sp_api_clients 2.0.0

data/lib/amazon_sp_clients/api_client.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require 'faraday'
+require 'amazon_sp_clients/adapter_loader'
+
+module AmazonSpClients
+  class ApiClient
+    # The Configuration object holding settings to be used in the API client.
+    attr_accessor :config
+
+    attr_accessor :connection
+
+    # Defines the headers to be used in HTTP requests of all API calls by
+    # default.
+    #
+    # @return [Hash]
+    attr_accessor :default_headers
+
+    # Initializes the ApiClient
+    # @option config [Configuration] Configuration for initializing the object,
+    # default to Configuration.default
+    def initialize(session, config = Configuration.default)
+      @session = session
+
+      @config = config
+      @user_agent = "Dropstream/1.0 (Language=Ruby/#{RUBY_VERSION})"
+      @default_headers = { 'Content-Type' => 'application/json', 'User-Agent' => @user_agent }
+      @connection =
+        Faraday.new(
+          url: @config.base_url,
+          headers: @default_headers,
+          request: {
+            timeout: @config.timeout
+          }
+        ) do |conn|
+          conn.adapter Faraday::Adapter::HTTPClient
+
+          conn.use AmazonSpClients::Middlewares::RaiseError, { service: :spapi }
+        end
+    end
+
+    # Call an API with given options.
+    #
+    # @return [Array<(Object, Integer, Hash)>] an array of 3 elements: the data
+    # deserialized from response body (could be nil), response status code and
+    # response headers.
+    def call_api(http_method, path, opts = {})
+      # Non standard usage of auth_names to determine if this is restricted access data kind
+      # of request:
+      restricted_resource = (Array(opts.delete(:auth_names)).first if opts.has_key?(:auth_names))
+
+      url, req_opts = build_request(http_method, path, opts)
+
+      raise 'Ensure session is valid before calling API methods' if @session.nil?
+
+      access_token = ''
+      if restricted_resource
+        @session.ask_for_restricted_data_token(restricted_resource)
+        access_token = @session.restricted_data_token[restricted_resource]
+      else
+        @session.refresh
+        access_token = @session.access_token
+      end
+
+      # Query params go through the request object: Faraday's post/put/
+      # patch helpers take (url, body), so a positional params argument
+      # would be treated as the body there and lost.
+      response =
+        @connection.send(req_opts[:method], url) do |req|
+          req.params.update(req_opts[:params])
+          req.body = req_opts[:body]
+          req.headers.merge!(req_opts[:headers])
+          req.headers.merge!(
+            {
+              'x-amz-date' => Time.now.utc.strftime('%Y%m%dT%H%M%SZ'),
+              'x-amz-access-token' => access_token
+            }
+          )
+        end
+
+      # Skipping error check and raise (use middleware for that instead)
+
+      (deserialize(response, opts[:return_type]) if opts[:return_type])
+    end
+
+    # Builds the HTTP request
+    #
+    # @param [String] http_method HTTP method/verb (e.g. POST)
+    # @param [String] path URL path (e.g. /account/new)
+    # @option opts [Hash] :header_params Header parameters
+    # @option opts [Hash] :query_params Query parameters
+    # @option opts [Hash] :form_params Query parameters
+    # @option opts [Object] :body HTTP body (JSON/XML)
+    # @return [Array(String, Hash)] the request url and options
+    def build_request(http_method, path, opts = {})
+      url = build_request_url(path)
+      http_method = http_method.to_sym.downcase
+
+      header_params = @default_headers.merge(opts[:header_params] || {})
+      query_params = opts[:query_params] || {}
+      form_params = opts[:form_params] || {}
+
+      req_opts = {
+        method: http_method,
+        headers: header_params,
+        params: query_params
+      }
+
+      if %i[post patch put delete].include?(http_method)
+        req_body = build_request_body(header_params, form_params, opts[:body])
+        req_opts.update body: req_body
+      end
+
+      [url, req_opts]
+    end
+
+    # Builds the HTTP request body
+    #
+    # @param [Hash] header_params Header parameters
+    # @param [Hash] form_params Query parameters
+    # @param [Object] body HTTP body (JSON/XML)
+    # @return [String] HTTP body data in the form of string
+    def build_request_body(header_params, form_params, body)
+      # http form
+      if ['application/x-www-form-urlencoded',
+          'multipart/form-data'].include?(header_params['Content-Type'])
+        data = {}
+        form_params.each do |key, value|
+          data[key] = case value
+                      when ::File, ::Array, nil
+                        # TODO: how does http lib support File and Array params?
+                        value
+                      else
+                        value.to_s
+                      end
+        end
+      elsif body
+        data = body.is_a?(String) ? body : body.to_json
+      else
+        data = nil
+      end
+      data
+    end
+
+    # Check if the given MIME is a JSON MIME.
+    # JSON MIME examples:
+    #   application/json
+    #   application/json; charset=UTF8
+    #   APPLICATION/JSON
+    #   */*
+    # @param [String] mime MIME
+    # @return [Boolean] True if the MIME is application/json
+    def json_mime?(mime)
+      (mime == '*/*') || !(mime =~ %r{Application/.*json(?!p)(;.*)?}i).nil?
+    end
+
+    # Deserialize the response to the given return type.
+    #
+    # @param [Response] response HTTP response
+    # @param [String] return_type some examples: "User", "Array<User>",
+    # "Hash<String, Integer>"
+    def deserialize(response, return_type)
+      body = response.body
+      body = JSON.parse(body, symbolize_names: true) if body.is_a?(String)
+
+      return nil if body.nil? || body.empty?
+
+      # return response body directly for String return type
+      return body if return_type == 'String'
+
+      # ensuring a default content type
+      content_type = response.headers['Content-Type'] || 'application/json'
+
+      raise "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+
+      begin
+        data = if body.is_a?(String)
+                 JSON.parse("[#{body}]", symbolize_names: true)[0]
+               else
+                 body
+               end
+      rescue JSON::ParserError => e
+        raise e unless %w[String Date DateTime].include?(return_type)
+
+        data = body
+      end
+
+      convert_to_type(data, return_type, response)
+    end
+
+    # Convert data to the given return type.
+    # @param [Object] data Data to be converted
+    # @param [String] return_type Return type
+    # @return [Mixed] Data in a particular type
+    def convert_to_type(data, return_type, response)
+      return nil if data.nil?
+
+      case return_type
+      when 'String'
+        data.to_s
+      when 'Integer'
+        data.to_i
+      when 'Float'
+        data.to_f
+      when 'Boolean'
+        data == true
+      when 'DateTime'
+        # parse date time (expecting ISO 8601 format)
+        DateTime.parse data
+      when 'Date'
+        # parse date time (expecting ISO 8601 format)
+        Date.parse data
+      when 'Object'
+        # generic object (usually a Hash), return directly
+        data
+      when /\AArray<(.+)>\z/
+        # e.g. Array<Pet>
+        sub_type = ::Regexp.last_match(1)
+        data.map { |item| convert_to_type(item, sub_type, response) }
+      when /\AHash<String, (.+)>\z/
+        # e.g. Hash<String, Integer>
+        sub_type = ::Regexp.last_match(1)
+        {}.tap { |hash| data.each { |k, v| hash[k] = convert_to_type(v, sub_type, response) } }
+      else
+        AmazonSpClients::ApiResponse.build_from_hash(data, response)
+      end
+    end
+
+    def build_request_url(path)
+      # Add leading and trailing slashes to path
+      path = "/#{path}".gsub(%r{/+}, '/')
+      @config.base_url + path
+    end
+
+    # Sets user agent in HTTP header
+    #
+    # @param [String] user_agent User agent (e.g. swagger-codegen/ruby/1.0.0)
+    def user_agent=(user_agent)
+      @user_agent = user_agent
+      @default_headers['User-Agent'] = @user_agent
+    end
+
+    # Return Accept header based on an array of accepts provided.
+    # @param [Array] accepts array for Accept
+    # @return [String] the Accept header (e.g. application/json)
+    def select_header_accept(accepts)
+      return nil if accepts.nil? || accepts.empty?
+
+      # use JSON when present, otherwise use all of the provided
+      json_accept = accepts.find { |s| json_mime?(s) }
+      json_accept || accepts.join(',')
+    end
+
+    # Return Content-Type header based on an array of content types provided.
+    # @param [Array] content_types array for Content-Type
+    # @return [String] the Content-Type header  (e.g. application/json)
+    def select_header_content_type(content_types)
+      # use application/json by default
+      return 'application/json' if content_types.nil? || content_types.empty?
+
+      # use JSON when present, otherwise use the first one
+      json_content_type = content_types.find { |s| json_mime?(s) }
+      json_content_type || content_types.first
+    end
+
+    # Convert object (array, hash, object, etc) to JSON string.
+    # @param [Object] model object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_http_body(model)
+      return model if model.nil? || model.is_a?(String)
+
+      local_body = if model.is_a?(Array)
+                     model.map { |m| object_to_hash(m) }
+                   else
+                     object_to_hash(model)
+                   end
+      local_body.to_json
+    end
+
+    # Convert object(non-array) to hash.
+    # @param [Object] obj object to be converted into JSON string
+    # @return [String] JSON string representation of the object
+    def object_to_hash(obj)
+      obj.respond_to?(:to_hash) ? obj.to_hash : obj
+    end
+
+    # Build parameter value according to the given collection format.
+    # @param [String] collection_format one of :csv, :ssv, :tsv, :pipes and :multi
+    def build_collection_param(param, collection_format)
+      case collection_format
+      when :csv
+        param.join(',')
+      when :ssv
+        param.join(' ')
+      when :tsv
+        param.join("\t")
+      when :pipes
+        param.join('|')
+      when :multi
+        # return the array directly as typhoeus will handle it as expected
+        param
+      else
+        raise "unknown collection format: #{collection_format.inspect}"
+      end
+    end
+  end
+end

