profitable 0.2.3 → 0.4.0

data/lib/profitable/json_helpers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Profitable
+  module JsonHelpers
+    # Regex patterns for validating SQL identifiers to prevent SQL injection
+    # Only allows: alphanumeric characters, underscores, and dots (for table.column format)
+    VALID_TABLE_COLUMN_PATTERN = /\A[a-zA-Z_][a-zA-Z0-9_.]*\z/
+    VALID_JSON_KEY_PATTERN = /\A[a-zA-Z_][a-zA-Z0-9_]*\z/
+
+    # Returns the appropriate JSON extraction syntax for the current database adapter
+    # Supports PostgreSQL, MySQL (5.7.9+), and SQLite
+    #
+    # @param table_column [String] The table and column name (e.g., 'pay_charges.object')
+    # @param json_key [String] The JSON key to extract (e.g., 'paid', 'status')
+    # @return [String] Database-specific SQL for JSON extraction
+    # @raise [ArgumentError] if table_column or json_key contain invalid characters
+    #
+    # @example PostgreSQL
+    #   json_extract('pay_charges.object', 'paid')
+    #   # => "pay_charges.object ->> 'paid'"
+    #
+    # @example MySQL
+    #   json_extract('pay_charges.object', 'paid')
+    #   # => "JSON_UNQUOTE(JSON_EXTRACT(pay_charges.object, '$.paid'))"
+    #
+    # @example SQLite
+    #   json_extract('pay_charges.object', 'paid')
+    #   # => "json_extract(pay_charges.object, '$.paid')"
+    def json_extract(table_column, json_key)
+      # Validate inputs to prevent SQL injection
+      validate_table_column!(table_column)
+      validate_json_key!(json_key)
+
+      adapter = ActiveRecord::Base.connection.adapter_name.downcase
+
+      case adapter
+      when /postgres/
+        "#{table_column} ->> '#{json_key}'"
+      when /mysql/, /trilogy/
+        # MySQL 5.7.9+ supports JSON_EXTRACT and ->> operator
+        # We use JSON_UNQUOTE(JSON_EXTRACT()) for maximum compatibility
+        "JSON_UNQUOTE(JSON_EXTRACT(#{table_column}, '$.#{json_key}'))"
+      when /sqlite/
+        "json_extract(#{table_column}, '$.#{json_key}')"
+      else
+        # Fallback to PostgreSQL syntax for unknown adapters
+        Rails.logger.warn("Unknown database adapter '#{adapter}' for JSON extraction. Falling back to PostgreSQL syntax.")
+        "#{table_column} ->> '#{json_key}'"
+      end
+    end
+
+    private
+
+    def validate_table_column!(table_column)
+      unless table_column.is_a?(String) && table_column.match?(VALID_TABLE_COLUMN_PATTERN)
+        raise ArgumentError, "Invalid table_column format: #{table_column.inspect}. " \
+          "Must be alphanumeric with underscores/dots only (e.g., 'pay_charges.object')."
+      end
+    end
+
+    def validate_json_key!(json_key)
+      unless json_key.is_a?(String) && json_key.match?(VALID_JSON_KEY_PATTERN)
+        raise ArgumentError, "Invalid json_key format: #{json_key.inspect}. " \
+          "Must be alphanumeric with underscores only (e.g., 'paid', 'status')."
+      end
+    end
+  end
+end

data/lib/profitable/mrr_calculator.rb

@@ -10,7 +10,7 @@ module Profitable
       total_mrr = 0
       subscriptions = Pay::Subscription
         .active
-        .where.not(status: ['trialing', 'paused'])
+        .where.not(status: Profitable::EXCLUDED_STATUSES)
         .includes(:customer)
         .select('pay_subscriptions.*, pay_customers.processor as customer_processor')
         .joins(:customer)
@@ -27,9 +27,13 @@ module Profitable
     end
 
     def self.process_subscription(subscription)
-      return 0 if subscription.nil? || subscription.data.nil?
+      return 0 if subscription.nil?
+      return 0 if subscription_data(subscription).nil?
 
-      processor_class = processor_for(subscription.customer_processor)
+      # Get processor from virtual attribute (set by .select() in queries) or from customer association
+      processor_name = subscription.try(:customer_processor) || subscription.customer&.processor
+
+      processor_class = processor_for(processor_name)
       mrr = processor_class.new(subscription).calculate_mrr
 
       # Ensure MRR is a non-negative number
@@ -39,6 +43,12 @@ module Profitable
       0
     end
 
+    # Pay gem v10+ stores Stripe objects in the `object` column,
+    # while older versions used `data`. This method provides backwards compatibility.
+    def self.subscription_data(subscription)
+      subscription.try(:object) || subscription.try(:data)
+    end
+
     def self.processor_for(processor_name)
       case processor_name
       when 'stripe'

data/lib/profitable/processors/base.rb

@@ -13,22 +13,45 @@ module Profitable
 
       protected
 
+      # Pay gem v10+ stores Stripe objects in the `object` column,
+      # while older versions used `data`. This method provides backwards compatibility.
+      def subscription_data
+        subscription.try(:object) || subscription.try(:data)
+      end
+
+      # Converts a billing amount to its monthly equivalent rate.
+      #
+      # Uses floating-point arithmetic for precision during calculation,
+      # then rounds to the nearest integer cent at the end. This approach
+      # ensures accurate rounding for fractional results (e.g., $100/year = $8.33/month = 833 cents).
+      #
+      # @param amount [Integer, String] The billing amount in cents
+      # @param interval [String] The billing interval ('day', 'week', 'month', 'year')
+      # @param interval_count [Integer, String] How many intervals per billing cycle
+      # @return [Integer] The monthly amount in cents (always a non-negative integer)
       def normalize_to_monthly(amount, interval, interval_count)
         return 0 if amount.nil? || interval.nil? || interval_count.nil?
 
