peddler 4.2.0 → 4.3.0

data/lib/peddler/parsers/openapi_parser_generator.rb

@@ -0,0 +1,550 @@
+# frozen_string_literal: true
+
+require "json"
+require "bigdecimal"
+
+module Peddler
+  module Parsers
+    # Check if Money gem is available for handling monetary values
+    begin
+      require "money"
+      MONEY_GEM_AVAILABLE = true
+
+      # Configure Money to avoid issues
+      Money.rounding_mode = BigDecimal::ROUND_HALF_UP
+
+      # Avoid locale issues by using currency backend
+      if Money.respond_to?(:locale_backend=)
+        Money.locale_backend = :currency
+      end
+    rescue LoadError
+      MONEY_GEM_AVAILABLE = false
+    end
+
+    # Use Structs to represent structured data in responses
+    DATA_TYPES = {
+      # Common Amazon data types that will be converted to structured objects
+      money: Struct.new(:currency, :amount, keyword_init: true),
+      dimension: Struct.new(:value, :unit, keyword_init: true),
+      address: Struct.new(
+        :name,
+        :address_line1,
+        :address_line2,
+        :city,
+        :state_or_region,
+        :postal_code,
+        :country_code,
+        :phone,
+        keyword_init: true,
+      ),
+      weight: Struct.new(:value, :unit, keyword_init: true),
+      daterange: Struct.new(:start, :end, keyword_init: true),
+      price: Struct.new(:currency_code, :amount, keyword_init: true),
+    }
+
+    # Generates response parsers based on Amazon's OpenAPI schemas
+    class OpenAPIParserGenerator
+      # OpenAPI Parser Generator error class
+      class Error < StandardError; end
+
+      # Error when schema cannot be parsed or is invalid
+      class InvalidSchemaError < Error; end
+
+      # Error when operation cannot be found
+      class OperationNotFoundError < Error; end
+
+      # Initialize the generator with an OpenAPI schema
+      #
+      # @param [String, Hash] schema The OpenAPI schema (file path or parsed hash)
+      # @raise [InvalidSchemaError] If the schema is invalid or cannot be parsed
+      def initialize(schema)
+        @schema = if schema.is_a?(String)
+          begin
+            JSON.parse(File.read(schema))
+          rescue JSON::ParserError => e
+            raise InvalidSchemaError, "Failed to parse schema JSON: #{e.message}"
+          rescue Errno::ENOENT => e
+            raise InvalidSchemaError, "Schema file not found: #{e.message}"
+          end
+        else
+          schema
+        end
+
+        # Basic validation of schema structure
+        unless @schema.is_a?(Hash) && @schema["paths"].is_a?(Hash)
+          raise InvalidSchemaError, "Invalid schema format: missing or invalid 'paths' property"
+        end
+      rescue NoMethodError => e
+        raise InvalidSchemaError, "Invalid schema structure: #{e.message}"
+      end
+
+      # Generate a parser class for a specific API operation
+      #
+      # @param [String] operation_id The OpenAPI operationId to generate a parser for
+      # @return [Class] A parser class configured for the operation's response schema
+      def generate_parser_for_operation(operation_id)
+        operation_schema = find_operation_schema(operation_id)
+        return unless operation_schema
+
+        # Use the actual operationId from the schema
+        actual_operation_id = operation_schema["operationId"]
+
+        response_schema = extract_response_schema(operation_schema)
+        return unless response_schema
+
+        create_parser_class(actual_operation_id, response_schema)
+      end
+
+      # Generate parsers for all operations in the schema
+      #
+      # @return [Hash<String, Class>] A map of operation IDs to parser classes
+      def generate_all_parsers
+        operations = find_all_operations
+        operations.each_with_object({}) do |(op_id, op_schema), parsers|
+          response_schema = extract_response_schema(op_schema)
+          next unless response_schema
+
+          parser_class = create_parser_class(op_id, response_schema)
+          parsers[op_id] = parser_class if parser_class
+        end
+      end
+
+      private
+
+      # Find the schema for a specific operation
+      #
+      # @param [String] operation_id The operation ID to find
+      # @return [Hash, nil] The operation schema if found
+      def find_operation_schema(operation_id)
+        return unless @schema["paths"]
+
+        @schema["paths"].each_value do |path_item|
+          ["get", "post", "put", "delete", "patch"].each do |method|
+            next unless path_item[method]
+
+            # Amazon SP-API sometimes uses camelCase for operation IDs
+            op = path_item[method]
+            op_id = op["operationId"]
+
+            # Try exact match first
+            return op if op_id == operation_id
+
+            # Try case-insensitive match as fallback
+            return op if op_id.to_s.downcase == operation_id.to_s.downcase
+
+            # Try camelCase to snake_case conversion
+            snake_case_id = op_id.to_s.gsub(/([A-Z])/, '_\1').downcase.sub(/^_/, "")
+            return op if snake_case_id == operation_id.to_s.downcase
+          end
+        end
+        nil
+      end
+
+      # Find all operations in the schema
+      #
+      # @return [Hash<String, Hash>] Map of operation IDs to operation schemas
+      def find_all_operations
+        result = {}
+        @schema["paths"].each_value do |path_item|
+          ["get", "post", "put", "delete", "patch"].each do |method|
+            next unless path_item[method]
+
+            operation = path_item[method]
+            result[operation["operationId"]] = operation if operation["operationId"]
+          end
+        end
+        result
+      end
+
+      # Extract the response schema from an operation
+      #
+      # @param [Hash] operation_schema The operation schema
+      # @return [Hash, nil] The response schema if found
+      def extract_response_schema(operation_schema)
+        return unless operation_schema["responses"]
+
+        # Try to get 200 response first, then any 2xx response
+        response = operation_schema["responses"]["200"] ||
+          operation_schema["responses"].find { |k, _| k.to_s.start_with?("2") }&.last
+
+        return unless response
+
+        # Amazon SP-API might have different formats
+        if response["content"] && response["content"]["application/json"]
+          # Standard OpenAPI 3.0 format
+          response["content"]["application/json"]["schema"]
+        elsif response["schema"]
+          # Some Amazon models use a direct schema property
+          response["schema"]
+        elsif response["$ref"]
+          # Some models use a reference
+          resolve_reference(response["$ref"])
+        end
+      end
+
+      # Resolve a JSON Schema reference
+      #
+      # @param [String] ref The reference string (e.g., "#/components/schemas/Order")
+      # @return [Hash, nil] The resolved schema or nil if not found
+      def resolve_reference(ref)
+        return unless ref.is_a?(String) && ref.start_with?("#/")
+
+        path = ref[2..-1].split("/")
+        current = @schema
+
+        path.each do |segment|
+          return nil unless current[segment]
+
+          current = current[segment]
+        end
+
+        current
+      end
+
+      # Create a parser class for a specific operation and schema
+      #
+      # @param [String] operation_id The operation ID
+      # @param [Hash] response_schema The response schema
+      # @return [Class] A parser class for the operation
+      def create_parser_class(operation_id, response_schema)
+        # Store a reference to the generator for resolving references
+        generator = self
+
+        Class.new do
+          # Store schema and operation ID as class methods
+          define_singleton_method(:schema) { response_schema }
+          define_singleton_method(:operation_id) { operation_id }
+
+          # Store a reference to the generator for resolving nested references
+          define_singleton_method(:generator) { generator }
+
+          # Initialize the parser
+          #
+          # @param [Hash] options Parser options
+          def initialize(options = {})
+            @options = options
+            @symbolize_keys = options.fetch(:symbolize_keys, false)
+          end
+
+          # Parse the HTTP response
+          #
+          # @param [HTTP::Response] response The HTTP response
+          # @return [Hash] The parsed response
+          def call(response)
+            @parsed_response = JSON.parse(response.body.to_s)
+            transform_response(self.class.schema, @parsed_response)
+          end
+
+          # Convert the response to a hash
+          #
+          # @return [Hash] The parsed response hash
+          def to_h
+            @parsed_response
+          end
+
+          private
+
+          # Transform the response based on the schema
+          #
+          # @param [Hash] schema The schema for the current part of the response
+          # @param [Hash, Array, Object] data The data to transform
+          # @return [Hash, Array, Object] The transformed data
+          def transform_response(schema, data)
+            case data
+            when Hash
+              transform_hash(schema, data)
+            when Array
+              transform_array(schema, data)
+            else
+              transform_primitive(schema, data)
+            end
+          end
+
+          # Transform a hash based on its schema
+          #
+          # @param [Hash] schema The schema for the hash
+          # @param [Hash] hash The hash to transform
+          # @return [Hash, Data] The transformed hash or Data object
+          def transform_hash(schema, hash)
+            # Resolve schema reference if present
+            if schema["$ref"] && self.class.generator
+              ref_schema = self.class.generator.send(:resolve_reference, schema["$ref"])
+              schema = ref_schema if ref_schema
+            end
+
+            # First, check if this hash represents a known type that should be converted to a Data object
+            data_type = determine_data_type(schema, hash)
+            return transform_to_data_object(data_type, hash) if data_type
+
+            # Otherwise, process as a regular hash
+            result = @symbolize_keys ? {} : hash.class.new
+
+            hash.each do |k, v|
+              key = @symbolize_keys ? k.to_sym : k
+
+              # Get property schema, possibly resolving references
+              property_schema = nil
+              if schema["properties"] && schema["properties"][k]
+                property_schema = schema["properties"][k]
+
+                # Resolve property schema reference if present
+                if property_schema["$ref"] && self.class.generator
+                  ref_schema = self.class.generator.send(:resolve_reference, property_schema["$ref"])
+                  property_schema = ref_schema if ref_schema
+                end
+              end
+
+              # Special handling for known Amazon types
+              transformed = if money_type?(property_schema)
+                transform_money(v)
+              elsif datetime_type?(property_schema, k)
+                transform_datetime(v)
+              elsif dimension_type?(property_schema)
+                transform_dimension(v)
+              elsif address_type?(property_schema)
+                transform_address(v)
+              else
+                transform_response(property_schema || {}, v)
+              end
+
+              result[key] = transformed
+            end
+
+            result
+          end
+
+          # Determine if a hash should be converted to a Data object
+          #
+          # @param [Hash] schema The schema for the hash
+          # @param [Hash] hash The hash to transform
+          # @return [Symbol, nil] The Data type to use, or nil if not a recognized type
+          def determine_data_type(schema, hash)
+            return :money if money_type?(schema) ||
+              (hash.key?("CurrencyCode") && hash.key?("Amount"))
+
+            return :dimension if dimension_type?(schema) ||
+              (hash.key?("Value") && hash.key?("Unit"))
+
+            return :address if address_type?(schema) ||
+              (hash.key?("City") && hash.key?("PostalCode") &&
+               hash.key?("CountryCode"))
+
+            return :weight if hash.key?("Value") && hash.key?("Unit") &&
+              schema.dig("properties", "Unit", "enum")&.include?("pounds")
+
+            return :daterange if hash.key?("Start") && hash.key?("End") &&
+              schema.dig("properties", "Start", "type") == "string" &&
+              schema.dig("properties", "End", "type") == "string"
+
+            nil
+          end
+
+          # Transform a hash to a structured object
+          #
+          # @param [Symbol] data_type The type of structured object to create
+          # @param [Hash] hash The hash to transform
+          # @return [Struct] The structured object
+          def transform_to_data_object(data_type, hash)
+            data_class = DATA_TYPES[data_type]
+            return transform_response({}, hash) unless data_class
+
+            case data_type
+            when :money
+              if defined?(Money) && MONEY_GEM_AVAILABLE
+                # Use Money gem for monetary values if available
+                amount_cents = (BigDecimal(hash["Amount"]) * 100).to_i
+                Money.new(amount_cents, hash["CurrencyCode"])
+              else
+                # Use Struct as fallback
+                data_class.new(
+                  currency: hash["CurrencyCode"],
+                  amount: BigDecimal(hash["Amount"]),
+                )
+              end
+            when :dimension, :weight
+              data_class.new(
+                value: numeric_value(hash["Value"]),
+                unit: hash["Unit"],
+              )
+            when :address
+              data_class.new(
+                name: hash["Name"],
+                address_line1: hash["AddressLine1"],
+                address_line2: hash["AddressLine2"],
+                city: hash["City"],
+                state_or_region: hash["StateOrRegion"],
+                postal_code: hash["PostalCode"],
+                country_code: hash["CountryCode"],
+                phone: hash["Phone"],
+              )
+            when :daterange
+              start_date = transform_datetime(hash["Start"])
+              end_date = transform_datetime(hash["End"])
+              data_class.new(
+                start: start_date,
+                end: end_date,
+              )
+            when :price
+              data_class.new(
+                currency_code: hash["CurrencyCode"],
+                amount: numeric_value(hash["Amount"]),
+              )
+            else
+              # If we don't recognize the type, just process normally
+              transform_response({}, hash)
+            end
+          end
+
+          # Helper to convert string values to numeric when appropriate
+          #
+          # @param [String] value The value to convert
+          # @return [Numeric] The converted numeric value
+          def numeric_value(value)
+            return value if value.is_a?(Numeric)
+
+            value.to_f
+          end
+
+          # Transform an array based on its schema
+          #
+          # @param [Hash] schema The schema for the array
+          # @param [Array] array The array to transform
+          # @return [Array] The transformed array
+          def transform_array(schema, array)
+            items_schema = schema["items"] || {}
+            array.map { |item| transform_response(items_schema, item) }
+          end
+
+          # Transform a primitive value based on its schema
+          #
+          # @param [Hash] schema The schema for the value
+          # @param [Object] value The value to transform
+          # @return [Object] The transformed value
+          def transform_primitive(schema, value)
+            case schema["type"]
+            when "number", "integer"
+              value.to_f
+            when "boolean"
+              value == true || value == "true"
+            else
+              value
+            end
+          end
+
+          # Check if a schema represents a money type
+          #
+          # @param [Hash] schema The schema to check
+          # @return [Boolean] True if the schema represents money
+          def money_type?(schema)
+            return false unless schema && schema["properties"]
+
+            schema["properties"]["CurrencyCode"] &&
+              schema["properties"]["Amount"]
+          end
+
+          # Transform a money object
+          #
+          # @param [Hash] money The money hash to transform
+          # @return [Money, Hash] Money object if gem available, otherwise a hash
+          def transform_money(money)
+            currency_code = money["CurrencyCode"]
+            amount_str = money["Amount"]
+
+            if defined?(Money) && MONEY_GEM_AVAILABLE
+              # Convert to cents (Money uses cents as its base unit)
+              amount_cents = (BigDecimal(amount_str) * 100).to_i
+
+              # Create Money object with the specified currency
+              Money.new(amount_cents, currency_code)
+            else
+              # Fallback when Money gem is not available
+              amount = BigDecimal(amount_str)
+              keys = @symbolize_keys ? [:currency, :amount] : ["currency", "amount"]
+              {
+                keys[0] => currency_code,
+                keys[1] => amount,
+              }
+            end
+          end
+
+          # Check if a schema represents a datetime
+          #
+          # @param [Hash] schema The schema to check
+          # @param [String] key The key name
+          # @return [Boolean] True if the schema represents a datetime
+          def datetime_type?(schema, key)
+            return false unless schema && schema["type"] == "string"
+
+            schema["format"] == "date-time" ||
+              key.end_with?("Date", "Time", "At")
+          end
+
+          # Transform a datetime string
+          #
+          # @param [String] datetime The datetime string
+          # @return [DateTime] The parsed datetime
+          def transform_datetime(datetime)
+            # Convert to DateTime for consistent API usage
+            # even though RuboCop prefers Time
+            DateTime.parse(datetime)
+          rescue
+            datetime
+          end
+
+          # Check if a schema represents a dimension
+          #
+          # @param [Hash] schema The schema to check
+          # @return [Boolean] True if the schema represents a dimension
+          def dimension_type?(schema)
+            return false unless schema && schema["properties"]
+
+            schema["properties"]["Value"] &&
+              schema["properties"]["Unit"]
+          end
+
+          # Check if a schema represents an address
+          #
+          # @param [Hash] schema The schema to check
+          # @return [Boolean] True if the schema represents an address
+          def address_type?(schema)
+            return false unless schema && schema["properties"]
+
+            # Check for common address fields
+            address_fields = ["City", "PostalCode", "CountryCode"]
+            address_fields.all? { |field| schema["properties"][field] }
+          end
+
+          # Transform a dimension object
+          #
+          # @param [Hash] dimension The dimension hash to transform
+          # @return [Hash] The transformed dimension object
+          def transform_dimension(dimension)
+            keys = @symbolize_keys ? [:value, :unit] : ["value", "unit"]
+            {
+              keys[0] => dimension["Value"].to_f,
+              keys[1] => dimension["Unit"],
+            }
+          end
+
+          # Transform an address object
+          #
+          # @param [Hash] address The address hash to transform
+          # @return [Struct] A Struct representing the address
+          def transform_address(address)
+            # Create an Address Struct
+            DATA_TYPES[:address].new(
+              name: address["Name"],
+              address_line1: address["AddressLine1"],
+              address_line2: address["AddressLine2"],
+              city: address["City"],
+              state_or_region: address["StateOrRegion"],
+              postal_code: address["PostalCode"],
+              country_code: address["CountryCode"],
+              phone: address["Phone"],
+            )
+          end
+        end
+      end
+    end
+  end
+end