terminal-shop 0.1.0.pre.alpha.5

data/lib/terminal-shop/models/view_init_response.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  module Models
+    # @example
+    # ```ruby
+    # view_init_response => {
+    #   data: TerminalShop::Models::ViewInitResponse::Data
+    # }
+    # ```
+    class ViewInitResponse < TerminalShop::BaseModel
+      # @!attribute data
+      #   Initial app data.
+      #
+      #   @return [TerminalShop::Models::ViewInitResponse::Data]
+      required :data, -> { TerminalShop::Models::ViewInitResponse::Data }
+
+      # @!parse
+      #   # @param data [TerminalShop::Models::ViewInitResponse::Data]
+      #   #
+      #   def initialize(data:, **) = super
+
+      # def initialize: (Hash | TerminalShop::BaseModel) -> void
+
+      # @example
+      # ```ruby
+      # data => {
+      #   addresses: -> { TerminalShop::ArrayOf[TerminalShop::Models::AddressAPI] === _1 },
+      #   apps: -> { TerminalShop::ArrayOf[TerminalShop::Models::AppAPI] === _1 },
+      #   cards: -> { TerminalShop::ArrayOf[TerminalShop::Models::CardAPI] === _1 },
+      #   cart: TerminalShop::Models::CartAPI,
+      #   orders: -> { TerminalShop::ArrayOf[TerminalShop::Models::OrderAPI] === _1 },
+      #   **_
+      # }
+      # ```
+      class Data < TerminalShop::BaseModel
+        # @!attribute addresses
+        #
+        #   @return [Array<TerminalShop::Models::AddressAPI>]
+        required :addresses, -> { TerminalShop::ArrayOf[TerminalShop::Models::AddressAPI] }
+
+        # @!attribute apps
+        #
+        #   @return [Array<TerminalShop::Models::AppAPI>]
+        required :apps, -> { TerminalShop::ArrayOf[TerminalShop::Models::AppAPI] }
+
+        # @!attribute cards
+        #
+        #   @return [Array<TerminalShop::Models::CardAPI>]
+        required :cards, -> { TerminalShop::ArrayOf[TerminalShop::Models::CardAPI] }
+
+        # @!attribute cart
+        #   The current Terminal shop user's cart.
+        #
+        #   @return [TerminalShop::Models::CartAPI]
+        required :cart, -> { TerminalShop::Models::CartAPI }
+
+        # @!attribute orders
+        #
+        #   @return [Array<TerminalShop::Models::OrderAPI>]
+        required :orders, -> { TerminalShop::ArrayOf[TerminalShop::Models::OrderAPI] }
+
+        # @!attribute products
+        #
+        #   @return [Array<TerminalShop::Models::ProductAPI>]
+        required :products, -> { TerminalShop::ArrayOf[TerminalShop::Models::ProductAPI] }
+
+        # @!attribute profile
+        #   A Terminal shop user's profile. (We have users, btw.)
+        #
+        #   @return [TerminalShop::Models::ProfileAPI]
+        required :profile, -> { TerminalShop::Models::ProfileAPI }
+
+        # @!attribute subscriptions
+        #
+        #   @return [Array<TerminalShop::Models::SubscriptionAPI>]
+        required :subscriptions, -> { TerminalShop::ArrayOf[TerminalShop::Models::SubscriptionAPI] }
+
+        # @!attribute tokens
+        #
+        #   @return [Array<TerminalShop::Models::TokenAPI>]
+        required :tokens, -> { TerminalShop::ArrayOf[TerminalShop::Models::TokenAPI] }
+
+        # @!parse
+        #   # Initial app data.
+        #   #
+        #   # @param addresses [Array<TerminalShop::Models::AddressAPI>]
+        #   # @param apps [Array<TerminalShop::Models::AppAPI>]
+        #   # @param cards [Array<TerminalShop::Models::CardAPI>]
+        #   # @param cart [TerminalShop::Models::CartAPI]
+        #   # @param orders [Array<TerminalShop::Models::OrderAPI>]
+        #   # @param products [Array<TerminalShop::Models::ProductAPI>]
+        #   # @param profile [TerminalShop::Models::ProfileAPI]
+        #   # @param subscriptions [Array<TerminalShop::Models::SubscriptionAPI>]
+        #   # @param tokens [Array<TerminalShop::Models::TokenAPI>]
+        #   #
+        #   def initialize(addresses:, apps:, cards:, cart:, orders:, products:, profile:, subscriptions:, tokens:, **) = super
+
+        # def initialize: (Hash | TerminalShop::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/terminal-shop/pooled_net_requester.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  # @private
+  #
+  class PooledNetRequester
+    def initialize
+      @mutex = Mutex.new
+      @pools = {}
+    end
+
+    # @private
+    #
+    # @param url [URL::Generic]
+    # @param timeout [Float]
+    #
+    # @return [ConnectionPool]
+    #
+    private def get_pool(url)
+      origin = TerminalShop::Util.uri_origin(url)
+      @mutex.synchronize do
+        @pools[origin] ||= ConnectionPool.new(size: Etc.nprocessors) do
+          port =
+            case [url.port, url.scheme]
+            in [Integer, _]
+              url.port
+            in [nil, "http" | "ws"]
+              Net::HTTP.http_default_port
+            in [nil, "https" | "wss"]
+              Net::HTTP.https_default_port
+            end
+
+          session = Net::HTTP.new(url.host, port)
+          session.use_ssl = %w[https wss].include?(url.scheme)
+          session.max_retries = 0
+          session
+        end
+      end
+    end
+
+    # @private
+    #
+    # @param req [Hash{Symbol => Object}]
+    #   @option req [Symbol] :method
+    #   @option req [URI::Generic] :url
+    #   @option req [Hash{String => String}] :headers
+    #   @option req [String, Hash] :body
+    #   @option req [Float] :timeout
+    #
+    # @return [Net::HTTPResponse]
+    #
+    def execute(req)
+      method, url, headers, body, timeout = req.fetch_values(:method, :url, :headers, :body, :timeout)
+
+      request = Net::HTTPGenericRequest.new(
+        method.to_s.upcase,
+        !body.nil?,
+        ![:head, :options].include?(method),
+        url.to_s
+      )
+
+      headers.each { |k, v| request[k] = v }
+      case body
+      in String | nil
+        request.body = body
+      in IO | StringIO
+        request.body_stream = body
+      end
+
+      # This timeout is for acquiring a connection from the pool
+      # The default 5 seconds seems too short, lets just have a nearly unbounded queue for now
+      #
+      # TODO: revisit this around granular timeout / concurrency control
+      get_pool(url).with(timeout: 600) do |conn|
+        conn.open_timeout = timeout
+        conn.read_timeout = timeout
+        conn.write_timeout = timeout
+        conn.continue_timeout = timeout
+
+        conn.start unless conn.started?
+
+        conn.request(request)
+        # rubocop:disable Lint/RescueException
+      rescue Exception => e
+        # rubocop:enable Lint/RescueException
+        # should close connection on all errors to ensure no invalid state persists
+        conn.finish if conn.started?
+        raise e
+      end
+    rescue ConnectionPool::TimeoutError
+      raise TerminalShop::APITimeoutError.new(url: url)
+    end
+  end
+end