data/lib/amazon_sp_clients/api_error.rb

@@ -0,0 +1,37 @@
+module AmazonSpClients
+  class ApiError
+    class Error < Struct.new(:code, :message, :details)
+    end
+
+    attr_reader :errors
+
+    # attr_reader :code, :response_headers, :errors
+
+    # SP API returns errors in this format:
+    #
+    #   {"errors"=>[{"code"=>"InvalidInput", "message"=>"Invalid Input"}]}
+    #
+    def initialize(errors)
+      @errors = []
+
+      errors = errors[:errors] if errors.is_a?(Hash) && errors.key?(:errors)
+
+      return unless errors.is_a?(Array)
+
+      @errors =
+        errors.map do |h|
+          AmazonSpClients::ApiError::Error.new(
+            h[:code],
+            h[:message],
+            h[:details]
+          )
+        end
+    end
+
+    def full_messages
+      @errors.map do |err|
+        "#{err.code}: #{err.message}#{' - ' + err.details if err.details}"
+      end.join(', ')
+    end
+  end
+end

data/lib/amazon_sp_clients/api_response.rb

@@ -0,0 +1,54 @@
+module AmazonSpClients
+  # The general response.
+  class ApiResponse
+    # Hash with response payload
+    attr_accessor :payload
+
+    # Hash with error response, nil otherwise
+    attr_accessor :errors
+
+    # Some APIs move :nextToken to separate top level key :pagination
+    attr_accessor :pagination
+
+    attr_reader :attributes, :response
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {}, response = nil)
+      @attributes = attributes
+      @response = response
+
+      unless attributes.is_a?(Hash)
+        raise ArgumentError,
+              'The input argument (attributes) must be a hash in `ApiResponse` initialize method'
+      end
+
+      # The envelope keys are always symbols: deserialize parses
+      # response bodies with symbolize_names.
+      if attributes.key?(:payload) || attributes.key?(:errors)
+        self.payload = attributes[:payload]
+        if attributes.key?(:errors)
+          self.errors = AmazonSpClients::ApiError.new(attributes.delete(:errors))
+        end
+        self.pagination = attributes[:pagination] if attributes.key?(:pagination)
+      else
+        self.payload = attributes
+      end
+    end
+
+    def reported_rate_limit
+      response_headers&.fetch('X-Amzn-Ratelimit-Limit', nil)&.to_f
+    end
+
+    def response_headers
+      @response&.headers
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes, response = nil)
+      new(attributes, response)
+    end
+  end
+end

