modern_treasury 0.1.0.pre.alpha.18 → 0.1.0.pre.alpha.20

data/lib/modern_treasury/internal/util.rb

@@ -9,6 +9,23 @@ module ModernTreasury
       # @return [Float]
       def self.monotonic_secs = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
+      # @api private
+      #
+      # @param ns [Module, Class]
+      #
+      # @return [Enumerable<Module, Class>]
+      def self.walk_namespaces(ns)
+        ns.constants(false).lazy.flat_map do
+          case (c = ns.const_get(_1, false))
+          in Module | Class
+            walk_namespaces(c)
+          else
+            []
+          end
+        end
+          .chain([ns])
+      end
+
       class << self
         # @api private
         #
@@ -128,6 +145,22 @@ module ModernTreasury
             input.respond_to?(:to_h) ? input.to_h : input
           end
         end
+
+        # @api private
+        #
+        # @param input [Object]
+        #
+        # @raise [ArgumentError]
+        # @return [Hash{Object=>Object}, nil]
+        def coerce_hash!(input)
+          case coerce_hash(input)
+          in Hash | nil => coerced
+            coerced
+          else
+            message = "Expected a #{Hash} or #{ModernTreasury::Internal::Type::BaseModel}, got #{data.inspect}"
+            raise ArgumentError.new(message)
+          end
+        end
       end
 
       class << self
@@ -175,18 +208,17 @@ module ModernTreasury
         # @api private
         #
         # @param data [Hash{Symbol=>Object}, Array<Object>, Object]
-        # @param pick [Symbol, Integer, Array<Symbol, Integer>, nil]
-        # @param sentinel [Object, nil]
+        # @param pick [Symbol, Integer, Array<Symbol, Integer>, Proc, nil]
         # @param blk [Proc, nil]
         #
         # @return [Object, nil]
-        def dig(data, pick, sentinel = nil, &blk)
-          case [data, pick, blk]
-          in [_, nil, nil]
+        def dig(data, pick, &blk)
+          case [data, pick]
+          in [_, nil]
             data
-          in [Hash, Symbol, _] | [Array, Integer, _]
-            blk.nil? ? data.fetch(pick, sentinel) : data.fetch(pick, &blk)
-          in [Hash | Array, Array, _]
+          in [Hash, Symbol] | [Array, Integer]
+            data.fetch(pick) { blk&.call }
+          in [Hash | Array, Array]
             pick.reduce(data) do |acc, key|
               case acc
               in Hash if acc.key?(key)
@@ -194,11 +226,13 @@ module ModernTreasury
               in Array if key.is_a?(Integer) && key < acc.length
                 acc[key]
               else
-                return blk.nil? ? sentinel : blk.call
+                return blk&.call
               end
             end
-          in _
-            blk.nil? ? sentinel : blk.call
+          in [_, Proc]
+            pick.call(data)
+          else
+            blk&.call
           end
         end
       end
@@ -348,27 +382,6 @@ module ModernTreasury
         end
       end
 
-      # @api private
-      class SerializationAdapter
-        # @return [Pathname, IO]
-        attr_reader :inner
-
-        # @param a [Object]
-        #
-        # @return [String]
-        def to_json(*a) = (inner.is_a?(IO) ? inner.read : inner.read(binmode: true)).to_json(*a)
-
-        # @param a [Object]
-        #
-        # @return [String]
-        def to_yaml(*a) = (inner.is_a?(IO) ? inner.read : inner.read(binmode: true)).to_yaml(*a)
-
-        # @api private
-        #
-        # @param inner [Pathname, IO]
-        def initialize(inner) = @inner = inner
-      end
-
       # @api private
       #
       # An adapter that satisfies the IO interface required by `::IO.copy_stream`
@@ -471,53 +484,81 @@ module ModernTreasury
         end
       end
 
+      # @type [Regexp]
+      JSON_CONTENT = %r{^application/(?:vnd(?:\.[^.]+)*\+)?json(?!l)}
+      # @type [Regexp]
+      JSONL_CONTENT = %r{^application/(:?x-(?:n|l)djson)|(:?(?:x-)?jsonl)}
+
       class << self
         # @api private
         #
         # @param y [Enumerator::Yielder]
-        # @param boundary [String]
-        # @param key [Symbol, String]
         # @param val [Object]
         # @param closing [Array<Proc>]
