sp_api_clients 2.0.0

data/lib/amazon_sp_clients/middlewares/raise_error.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'faraday'
+# Faraday::RetriableResponse (raised on 429) lives in the faraday-retry
+# gem under Faraday 2; a no-op under Faraday 1, which loads it itself.
+require 'faraday/retry'
+require 'json'
+
+# Based on https://github.com/lostisland/faraday/blob/main/lib/faraday/response/raise_error.rb
+module AmazonSpClients
+  module Middlewares
+    # RaiseError is a Faraday middleware that raises exceptions on common HTTP
+    # client or server error responses.
+    # Subclasses Faraday::Middleware (not Faraday::Response::Middleware,
+    # which Faraday 2 removed) so one class works on Faraday 1.10 and 2.x.
+    class RaiseError < Faraday::Middleware
+      # rubocop:disable Naming/ConstantName
+      ClientErrorStatuses = (400...500)
+      ServerErrorStatuses = (500...600)
+
+      # rubocop:enable Naming/ConstantName
+
+      VALID_SERVICE = %i[token spapi uploads].freeze
+
+      # The error payload ends up in consumer logs; keep secrets out.
+      FILTERED = '[FILTERED]'
+      SENSITIVE_HEADERS = %w[authorization x-amz-access-token x-amz-security-token].freeze
+
+      def initialize(app, options = {})
+        super
+        @service = options.fetch(:service)
+        raise unless VALID_SERVICE.include?(@service)
+      end
+
+      def on_complete(env)
+        case env[:status]
+        when 400
+          raise Faraday::BadRequestError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 401
+          raise Faraday::UnauthorizedError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 403
+          raise Faraday::ForbiddenError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 404
+          raise Faraday::ResourceNotFound.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 407
+          # mimic the behavior that we get with proxy requests with HTTPS
+          msg = '407 "Proxy Authentication Required"'
+          raise Faraday::ProxyAuthError.new(msg, response_values(env))
+        when 409
+          raise Faraday::ConflictError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 422
+          raise Faraday::UnprocessableEntityError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when 429
+          # This assumes you will handle throttling/retires yourself
+          raise Faraday::RetriableResponse.new(
+            error_message(env),
+            response_values(env)
+          )
+        when ClientErrorStatuses
+          raise Faraday::ClientError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when ServerErrorStatuses
+          raise Faraday::ServerError.new(
+            error_message(env),
+            response_values(env)
+          )
+        when nil
+          raise Faraday::NilStatusError.new(
+            error_message(env),
+            response_values(env)
+          )
+        end
+      end
+
+      def error_message(env)
+        body = env.body
+
+        unless !body.nil? && !body.empty?
+          return "the server responded with status #{env[:status]} (no body)"
+        end
+
+        case @service
+        when :token
+          body = ::JSON.parse(body) if body.is_a?(String)
+
+          "Service 'token' ERR: error: #{body['error']} description: #{body['error_description']}"
+        when :spapi
+          body = ::JSON.parse(body, symbolize_names: true) if body.is_a?(String)
+
+          err = AmazonSpClients::ApiError.new(body)
+
+          "Service 'spapi' ERR: #{err.full_messages}"
+        else
+          "the server responded with status #{env[:status]}"
+        end
+      rescue StandardError => e
+        "the server responded with status #{env[:status]} (#{e})"
+      end
+
+      def response_values(env)
+        {
+          service: @service,
+          response: {
+            status: env.status,
+            headers: env.response_headers,
+            body: env.body
+          },
+          request: {
+            method: env.method,
+            url_path: env.url.path,
+            url: redacted_url(env),
+            headers: redacted_request_headers(env.request_headers),
+            body: redacted_request_body(env)
+          }
+        }
+      end
+
+      private
+
+      # Returns a copy that keeps Faraday's case-insensitive lookup.
+      def redacted_request_headers(headers)
+        redacted = Faraday::Utils::Headers.new(headers || {})
+        SENSITIVE_HEADERS.each do |name|
+          redacted[name] = FILTERED unless redacted[name].nil?
+        end
+        redacted
+      end
+
+      # Presigned S3 urls (uploads service) carry their credential in
+      # the query string.
+      def redacted_url(env)
+        return env.url unless @service == :uploads
+
+        env.url.dup.tap { |url| url.query = nil }
+      end
+
+      # The LWA token request body carries client_secret and
+      # refresh_token as form fields.
+      def redacted_request_body(env)
+        return FILTERED if @service == :token
+
+        env.request_body
+      end
+    end
+  end
+end