data/lib/amazon_sp_clients/configuration.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module AmazonSpClients
+  class Configuration
+    # SP specific
+    attr_reader :marketplace_id
+    attr_reader :region
+
+    attr_reader :endpoint
+
+    # App credentials
+    attr_accessor :client_id
+    attr_accessor :client_secret
+
+    # Deprecated AWS/SigV4-era settings. Amazon dropped the SigV4
+    # requirement in October 2023. Accepted and ignored since 1.8.0;
+    # they go away together with the v1 API in a later major.
+    attr_accessor :credentials_provider
+    attr_accessor :access_key
+    attr_accessor :secret_key
+    attr_accessor :role_arn
+
+    # Defines url scheme
+    attr_accessor :scheme
+
+    # Defines url base path
+    attr_accessor :base_path
+
+    # Deprecated: the gem no longer logs. Accepted and ignored since 1.8.0;
+    # they go away together with the v1 API in a later major.
+    attr_accessor :debugging
+    attr_accessor :logger
+
+    # The time limit for HTTP request in seconds.
+    # Default to 0 (never times out).
+    attr_accessor :timeout
+
+    # Set this to false to skip client side validation in the operation.
+    # Default to true.
+    # @return [true, false]
+    attr_accessor :client_side_validation
+
+    def initialize
+      @sandbox_env = false
+
+      @credentials_provider = nil
+
+      @marketplace_id = nil
+
+      # iam
+      @role_arn = nil
+      @access_key = nil
+      @secret_key = nil
+
+      # app
+      @client_id = nil
+      @client_secret = nil
+
+      @endpoint = nil
+      @scheme = 'https'
+      @region = 'us-east-1'
+      @base_path = '/'
+      @timeout = 60
+      @client_side_validation = true
+      yield(self) if block_given?
+    end
+
+    # The default Configuration object.
+    def self.default
+      Thread.current[:amazon_sp_configuration] ||= Configuration.new
+    end
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def scheme=(scheme)
+      # remove :// from scheme
+      @scheme = scheme.sub(%r{://}, '')
+    end
+
+    def host
+      "#{'sandbox.' if @sandbox_env}#{AmazonSpClients::REGIONS.fetch(@region)}"
+    end
+
+    def base_path=(base_path)
+      # Add leading and trailing slashes to base_path
+      @base_path = "/#{base_path}".gsub(%r{/+}, '/')
+      @base_path = '' if @base_path == '/'
+    end
+
+    def base_url
+      "#{scheme}://#{[host, base_path].join('/').gsub(%r{/+}, '/')}".sub(%r{/+\z}, '')
+    end
+
+    def region=(region)
+      # The fetch validates the region; host is computed from it.
+      AmazonSpClients::REGIONS.fetch(region)
+      @region = region
+    end
+
+    # When sandbox mode is enabled, all requests will go to 'sandbox.' host.
+    def sandbox_env!
+      @sandbox_env = true
+    end
+
+    def disable_sandbox!
+      @sandbox_env = false
+    end
+
+    def set_endpoint_by_marketplace_id(marketplace_id)
+      # Validate before assigning so a bad id cannot corrupt state.
+      endpoint = AmazonSpClients::MARKETPLACE_ENDPOINT_MAP.fetch(marketplace_id)
+
+      @marketplace_id = marketplace_id
+      self.endpoint = endpoint
+    end
+
+    def endpoint=(str)
+      set_region_by_endpoint(str)
+      @endpoint = str
+    end
+
+    def set_region_by_endpoint(str)
+      self.region =
+        case str
+        when 'na'
+          AmazonSpClients::REGION_NA
+        when 'fe'
+          AmazonSpClients::REGION_FE
+        when 'eu'
+          AmazonSpClients::REGION_EU
+        when 'br', 'ca', 'mx', 'us'
+          AmazonSpClients::REGION_NA
+        when 'sg', 'au', 'jp'
+          AmazonSpClients::REGION_FE
+        when 'ae', 'de', 'eg', 'es', 'fr', 'gb', 'in', 'it', 'nl', 'sa', 'tr', 'pl', 'se'
+          AmazonSpClients::REGION_EU
+        else
+          raise ArgumentError, "unknown endpoint #{str.inspect}"
+        end
+    end
+  end
+end

data/lib/amazon_sp_clients/marketplaces.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# Region and marketplace tables. Shared by v1 and V2; depends on nothing.
+module AmazonSpClients
+  REGION_FE = 'us-west-2'
+  REGION_EU = 'eu-west-1'
+  REGION_NA = 'us-east-1'
+
+  REGIONS = {
+    REGION_NA => 'sellingpartnerapi-na.amazon.com',
+    REGION_EU => 'sellingpartnerapi-eu.amazon.com',
+    REGION_FE => 'sellingpartnerapi-fe.amazon.com'
+  }.freeze
+
+  MARKETPLACE_IDS = {
+    # NA
+    us: 'ATVPDKIKX0DER',
+    ca: 'A2EUQ1WTGCTBG2',
+    mx: 'A1AM78C64UM0Y8',
+    br: 'A2Q3Y263D00KWC',
+    # EU
+    es: 'A1RKKUPIHCS9HS',
+    gb: 'A1F83G8C2ARO7P',
+    fr: 'A13V1IB3VIYZZH',
+    nl: 'A1805IZSGTT6HS',
+    de: 'A1PA6795UKMFR9',
+    it: 'APJ6JRA9NG5V4',
+    se: 'A2NODRKZP88ZB9',
+    pl: 'A1C3SOZRARQ6R3',
+    eg: 'ARBP9OOSHTCHU',
+    tr: 'A33AVAJ2PDY3EV',
+    sa: 'A17E79C6D8DWNP',
+    ae: 'A2VIGQ35RCS4UG',
+    in: 'A21TJRUUN4KGV',
+    # FE
+    sg: 'A19VAU5U5O7RUS',
+    au: 'A39IBJ37TRP1C6',
+    jp: 'A1VC38T7YXB528'
+  }.freeze
+
+  MARKETPLACE_ENDPOINT_MAP = {
+    'A2EUQ1WTGCTBG2' => 'na',
+    'ATVPDKIKX0DER' => 'na',
+    'A1AM78C64UM0Y8' => 'na',
+    'A2Q3Y263D00KWC' => 'na',
+    'A1RKKUPIHCS9HS' => 'eu',
+    'A1F83G8C2ARO7P' => 'eu',
+    'A13V1IB3VIYZZH' => 'eu',
+    'A1805IZSGTT6HS' => 'eu',
+    'A1PA6795UKMFR9' => 'eu',
+    'APJ6JRA9NG5V4' => 'eu',
+    'A2NODRKZP88ZB9' => 'eu',
+    'A1C3SOZRARQ6R3' => 'eu',
+    'ARBP9OOSHTCHU' => 'eu',
+    'A33AVAJ2PDY3EV' => 'eu',
+    'A17E79C6D8DWNP' => 'eu',
+    'A2VIGQ35RCS4UG' => 'eu',
+    'A21TJRUUN4KGV' => 'eu',
+    'A19VAU5U5O7RUS' => 'fe',
+    'A39IBJ37TRP1C6' => 'fe',
+    'A1VC38T7YXB528' => 'fe'
+  }.freeze
+end