-        case interval.to_s.downcase
+        # Ensure interval_count is converted to integer before division
+        interval_count_int = interval_count.to_i
+        return 0 if interval_count_int.zero?
+
+        # Calculate using floats for precision, round at the end for integer cents
+        monthly_amount = case interval.to_s.downcase
         when 'day'
-          amount * 30.0 / interval_count
+          amount.to_f * 30 / interval_count_int
         when 'week'
-          amount * 4.0 / interval_count
+          amount.to_f * 4 / interval_count_int
         when 'month'
-          amount / interval_count
+          amount.to_f / interval_count_int
         when 'year'
-          amount / (12.0 * interval_count)
+          amount.to_f / (12 * interval_count_int)
         else
           Rails.logger.warn("Unknown interval for MRR calculation: #{interval}")
           0
         end
+
+        monthly_amount.round  # Return integer cents
       end
     end
   end

data/lib/profitable/processors/braintree_processor.rb

@@ -2,10 +2,15 @@ module Profitable
   module Processors
     class BraintreeProcessor < Base
       def calculate_mrr
-        amount = subscription.data['price']
+        data = subscription_data
+        return 0 if data.nil?
+
+        amount = data['price']
+        return 0 if amount.nil?
+
         quantity = subscription.quantity || 1
-        interval = subscription.data['billing_period_unit']
-        interval_count = subscription.data['billing_period_frequency'] || 1
+        interval = data['billing_period_unit']
+        interval_count = data['billing_period_frequency'] || 1
 
         normalize_to_monthly(amount * quantity, interval, interval_count)
       end

data/lib/profitable/processors/paddle_billing_processor.rb

@@ -2,15 +2,30 @@ module Profitable
   module Processors
     class PaddleBillingProcessor < Base
       def calculate_mrr
-        price_data = subscription.data['items']&.first&.dig('price')
-        return 0 if price_data.nil?
+        data = subscription_data
+        return 0 if data.nil?
 
-        amount = price_data['unit_price']['amount']
-        quantity = subscription.quantity || 1
-        interval = price_data['billing_cycle']['interval']
-        interval_count = price_data['billing_cycle']['frequency']
+        items = data['items']
+        return 0 if items.nil? || items.empty?
 
-        normalize_to_monthly(amount * quantity, interval, interval_count)
+        # Sum MRR from ALL subscription items
+        total_mrr = 0
+
+        items.each do |item|
+          price_data = item['price']
+          next if price_data.nil?
+
+          amount = price_data.dig('unit_price', 'amount')
+          next if amount.nil?
+
+          item_quantity = item['quantity'] || 1
+          interval = price_data.dig('billing_cycle', 'interval')
+          interval_count = price_data.dig('billing_cycle', 'frequency')
+
+          total_mrr += normalize_to_monthly(amount * item_quantity, interval, interval_count)
+        end
+
+        total_mrr
       end
     end
   end

data/lib/profitable/processors/paddle_classic_processor.rb

@@ -2,9 +2,14 @@ module Profitable
   module Processors
     class PaddleClassicProcessor < Base
       def calculate_mrr
-        amount = subscription.data['recurring_price']
+        data = subscription_data
+        return 0 if data.nil?
+
+        amount = data['recurring_price']
+        return 0 if amount.nil?
+
         quantity = subscription.quantity || 1
-        interval = subscription.data['recurring_interval']
+        interval = data['recurring_interval']
         interval_count = 1 # Paddle Classic doesn't have interval_count
 
         normalize_to_monthly(amount * quantity, interval, interval_count)

data/lib/profitable/processors/stripe_processor.rb

@@ -2,18 +2,34 @@ module Profitable
   module Processors
     class StripeProcessor < Base
       def calculate_mrr
-        subscription_items = subscription.data['subscription_items']
+        data = subscription_data
+        return 0 if data.nil?
+
+        # Pay gem v10+ stores items at object['items']['data']
+        # Older versions stored at data['subscription_items']
+        subscription_items = data.dig('items', 'data') || data['subscription_items']
         return 0 if subscription_items.nil? || subscription_items.empty?
 
-        price_data = subscription_items[0]['price']
-        return 0 if price_data.nil?
+        # Sum MRR from ALL subscription items (not just the first one)
+        # Stripe subscriptions can have multiple line items
+        total_mrr = 0
+
+        subscription_items.each do |item|
+          price_data = item['price'] || item
+          next if price_data.nil?
+
+          amount = price_data['unit_amount']
+          next if amount.nil?
+
+          # Each item can have its own quantity
+          item_quantity = item['quantity'] || 1
+          interval = price_data.dig('recurring', 'interval')
+          interval_count = price_data.dig('recurring', 'interval_count') || 1
 
-        amount = price_data['unit_amount']
-        quantity = subscription.quantity || 1
-        interval = price_data.dig('recurring', 'interval')
-        interval_count = price_data.dig('recurring', 'interval_count') || 1
+          total_mrr += normalize_to_monthly(amount * item_quantity, interval, interval_count)
+        end
 
-        normalize_to_monthly(amount * quantity, interval, interval_count)
+        total_mrr
       end
     end
   end

data/lib/profitable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profitable
-  VERSION = "0.2.3"
+  VERSION = "0.4.0"
 end