data/lib/amazon_sp_clients/session.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'amazon_sp_clients/sp_tokens_2021'
+
+module AmazonSpClients
+  class Session
+    RESTRICTED_OPS = {
+      orders: {
+        restrictedResources: [
+          { method: 'GET', path: '/orders/v0/orders', dataElements: %w[buyerInfo shippingAddress] }
+        ]
+      },
+      orders_and_items: {
+        restrictedResources: [
+          { method: 'GET', path: '/orders/v0/orders', dataElements: %w[buyerInfo shippingAddress] },
+          { method: 'GET', path: '/orders/v0/orders/{orderId}/orderItems',
+            dataElements: ['buyerInfo'] }
+        ]
+      }
+    }.freeze
+
+    attr_reader :access_token, :restricted_data_token
+
+    def initialize(config = Configuration.default, &block)
+      @config = config
+
+      @refresh_token = nil
+      @access_token = nil
+      @access_token_expires_at = nil
+      @restricted_data_token = {}
+      @restricted_data_token_expires_at = {}
+      @grantless = false
+      @scope = nil
+
+      @callback = block
+    end
+
+    def with_callback(&block)
+      @callback = block
+      self
+    end
+
+    # @return [self]
+    def authenticate(refresh_token)
+      @refresh_token = refresh_token
+      @grantless = false
+      @scope = nil
+
+      request_access_token
+      self
+    end
+
+    # @return [self]
+    def authenticate_grantless(scope)
+      @grantless = true
+      @scope = scope
+
+      request_access_token
+      self
+    end
+
+    def refresh
+      if @callback
+        @access_token = @callback.call
+        @access_token_expires_at = nil
+      elsif @grantless
+        authenticate_grantless(@scope)
+      elsif !@refresh_token.nil?
+        authenticate(@refresh_token)
+      end
+    end
+
+    def ask_for_restricted_data_token(restricted_resource)
+      if !@restricted_data_token[restricted_resource].nil? &&
+         !expired?(@restricted_data_token_expires_at[restricted_resource])
+        return
+      end
+
+      tokens_api = AmazonSpClients::SpTokens2021::TokensApi.new(self)
+
+      token_params = if restricted_resource.is_a?(Symbol)
+                       RESTRICTED_OPS.fetch(restricted_resource)
+                     else
+                       { restrictedResources: [restricted_resource] }
+                     end
+      # TODO: handle errors for restricted_data_token request!
+      tokens_resp = tokens_api.create_restricted_data_token(token_params)
+
+      @restricted_data_token_expires_at[restricted_resource] =
+        duration_to_time(tokens_resp.payload[:expiresIn])
+      @restricted_data_token[restricted_resource] = tokens_resp.payload[:restrictedDataToken]
+    end
+
+    private
+
+    # Returns nil on success, error struct on error
+    def request_access_token
+      return if @access_token && !expired?(@access_token_expires_at)
+
+      resp_struct = exchange_token_request
+      @access_token = resp_struct.access_token
+      @refresh_token = resp_struct.refresh_token
+      @access_token_expires_at = duration_to_time(resp_struct.expires_in)
+    end
+
+    def exchange_token_request
+      auth = AmazonSpClients::TokenExchangeAuth.new(@refresh_token)
+
+      @grantless ? auth.exchange('client_credentials', @scope) : auth.exchange('refresh_token')
+    end
+
+    def expired?(expires)
+      return true if expires.nil?
+
+      # Shorten expiration time by 60s as a safety net.
+      Time.now.utc >= expires - 60
+    end
+
+    def duration_to_time(seconds)
+      Time.now.utc + seconds.to_i
+    end
+  end
+end