data/lib/terminal-shop/request_options.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  # @private
+  #
+  # @abstract
+  #
+  module RequestParameters
+    # @!parse
+    #   # Options to specify HTTP behaviour for this request.
+    #   # @return [TerminalShop::RequestOptions, Hash{Symbol=>Object}]
+    #   attr_accessor :request_options
+
+    # @param mod [Module]
+    #
+    def self.included(mod)
+      return unless mod <= TerminalShop::BaseModel
+
+      mod.extend(TerminalShop::RequestParameters::Converter)
+      mod.optional(:request_options, TerminalShop::RequestOptions)
+    end
+
+    # @private
+    #
+    module Converter
+      # @private
+      #
+      # @param params [Object]
+      #
+      # @return [Array(Object, Hash{Symbol=>Object})]
+      #
+      def dump_request(params)
+        case (dumped = dump(params))
+        in Hash
+          [dumped.except(:request_options), dumped[:request_options]]
+        else
+          [dumped, nil]
+        end
+      end
+    end
+  end
+
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  #   or override those provided at the client level.
+  #
+  #   When making a request, you can pass an actual {RequestOptions} instance, or
+  #   simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < TerminalShop::BaseModel
+    # @private
+    #
+    # @param opts [TerminalShop::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    #
+    def self.validate!(opts)
+      case opts
+      in TerminalShop::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #     sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #     `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, TerminalShop::HashOf[TerminalShop::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #     `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, TerminalShop::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #     generated as part of the normal request.
+    #
+    #   @return [Hash{Symbol=>Object}, nil]
+    optional :extra_body, TerminalShop::HashOf[TerminalShop::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!parse
+    #   # Returns a new instance of RequestOptions.
+    #   #
+    #   # @param values [Hash{Symbol=>Object}]
+    #   #
+    #   def initialize(values = {}) = super
+  end
+end

data/lib/terminal-shop/resources/address.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  module Resources
+    class Address
+      # Create and add a shipping address to the current user.
+      #
+      # @param params [TerminalShop::Models::AddressCreateParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :city City of the address.
+      #
+      #   @option params [String] :country ISO 3166-1 alpha-2 country code of the address.
+      #
+      #   @option params [String] :name The recipient's name.
+      #
+      #   @option params [String] :street1 Street of the address.
+      #
+      #   @option params [String] :zip Zip code of the address.
+      #
+      #   @option params [String] :phone Phone number of the recipient.
+      #
+      #   @option params [String] :province Province or state of the address.
+      #
+      #   @option params [String] :street2 Apartment, suite, etc. of the address.
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AddressCreateResponse]
+      #
+      def create(params)
+        parsed, options = TerminalShop::Models::AddressCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "address",
+          body: parsed,
+          model: TerminalShop::Models::AddressCreateResponse,
+          options: options
+        )
+      end
+
+      # Get the shipping addresses associated with the current user.
+      #
+      # @param params [TerminalShop::Models::AddressListParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AddressListResponse]
+      #
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "address",
+          model: TerminalShop::Models::AddressListResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Delete a shipping address from the current user.
+      #
+      # @param id [String] ID of the shipping address to delete.
+      #
+      # @param params [TerminalShop::Models::AddressDeleteParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AddressDeleteResponse]
+      #
+      def delete(id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["address/%0s", id],
+          model: TerminalShop::Models::AddressDeleteResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @param client [TerminalShop::Client]
+      #
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/terminal-shop/resources/app.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  module Resources
+    class App
+      # Create an app.
+      #
+      # @param params [TerminalShop::Models::AppCreateParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :id Unique object identifier. The format and length of IDs may change over time.
+      #
+      #   @option params [String] :name Name of the app.
+      #
+      #   @option params [String] :redirect_uri Redirect URI of the app.
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AppCreateResponse]
+      #
+      def create(params)
+        parsed, options = TerminalShop::Models::AppCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "app",
+          body: parsed,
+          model: TerminalShop::Models::AppCreateResponse,
+          options: options
+        )
+      end
+
+      # List the current user's registered apps.
+      #
+      # @param params [TerminalShop::Models::AppListParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AppListResponse]
+      #
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "app",
+          model: TerminalShop::Models::AppListResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Delete the app with the given ID.
+      #
+      # @param id [String] ID of the app to delete.
+      #
+      # @param params [TerminalShop::Models::AppDeleteParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AppDeleteResponse]
+      #
+      def delete(id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["app/%0s", id],
+          model: TerminalShop::Models::AppDeleteResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Get the app with the given ID.
+      #
+      # @param id [String] ID of the app to get.
+      #
+      # @param params [TerminalShop::Models::AppGetParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::AppGetResponse]
+      #
+      def get(id, params = {})
+        @client.request(
+          method: :get,
+          path: ["app/%0s", id],
+          model: TerminalShop::Models::AppGetResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @param client [TerminalShop::Client]
+      #
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/terminal-shop/resources/card.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  module Resources
+    class Card
+      # Attach a credit card (tokenized via Stripe) to the current user.
+      #
+      # @param params [TerminalShop::Models::CardCreateParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :token Stripe card token. Learn how to
+      #     [create one here](https://docs.stripe.com/api/tokens/create_card).
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CardCreateResponse]
+      #
+      def create(params)
+        parsed, options = TerminalShop::Models::CardCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "card",
+          body: parsed,
+          model: TerminalShop::Models::CardCreateResponse,
+          options: options
+        )
+      end
+
+      # List the credit cards associated with the current user.
+      #
+      # @param params [TerminalShop::Models::CardListParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CardListResponse]
+      #
+      def list(params = {})
+        @client.request(
+          method: :get,
+          path: "card",
+          model: TerminalShop::Models::CardListResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Delete a credit card associated with the current user.
+      #
+      # @param id [String] ID of the card to delete.
+      #
+      # @param params [TerminalShop::Models::CardDeleteParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CardDeleteResponse]
+      #
+      def delete(id, params = {})
+        @client.request(
+          method: :delete,
+          path: ["card/%0s", id],
+          model: TerminalShop::Models::CardDeleteResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Create a temporary URL for collecting credit card information for the current
+      #   user.
+      #
+      # @param params [TerminalShop::Models::CardCollectParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CardCollectResponse]
+      #
+      def collect(params = {})
+        @client.request(
+          method: :post,
+          path: "card/collect",
+          model: TerminalShop::Models::CardCollectResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @param client [TerminalShop::Client]
+      #
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/terminal-shop/resources/cart.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module TerminalShop
+  module Resources
+    class Cart
+      # Convert the current user's cart to an order.
+      #
+      # @param params [TerminalShop::Models::CartConvertParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CartConvertResponse]
+      #
+      def convert(params = {})
+        @client.request(
+          method: :post,
+          path: "cart/convert",
+          model: TerminalShop::Models::CartConvertResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Get the current user's cart.
+      #
+      # @param params [TerminalShop::Models::CartGetParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CartGetResponse]
+      #
+      def get(params = {})
+        @client.request(
+          method: :get,
+          path: "cart",
+          model: TerminalShop::Models::CartGetResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # Set the shipping address for the current user's cart.
+      #
+      # @param params [TerminalShop::Models::CartSetAddressParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :address_id ID of the shipping address to set for the current user's cart.
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CartSetAddressResponse]
+      #
+      def set_address(params)
+        parsed, options = TerminalShop::Models::CartSetAddressParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: "cart/address",
+          body: parsed,
+          model: TerminalShop::Models::CartSetAddressResponse,
+          options: options
+        )
+      end
+
+      # Set the credit card for the current user's cart.
+      #
+      # @param params [TerminalShop::Models::CartSetCardParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :card_id ID of the credit card to set for the current user's cart.
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CartSetCardResponse]
+      #
+      def set_card(params)
+        parsed, options = TerminalShop::Models::CartSetCardParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: "cart/card",
+          body: parsed,
+          model: TerminalShop::Models::CartSetCardResponse,
+          options: options
+        )
+      end
+
+      # Add an item to the current user's cart.
+      #
+      # @param params [TerminalShop::Models::CartSetItemParams, Hash{Symbol=>Object}] .
+      #
+      #   @option params [String] :product_variant_id ID of the product variant to add to the cart.
+      #
+      #   @option params [Integer] :quantity Quantity of the item to add to the cart.
+      #
+      #   @option params [TerminalShop::RequestOptions, Hash{Symbol=>Object}, nil] :request_options
+      #
+      # @return [TerminalShop::Models::CartSetItemResponse]
+      #
+      def set_item(params)
+        parsed, options = TerminalShop::Models::CartSetItemParams.dump_request(params)
+        @client.request(
+          method: :put,
+          path: "cart/item",
+          body: parsed,
+          model: TerminalShop::Models::CartSetItemResponse,
+          options: options
+        )
+      end
+
+      # @param client [TerminalShop::Client]
+      #
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end