Add dynamic charge model & validator

Add Charge model + extend properties service to support new charge model

app/models/charge.rb

@@ -24,6 +24,7 @@ class Charge < ApplicationRecord
     volume
     graduated_percentage
     custom
+    dynamic
   ].freeze
 
   REGROUPING_PAID_FEES_OPTIONS = %i[invoice].freeze
@@ -37,6 +38,7 @@ class Charge < ApplicationRecord
   validate :validate_percentage, if: -> { percentage? }
   validate :validate_volume, if: -> { volume? }
   validate :validate_graduated_percentage, if: -> { graduated_percentage? }
+  validate :validate_dynamic, if: -> { dynamic? }
 
   validates :min_amount_cents, numericality: {greater_than_or_equal_to: 0}, allow_nil: true
   validates :charge_model, presence: true
@@ -79,6 +81,10 @@ def validate_graduated_percentage
     validate_charge_model(Charges::Validators::GraduatedPercentageService)
   end
 
+  def validate_dynamic
+    validate_charge_model(Charges::Validators::DynamicService)
+  end
+
   def validate_charge_model(validator)
     instance = validator.new(charge: self)
     return if instance.valid?

app/models/clickhouse/events_raw.rb

@@ -10,11 +10,12 @@ class EventsRaw < BaseRecord
 #
 # Table name: events_raw
 #
-#  code                     :string           not null
-#  properties               :string           not null
-#  timestamp                :datetime         not null
-#  external_customer_id     :string           not null
-#  external_subscription_id :string           not null
-#  organization_id          :string           not null
-#  transaction_id           :string           not null
+#  code                       :string           not null
+#  precise_total_amount_cents :decimal(40, 15)
+#  properties                 :string           not null
+#  timestamp                  :datetime         not null
+#  external_customer_id       :string           not null
+#  external_subscription_id   :string           not null
+#  organization_id            :string           not null
+#  transaction_id             :string           not null
 #

app/services/base_service.rb

@@ -170,6 +170,10 @@ def call_async(**args, &block)
     raise NotImplementedError
   end
 
+  protected
+
+  attr_writer :result
+
   private
 
   attr_reader :result, :source

app/services/billable_metrics/aggregations/base_service.rb

@@ -26,6 +26,10 @@ def aggregate(options: {})
         else
           compute_aggregation(options:)
         end
+        if charge.dynamic?
+          compute_precise_total_amount_cents(options:)
+        end
+        result
       end
 
       def compute_aggregation(options: {})
@@ -36,6 +40,10 @@ def compute_grouped_by_aggregation(options: {})
         raise NotImplementedError
       end
 
+      def compute_precise_total_amount_cents(options: {})
+        raise NotImplementedError
+      end
+
       def per_event_aggregation(exclude_event: false)
         Result.new.tap do |result|
           result.event_aggregation = compute_per_event_aggregation(exclude_event:)

app/services/billable_metrics/aggregations/sum_service.rb

@@ -4,7 +4,7 @@ module BillableMetrics
   module Aggregations
     class SumService < BillableMetrics::Aggregations::BaseService
       def initialize(...)
-        super(...)
+        super
 
         event_store.numeric_property = true
         event_store.aggregation_property = billable_metric.field_name
@@ -64,6 +64,10 @@ def compute_grouped_by_aggregation(options: {})
         result.service_failure!(code: 'aggregation_failure', message: e.message)
       end
 
+      def compute_precise_total_amount_cents(options: {})
+        result.precise_total_amount_cents = event_store.sum_precise_total_amount_cents
+      end
+
       # NOTE: Return cumulative sum of field_name based on the number of free units
       #       (per_events or per_total_aggregation).
       def running_total(options)

app/services/billable_metrics/prorated_aggregations/sum_service.rb

@@ -4,9 +4,9 @@ module BillableMetrics
   module ProratedAggregations
     class SumService < BillableMetrics::ProratedAggregations::BaseService
       def initialize(**args)
+        super
         @base_aggregator = BillableMetrics::Aggregations::SumService.new(**args)
-
-        super(**args)
+        @base_aggregator.result = result
 
         event_store.numeric_property = true
         event_store.aggregation_property = billable_metric.field_name

app/services/billable_metrics/prorated_aggregations/unique_count_service.rb

@@ -4,9 +4,10 @@ module BillableMetrics
   module ProratedAggregations
     class UniqueCountService < BillableMetrics::ProratedAggregations::BaseService
       def initialize(**args)
-        @base_aggregator = BillableMetrics::Aggregations::UniqueCountService.new(**args)
+        super
 
-        super(**args)
+        @base_aggregator = BillableMetrics::Aggregations::UniqueCountService.new(**args)
+        @base_aggregator.result = result
 
         event_store.aggregation_property = billable_metric.field_name
         event_store.use_from_boundary = !billable_metric.recurring

app/services/charges/build_default_properties_service.rb

@@ -15,6 +15,7 @@ def call
       when :percentage then default_percentage_properties
       when :volume then default_volume_properties
       when :graduated_percentage then default_graduated_percentage_properties
+      when :dynamic then default_dynamic_properties
       end
     end
 
@@ -77,5 +78,9 @@ def default_graduated_percentage_properties
         ]
       }
     end
+
+    def default_dynamic_properties
+      {}
+    end
   end
 end

app/services/charges/charge_model_factory.rb

@@ -30,6 +30,8 @@ def self.charge_model_class(charge:, aggregation_result:, properties:)
         Charges::ChargeModels::VolumeService
       when :custom
         Charges::ChargeModels::CustomService
+      when :dynamic
+        Charges::ChargeModels::DynamicService
       else
         raise(NotImplementedError)
       end