data/lib/amazon_sp_clients/sp_fba_inventory.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/fba_inventory/lib/sp_fba_inventory.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_feeds_2021.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/feeds_2021/lib/sp_feeds_2021.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_fulfillment_outbound_2020.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/fulfillment_outbound_2020/lib/sp_fulfillment_outbound_2020.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_listings_items_2021.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/listings_items_2021/lib/sp_listings_items_2021.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_orders_v0.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/orders_v0/lib/sp_orders_v0.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_reports_2021.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/reports_2021/lib/sp_reports_2021.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_tokens_2021.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/tokens_2021/lib/sp_tokens_2021.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vdf_inventory_v1.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vdf_inventory_v1/lib/sp_vdf_inventory_v1.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vdf_orders_v1.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vdf_orders_v1/lib/sp_vdf_orders_v1.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vdf_shipping_v1.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vdf_shipping_v1/lib/sp_vdf_shipping_v1.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vendor_invoices.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vendor_invoices/lib/sp_vendor_invoices.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vendor_orders.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vendor_orders/lib/sp_vendor_orders.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vendor_transaction_status.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vendor_transaction_status/lib/sp_vendor_transaction_status.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/sp_vendors_shipments.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# This file was autogenerated, do not edit it
+
+require_relative "../../vendor/vendors_shipments/lib/sp_vendors_shipments.rb"
+
+module AmazonSpClients
+end

data/lib/amazon_sp_clients/token_exchange_auth.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'amazon_sp_clients/adapter_loader'
+
+module AmazonSpClients
+  class AuthResponse < Struct.new(
+    :access_token,
+    :token_type,
+    :expires_in,
+    :refresh_token
+  )
+  end
+
+  class TokenExchangeAuth
+    GRANT_TYPE = %w[refresh_token client_credentials].freeze
+    TOKEN_HOST = 'api.amazon.com'
+
+    def initialize(refresh_token = nil, config = Configuration.default)
+      @refresh_token = refresh_token
+      @config = config
+
+      @conn =
+        Faraday.new("https://#{TOKEN_HOST}", request: { timeout: @config.timeout }) do |conn|
+          conn.use AmazonSpClients::Middlewares::RaiseError, { service: :token }
+          conn.adapter Faraday::Adapter::HTTPClient
+        end
+    end
+
+    # Request login with access token
+    # https://github.com/amzn/selling-partner-api-docs/blob/main/guides/en-US/developer-guide/SellingPartnerApiDeveloperGuide.md#step-1-request-a-login-with-amazon-access-token
+    #
+    # # REQ:
+    # POST /auth/o2/token HTTP/l.l
+    # Host: api.amazon.com
+    # Content-Type: application/x-www-form-urlencoded;charset=UTF-8
+    # grant_type=refresh_token
+    #   &refresh_token=Aztr|...
+    #   &client_id=foodev
+    #   &client_secret=Y76SDl2F
+    #
+    # # RESP:
+    # HTTP/l.l 200 OK
+    # Content-Type: application/json;charset UTF-8
+    # Cache-Control: no-store
+    # Pragma:no-cache
+    # {
+    #   "access_token":"Atza|IQEBLjAsAhRmHjNgHpi0U-Dme37rR6CuUpSREXAMPLE",
+    #   "token_type":"bearer",
+    #   "expires_in":3600,
+    #   "refresh_token":"Atzr|IQEBLzAtAhRPpMJxdwVz2Nn6f2y-tpJX2DeXEXAMPLE"
+    # }
+    def exchange(grant_type = 'refresh_token', scope = nil)
+      raise 'Invalid grant_type' unless GRANT_TYPE.include?(grant_type)
+      raise 'Grantless operations require scope' if grant_type == 'client_credentials' && scope.nil?
+
+      params = {
+        grant_type: grant_type,
+        client_id: @config.client_id,
+        client_secret: @config.client_secret
+      }
+
+      if grant_type == 'refresh_token'
+        params[:refresh_token] = @refresh_token
+      else
+        params[:scope] = scope
+      end
+
+      resp = @conn.post '/auth/o2/token', params
+
+      body = resp.body
+      body = JSON.parse(body, symbolize_names: true) if body.is_a?(String)
+
+      AuthResponse.new(
+        body[:access_token],
+        body[:token_type],
+        body[:expires_in],
+        body[:refresh_token]
+      )
+    end
+  end
+end