-        private def write_multipart_chunk(y, boundary:, key:, val:, closing:)
-          val = val.inner if val.is_a?(ModernTreasury::Internal::Util::SerializationAdapter)
+        # @param content_type [String, nil]
+        private def write_multipart_content(y, val:, closing:, content_type: nil)
+          content_type ||= "application/octet-stream"
 
-          y << "--#{boundary}\r\n"
-          y << "Content-Disposition: form-data"
-          unless key.nil?
-            name = ERB::Util.url_encode(key.to_s)
-            y << "; name=\"#{name}\""
-          end
-          case val
-          in Pathname | IO
-            filename = ERB::Util.url_encode(File.basename(val.to_path))
-            y << "; filename=\"#{filename}\""
-          else
-          end
-          y << "\r\n"
           case val
+          in ModernTreasury::FilePart
+            return write_multipart_content(
+              y,
+              val: val.content,
+              closing: closing,
+              content_type: val.content_type
+            )
           in Pathname
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             io = val.open(binmode: true)
             closing << io.method(:close)
             IO.copy_stream(io, y)
           in IO
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             IO.copy_stream(val, y)
           in StringIO
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             y << val.string
           in String
-            y << "Content-Type: application/octet-stream\r\n\r\n"
+            y << "Content-Type: #{content_type}\r\n\r\n"
             y << val.to_s
-          in _ if primitive?(val)
+          in -> { primitive?(_1) }
             y << "Content-Type: text/plain\r\n\r\n"
             y << val.to_s
           else
             y << "Content-Type: application/json\r\n\r\n"
-            y << JSON.fast_generate(val)
+            y << JSON.generate(val)
+          end
+          y << "\r\n"
+        end
+
+        # @api private
+        #
+        # @param y [Enumerator::Yielder]
+        # @param boundary [String]
+        # @param key [Symbol, String]
+        # @param val [Object]
+        # @param closing [Array<Proc>]
+        private def write_multipart_chunk(y, boundary:, key:, val:, closing:)
+          y << "--#{boundary}\r\n"
+          y << "Content-Disposition: form-data"
+
+          unless key.nil?
+            name = ERB::Util.url_encode(key.to_s)
+            y << "; name=\"#{name}\""
+          end
+
+          case val
+          in ModernTreasury::FilePart unless val.filename.nil?
+            filename = ERB::Util.url_encode(val.filename)
+            y << "; filename=\"#{filename}\""
+          in Pathname | IO
+            filename = ERB::Util.url_encode(::File.basename(val.to_path))
+            y << "; filename=\"#{filename}\""
+          else
           end
           y << "\r\n"
+
+          write_multipart_content(y, val: val, closing: closing)
         end
 
         # @api private
@@ -559,15 +600,15 @@ module ModernTreasury
         #
         # @return [Object]
         def encode_content(headers, body)
+          # rubocop:disable Style/CaseEquality
+          # rubocop:disable Layout/LineLength
           content_type = headers["content-type"]
-          body = body.inner if body.is_a?(ModernTreasury::Internal::Util::SerializationAdapter)
-
           case [content_type, body]
-          in [%r{^application/(?:vnd\.api\+)?json}, Hash | Array | -> { primitive?(_1) }]
-            [headers, JSON.fast_generate(body)]
-          in [%r{^application/(?:x-)?jsonl}, Enumerable] unless body.is_a?(StringIO) || body.is_a?(IO)
-            [headers, body.lazy.map { JSON.fast_generate(_1) }]
-          in [%r{^multipart/form-data}, Hash | Pathname | StringIO | IO]
+          in [ModernTreasury::Internal::Util::JSON_CONTENT, Hash | Array | -> { primitive?(_1) }]
+            [headers, JSON.generate(body)]
+          in [ModernTreasury::Internal::Util::JSONL_CONTENT, Enumerable] unless ModernTreasury::Internal::Type::FileInput === body
+            [headers, body.lazy.map { JSON.generate(_1) }]
+          in [%r{^multipart/form-data}, Hash | ModernTreasury::Internal::Type::FileInput]
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}
             [headers, strio]
@@ -575,9 +616,13 @@ module ModernTreasury
             [headers, body.to_s]
           in [_, StringIO]
             [headers, body.string]
+          in [_, ModernTreasury::FilePart]
+            [headers, body.content]
           else
             [headers, body]
           end
+          # rubocop:enable Layout/LineLength
+          # rubocop:enable Style/CaseEquality
         end
 
         # @api private