app/services/charges/charge_models/dynamic_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Charges
+  module ChargeModels
+    class DynamicService < Charges::ChargeModels::BaseService
+      protected
+
+      def compute_amount
+        total_units = aggregation_result.full_units_number || units
+        return 0 if total_units.zero?
+
+        aggregation_result.precise_total_amount_cents
+      end
+
+      def unit_amount
+        # eventhough `full_units_number` is not set by the SumService, we still keep this code as is, to be future proof
+        total_units = aggregation_result.full_units_number || units
+        return 0 if total_units.zero?
+
+        compute_amount / total_units
+      end
+    end
+  end
+end

app/services/charges/validators/dynamic_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Charges
+  module Validators
+    class DynamicService < Charges::Validators::BaseService
+      def valid?
+        validate_billable_metric
+
+        super
+      end
+
+      private
+
+      def validate_billable_metric
+        # Only sum aggregation is compatible with Dynamic Pricing for now
+        return if charge.billable_metric.sum_agg?
+
+        add_error(field: :billable_metric, error_code: 'invalid_billable_metric_value')
+      end
+    end
+  end
+end

app/services/events/stores/clickhouse_store.rb

@@ -4,7 +4,9 @@ module Events
   module Stores
     class ClickhouseStore < BaseStore
       DECIMAL_SCALE = 26
-      DEDUPLICATION_GROUP = "events_raw.transaction_id, events_raw.properties, events_raw.timestamp"
+
+      DEDUPLICATION_GROUP = 'events_raw.transaction_id, events_raw.properties, events_raw.timestamp'
+      PRECISE_TOTAL_AMOUNT_DEDUPLICATION_GROUP = 'events_raw.transaction_id, events_raw.precise_total_amount_cents, events_raw.timestamp'
 
       # NOTE: keeps in mind that events could contains duplicated transaction_id
       #       and should be deduplicated depending on the aggregation logic
@@ -264,6 +266,21 @@ def grouped_last
         prepare_grouped_result(::Clickhouse::EventsRaw.connection.select_all(sql).rows)
       end
 
+      def sum_precise_total_amount_cents
+        cte_sql = events.group(PRECISE_TOTAL_AMOUNT_DEDUPLICATION_GROUP)
+          .select(Arel.sql("precise_total_amount_cents as property"))
+          .to_sql
+
+        sql = <<-SQL
+          with events as (#{cte_sql})
+
+          select sum(events.property)
+          from events
+        SQL
+
+        ::Clickhouse::EventsRaw.connection.select_value(sql)
+      end
+
       def sum
         cte_sql = events.group(DEDUPLICATION_GROUP)
           .select(Arel.sql("#{sanitized_numeric_property} AS property"))

app/services/events/stores/postgres_store.rb

@@ -188,6 +188,10 @@ def grouped_last
         prepare_grouped_result(Event.connection.select_all(sql).rows)
       end
 
+      def sum_precise_total_amount_cents
+        events.sum(:precise_total_amount_cents)
+      end
+
       def sum
         events.sum("(#{sanitized_property_name})::numeric")
       end

db/clickhouse_migrate/20240923124501_add_precise_total_amount_cents_to_events.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddPreciseTotalAmountCentsToEvents < ActiveRecord::Migration[7.1]
+  def change
+    add_column :events_raw, :precise_total_amount_cents, :decimal, precision: 40, scale: 15
+  end
+end

spec/factories/charges.rb

@@ -53,6 +53,14 @@
       end
     end
 
+    factory :dynamic_charge do
+      charge_model { 'dynamic' }
+      billable_metric { create(:sum_billable_metric) }
+      properties do
+        {}
+      end
+    end
+
     factory :graduated_percentage_charge do
       charge_model { 'graduated_percentage' }
       properties do

spec/models/charge_spec.rb

@@ -297,6 +297,58 @@
     end
   end
 
+  describe '#validate_dynamic' do
+    subject(:charge) { build(:dynamic_charge) }
+
+    let(:validation_service) { instance_double(Charges::Validators::DynamicService) }
+
+    let(:service_response) do
+      BaseService::Result.new.validation_failure!(
+        errors: {
+          billable_metric: ['invalid_billable_metric_value']
+        }
+      )
+    end
+
+    it 'delegates to a validation service' do
+      allow(Charges::Validators::DynamicService).to receive(:new)
+        .and_return(validation_service)
+      allow(validation_service).to receive(:valid?)
+        .and_return(false)
+      allow(validation_service).to receive(:result)
+        .and_return(service_response)
+
+      aggregate_failures do
+        expect(charge).not_to be_valid
+        expect(charge.errors.messages.keys).to include(:properties)
+        expect(charge.errors.messages[:properties]).to include('invalid_billable_metric_value')
+
+        expect(Charges::Validators::DynamicService).to have_received(:new).with(charge:)
+        expect(validation_service).to have_received(:valid?)
+        expect(validation_service).to have_received(:result)
+      end
+    end
+
+    context 'when charge model is not dynamic' do
+      subject(:charge) { build(:standard_charge) }
+
+      it 'does not apply the validation' do
+        allow(Charges::Validators::DynamicService).to receive(:new)
+          .and_return(validation_service)
+        allow(validation_service).to receive(:valid?)
+          .and_return(false)
+        allow(validation_service).to receive(:result)
+          .and_return(service_response)
+
+        charge.valid?
+
+        expect(Charges::Validators::DynamicService).not_to have_received(:new)
+        expect(validation_service).not_to have_received(:valid?)
+        expect(validation_service).not_to have_received(:result)
+      end
+    end
+  end
+
   describe '#validate_graduated_percentage' do
     subject(:charge) do
       build(:graduated_percentage_charge, properties: charge_properties)