data/lib/amazon_sp_clients/uploader.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'amazon_sp_clients/adapter_loader'
+require 'zlib'
+require 'multi_xml'
+
+module AmazonSpClients
+  class Uploader
+    attr_reader :response
+
+    def initialize
+      config = AmazonSpClients.configure
+      @conn =
+        Faraday.new(request: { timeout: config.timeout }) do |c|
+          c.adapter Faraday::Adapter::HTTPClient
+          c.use AmazonSpClients::Middlewares::RaiseError, { service: :uploads }
+        end
+    end
+
+    def upload(feed_doc, doc_content_type, payload)
+      upload_url = feed_doc[:url]
+      document = payload
+
+      file = StringIO.new(document)
+
+      @response =
+        @conn.put(upload_url) do |req|
+          req.headers.merge!('Content-Type' => doc_content_type)
+          req.body = file
+        end
+    end
+  end
+
+  class Downloader
+    # {
+    #   "compressionAlgorithm": "GZIP",
+    #   "feedDocumentId": "amzn1.tortuga.3.ed4cd0d8-447b-4c22-96b5-52da8ace1207.T3YUVYPGKE9BMY",
+    #   "url": "https://tortuga-prod-na.s3.amazonaws.com/%2FNinetyDays/amzn1.tortuga.3.920614b0-fc4c-4393-b0d9-fff175300000.T29XK4YL08B2VM?xxx
+    # }
+    def initialize(feed_processing_report)
+      @config = AmazonSpClients.configure
+      @feed_document_id = feed_processing_report[:feedDocumentId]
+
+      @url = feed_processing_report[:url]
+      @compression_algorithm = feed_processing_report[:compressionAlgorithm]
+
+      @conn =
+        Faraday.new(request: { timeout: @config.timeout }) do |c|
+          c.use AmazonSpClients::Middlewares::RaiseError, { service: :uploads }
+        end
+    end
+
+    def download
+      resp = @conn.get(@url)
+      decoded_body = inflate_document(resp.body)
+
+      content_type = resp.headers['content-type'].to_s.downcase
+
+      if content_type =~ /json/
+        JSON.parse(decoded_body)
+      else
+        MultiXml.parse(decoded_body)
+      end
+    end
+
+    private
+
+    def inflate_document(body)
+      if @compression_algorithm.to_s.downcase == 'gzip'
+        Zlib.gunzip(body)
+      else
+        body
+      end
+    end
+  end
+end

data/lib/amazon_sp_clients/v2/api.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module AmazonSpClients
+  module V2
+    # Base class of the generated API classes. Holds the client and the
+    # small helpers the generated methods use to shape a request.
+    #
+    #   class OrdersV0 < Api
+    #     def get_order(order_id, rdt: nil)
+    #       request(:get, "/orders/v0/orders/#{encode(order_id)}", rdt: rdt)
+    #     end
+    #   end
+    class Api
+      # @param client [Client]
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # @see Client#request
+      def request(method, path, query: {}, headers: {}, body: nil, rdt: nil)
+        @client.request(method, path, query: query, headers: headers, body: body, rdt: rdt)
+      end
+
+      # Array parameters travel comma-separated (collectionFormat csv).
+      # nil stays nil so the parameter is left out; an empty array sends
+      # an empty value, as v1 did.
+      def csv(value)
+        return nil if value.nil?
+
+        Array(value).join(',')
+      end
+
+      # Percent-encodes one path segment; SKUs can hold spaces and slashes.
+      def encode(value)
+        URI.encode_uri_component(value.to_s)
+      end
+    end
+  end
+end