@@ -611,7 +656,7 @@ module ModernTreasury
         # @return [Object]
         def decode_content(headers, stream:, suppress_error: false)
           case (content_type = headers["content-type"])
-          in %r{^application/(?:vnd\.api\+)?json}
+          in ModernTreasury::Internal::Util::JSON_CONTENT
             json = stream.to_a.join
             begin
               JSON.parse(json, symbolize_names: true)
@@ -619,7 +664,7 @@ module ModernTreasury
               raise e unless suppress_error
               json
             end
-          in %r{^application/(?:x-)?jsonl}
+          in ModernTreasury::Internal::Util::JSONL_CONTENT
             lines = decode_lines(stream)
             chain_fused(lines) do |y|
               lines.each { y << JSON.parse(_1, symbolize_names: true) }
@@ -777,6 +822,90 @@ module ModernTreasury
           end
         end
       end
+
+      # @api private
+      module SorbetRuntimeSupport
+        class MissingSorbetRuntimeError < ::RuntimeError
+        end
+
+        # @api private
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def sorbet_runtime_constants = @sorbet_runtime_constants ||= {}
+
+        # @api private
+        #
+        # @param name [Symbol]
+        def const_missing(name)
+          super unless sorbet_runtime_constants.key?(name)
+
+          unless Object.const_defined?(:T)
+            message = "Trying to access a Sorbet constant #{name.inspect} without `sorbet-runtime`."
+            raise MissingSorbetRuntimeError.new(message)
+          end
+
+          sorbet_runtime_constants.fetch(name).call
+        end
+
+        # @api private
+        #
+        # @param name [Symbol]
+        #
+        # @return [Boolean]
+        def sorbet_constant_defined?(name) = sorbet_runtime_constants.key?(name)
+
+        # @api private
+        #
+        # @param name [Symbol]
+        # @param blk [Proc]
+        def define_sorbet_constant!(name, &blk) = sorbet_runtime_constants.store(name, blk)
+
+        # @api private
+        #
+        # @return [Object]
+        def to_sorbet_type = raise NotImplementedError
+
+        class << self
+          # @api private
+          #
+          # @param type [ModernTreasury::Internal::Util::SorbetRuntimeSupport, Object]
+          #
+          # @return [Object]
+          def to_sorbet_type(type)
+            case type
+            in ModernTreasury::Internal::Util::SorbetRuntimeSupport
+              type.to_sorbet_type
+            else
+              type
+            end
+          end
+        end
+      end
+
+      extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
+      define_sorbet_constant!(:ParsedUri) do
+        T.type_alias do
+          {
+            scheme: T.nilable(String),
+            host: T.nilable(String),
+            port: T.nilable(Integer),
+            path: T.nilable(String),
+            query: T::Hash[String, T::Array[String]]
+          }
+        end
+      end
+
+      define_sorbet_constant!(:ServerSentEvent) do
+        T.type_alias do
+          {
+            event: T.nilable(String),
+            data: T.nilable(String),
+            id: T.nilable(String),
+            retry: T.nilable(Integer)
+          }
+        end
+      end
     end
   end
 end

data/lib/modern_treasury/internal.rb

@@ -1,12 +1,20 @@
 # frozen_string_literal: true
 
 module ModernTreasury
-  # @api private
   module Internal
+    extend ModernTreasury::Internal::Util::SorbetRuntimeSupport
+
     OMIT =
       Object.new.tap do
         _1.define_singleton_method(:inspect) { "#<#{ModernTreasury::Internal}::OMIT>" }
       end
         .freeze
+
+    define_sorbet_constant!(:AnyHash) do
+      T.type_alias { T::Hash[Symbol, T.anything] }
+    end
+    define_sorbet_constant!(:FileInput) do
+      T.type_alias { T.any(Pathname, StringIO, IO, String, ModernTreasury::FilePart) }
+    end
   end
 end

data/lib/modern_treasury/models/account_collection_flow.rb

@@ -15,124 +15,90 @@ module ModernTreasury
       #
       #   @return [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::PaymentType>]
       required :payment_types,
-               -> { ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::Models::AccountCollectionFlow::PaymentType] }
+               -> {
+                 ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::AccountCollectionFlow::PaymentType]
+               }
 
-      # @!attribute [r] id
+      # @!attribute id
       #
       #   @return [String, nil]
       optional :id, String
 
-      # @!parse
-      #   # @return [String]
-      #   attr_writer :id
-
-      # @!attribute [r] client_token
+      # @!attribute client_token
       #   The client token of the account collection flow. This token can be used to embed
       #   account collection in your client-side application.
       #
       #   @return [String, nil]
       optional :client_token, String
 
-      # @!parse
-      #   # @return [String]
-      #   attr_writer :client_token
-
-      # @!attribute [r] created_at
+      # @!attribute created_at
       #
       #   @return [Time, nil]
       optional :created_at, Time
 
-      # @!parse
-      #   # @return [Time]
-      #   attr_writer :created_at
-
       # @!attribute external_account_id
       #   If present, the ID of the external account created using this flow.
       #
       #   @return [String, nil]
       optional :external_account_id, String, nil?: true
 
-      # @!attribute [r] live_mode
+      # @!attribute live_mode
       #   This field will be true if this object exists in the live environment or false
       #   if it exists in the test environment.
       #
       #   @return [Boolean, nil]
       optional :live_mode, ModernTreasury::Internal::Type::Boolean
 
-      # @!parse
-      #   # @return [Boolean]
-      #   attr_writer :live_mode
-
-      # @!attribute [r] object
+      # @!attribute object
       #
       #   @return [String, nil]
       optional :object, String
 
-      # @!parse
-      #   # @return [String]
-      #   attr_writer :object
-
-      # @!attribute [r] receiving_countries
+      # @!attribute receiving_countries
       #
       #   @return [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry>, nil]
       optional :receiving_countries,
-               -> { ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry] }
-
-      # @!parse
-      #   # @return [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry>]
-      #   attr_writer :receiving_countries
+               -> {
+                 ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::AccountCollectionFlow::ReceivingCountry]
+               }
 
-      # @!attribute [r] status
+      # @!attribute status
       #   The current status of the account collection flow. One of `pending`,
       #   `completed`, `expired`, or `cancelled`.
       #
       #   @return [Symbol, ModernTreasury::Models::AccountCollectionFlow::Status, nil]
-      optional :status, enum: -> { ModernTreasury::Models::AccountCollectionFlow::Status }
+      optional :status, enum: -> { ModernTreasury::AccountCollectionFlow::Status }
 
-      # @!parse
-      #   # @return [Symbol, ModernTreasury::Models::AccountCollectionFlow::Status]
-      #   attr_writer :status
-
-      # @!attribute [r] updated_at
+      # @!attribute updated_at
       #
       #   @return [Time, nil]
       optional :updated_at, Time
 
-      # @!parse
-      #   # @return [Time]
-      #   attr_writer :updated_at
-
-      # @!parse
-      #   # @param counterparty_id [String]
-      #   # @param payment_types [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::PaymentType>]
-      #   # @param id [String]
-      #   # @param client_token [String]
-      #   # @param created_at [Time]
-      #   # @param external_account_id [String, nil]
-      #   # @param live_mode [Boolean]
-      #   # @param object [String]
-      #   # @param receiving_countries [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry>]
-      #   # @param status [Symbol, ModernTreasury::Models::AccountCollectionFlow::Status]
-      #   # @param updated_at [Time]
-      #   #
-      #   def initialize(
-      #     counterparty_id:,
-      #     payment_types:,
-      #     id: nil,
-      #     client_token: nil,
-      #     created_at: nil,
-      #     external_account_id: nil,
-      #     live_mode: nil,
-      #     object: nil,
-      #     receiving_countries: nil,
-      #     status: nil,
-      #     updated_at: nil,
-      #     **
-      #   )
-      #     super
-      #   end
-
-      # def initialize: (Hash | ModernTreasury::Internal::Type::BaseModel) -> void
+      # @!method initialize(counterparty_id:, payment_types:, id: nil, client_token: nil, created_at: nil, external_account_id: nil, live_mode: nil, object: nil, receiving_countries: nil, status: nil, updated_at: nil)
+      #   Some parameter documentations has been truncated, see
+      #   {ModernTreasury::Models::AccountCollectionFlow} for more details.
+      #
+      #   @param counterparty_id [String] The ID of a counterparty. An external account created with this flow will be ass
+      #
+      #   @param payment_types [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::PaymentType>]
+      #
+      #   @param id [String]
+      #
+      #   @param client_token [String] The client token of the account collection flow. This token can be used to embe
+      #
+      #   @param created_at [Time]
+      #
+      #   @param external_account_id [String, nil] If present, the ID of the external account created using this flow.
+      #
+      #   @param live_mode [Boolean] This field will be true if this object exists in the live environment or false i
+      #
+      #   @param object [String]
+      #
+      #   @param receiving_countries [Array<Symbol, ModernTreasury::Models::AccountCollectionFlow::ReceivingCountry>]
+      #
+      #   @param status [Symbol, ModernTreasury::Models::AccountCollectionFlow::Status] The current status of the account collection flow. One of `pending`, `completed`
+      #
+      #   @param updated_at [Time]
 
       # An account created with this flow will support payments of one of these types.
       module PaymentType
@@ -141,11 +107,8 @@ module ModernTreasury
         ACH = :ach
         WIRE = :wire
 
-        finalize!
-
-        # @!parse
-        #   # @return [Array<Symbol>]
-        #   def self.values; end
+        # @!method self.values
+        #   @return [Array<Symbol>]
       end
 
       # An account created with this flow will support wires from the US to these
@@ -172,11 +135,8 @@ module ModernTreasury
         ESP = :ESP
         GBR = :GBR
 
-        finalize!
-
-        # @!parse
-        #   # @return [Array<Symbol>]
-        #   def self.values; end
+        # @!method self.values
+        #   @return [Array<Symbol>]
       end
 
       # The current status of the account collection flow. One of `pending`,
@@ -191,11 +151,8 @@ module ModernTreasury
         EXPIRED = :expired
         PENDING = :pending
 
-        finalize!
-
-        # @!parse
-        #   # @return [Array<Symbol>]
-        #   def self.values; end
+        # @!method self.values
+        #   @return [Array<Symbol>]
       end
     end
   end

data/lib/modern_treasury/models/account_collection_flow_create_params.rb

@@ -4,8 +4,7 @@ module ModernTreasury
   module Models
     # @see ModernTreasury::Resources::AccountCollectionFlows#create
     class AccountCollectionFlowCreateParams < ModernTreasury::Internal::Type::BaseModel
-      # @!parse
-      #   extend ModernTreasury::Internal::Type::RequestParameters::Converter
+      extend ModernTreasury::Internal::Type::RequestParameters::Converter
       include ModernTreasury::Internal::Type::RequestParameters
 
       # @!attribute counterparty_id
@@ -19,25 +18,22 @@ module ModernTreasury
       #   @return [Array<String>]
       required :payment_types, ModernTreasury::Internal::Type::ArrayOf[String]
 
-      # @!attribute [r] receiving_countries
+      # @!attribute receiving_countries
       #
       #   @return [Array<Symbol, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry>, nil]
       optional :receiving_countries,
-               -> { ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry] }
+               -> {
+                 ModernTreasury::Internal::Type::ArrayOf[enum: ModernTreasury::AccountCollectionFlowCreateParams::ReceivingCountry]
+               }
 
-      # @!parse
-      #   # @return [Array<Symbol, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry>]
-      #   attr_writer :receiving_countries
-
-      # @!parse
-      #   # @param counterparty_id [String]
-      #   # @param payment_types [Array<String>]
-      #   # @param receiving_countries [Array<Symbol, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry>]
-      #   # @param request_options [ModernTreasury::RequestOptions, Hash{Symbol=>Object}]
-      #   #
-      #   def initialize(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {}, **) = super
-
-      # def initialize: (Hash | ModernTreasury::Internal::Type::BaseModel) -> void
+      # @!method initialize(counterparty_id:, payment_types:, receiving_countries: nil, request_options: {})
+      #   @param counterparty_id [String] Required.
+      #
+      #   @param payment_types [Array<String>]
+      #
+      #   @param receiving_countries [Array<Symbol, ModernTreasury::Models::AccountCollectionFlowCreateParams::ReceivingCountry>]
+      #
+      #   @param request_options [ModernTreasury::RequestOptions, Hash{Symbol=>Object}]
 
       # Optional. Array of 3-digit ISO country codes.
       module ReceivingCountry
@@ -62,11 +58,8 @@ module ModernTreasury
         ESP = :ESP
         GBR = :GBR
 
-        finalize!
-
-        # @!parse
-        #   # @return [Array<Symbol>]
-        #   def self.values; end
+        # @!method self.values
+        #   @return [Array<Symbol>]
       end
     end
   end