finch-api 0.1.0.pre.alpha.16 → 0.1.0.pre.alpha.17

data/lib/finch_api/internal/type/enum.rb

@@ -42,6 +42,7 @@ module FinchAPI
       #   end
       module Enum
         include FinchAPI::Internal::Type::Converter
+        include FinchAPI::Internal::Util::SorbetRuntimeSupport
 
         # All of the valid Symbol values for this enum.
         #

data/lib/finch_api/internal/type/hash_of.rb

@@ -29,7 +29,7 @@ module FinchAPI
         #
         #   @option spec [Boolean] :"nil?"
         #
-        # @return [FinchAPI::Internal::Type::HashOf]
+        # @return [self]
         def self.[](...) = new(...)
 
         # @api public

data/lib/finch_api/internal/type/union.rb

@@ -27,6 +27,7 @@ module FinchAPI
       #   end
       module Union
         include FinchAPI::Internal::Type::Converter
+        include FinchAPI::Internal::Util::SorbetRuntimeSupport
 
         # @api private
         #

data/lib/finch_api/internal/util.rb

@@ -801,6 +801,62 @@ module FinchAPI
           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]
+        # @param blk [Proc]
+        def define_sorbet_constant!(name, &blk) = sorbet_runtime_constants.store(name, blk)
+      end
+
+      extend FinchAPI::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/finch_api/internal.rb

@@ -2,10 +2,16 @@
 
 module FinchAPI
   module Internal
+    extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
     OMIT =
       Object.new.tap do
         _1.define_singleton_method(:inspect) { "#<#{FinchAPI::Internal}::OMIT>" }
       end
         .freeze
+
+    define_sorbet_constant!(:AnyHash) do
+      T.type_alias { T::Hash[Symbol, T.anything] }
+    end
   end
 end

data/lib/finch_api/models/hris/document_retreive_response.rb

@@ -20,6 +20,10 @@ module FinchAPI
 
         # @!method self.variants
         #   @return [Array(FinchAPI::HRIS::W42020, FinchAPI::HRIS::W42005)]
+
+        define_sorbet_constant!(:Variants) do
+          T.type_alias { T.any(FinchAPI::HRIS::W42020, FinchAPI::HRIS::W42005) }
+        end
       end
     end
   end

data/lib/finch_api/models/hris/employment_data.rb

@@ -221,6 +221,10 @@ module FinchAPI
               # @!method self.variants
               #   @return [Array(String, Array<Object>, Object, Float, Boolean)]
 
+              define_sorbet_constant!(:Variants) do
+                T.type_alias { T.any(String, T::Array[T.anything], T.anything, Float, T::Boolean) }
+              end
+
               # @type [FinchAPI::Internal::Type::Converter]
               UnionMember1Array = FinchAPI::Internal::Type::ArrayOf[FinchAPI::Internal::Type::Unknown]
             end
@@ -367,6 +371,12 @@ module FinchAPI
 
         # @!method self.variants
         #   @return [Array(FinchAPI::HRIS::EmploymentData::UnionMember0, FinchAPI::HRIS::EmploymentData::BatchError)]
+
+        define_sorbet_constant!(:Variants) do
+          T.type_alias do
+            T.any(FinchAPI::HRIS::EmploymentData::UnionMember0, FinchAPI::HRIS::EmploymentData::BatchError)
+          end
+        end
       end
     end
   end

data/lib/finch_api/models/hris/individual.rb

@@ -250,6 +250,12 @@ module FinchAPI
 
         # @!method self.variants
         #   @return [Array(FinchAPI::HRIS::Individual::UnionMember0, FinchAPI::HRIS::Individual::BatchError)]
+
+        define_sorbet_constant!(:Variants) do
+          T.type_alias do
+            T.any(FinchAPI::HRIS::Individual::UnionMember0, FinchAPI::HRIS::Individual::BatchError)
+          end
+        end
       end
     end
   end

data/lib/finch_api/models/hris/pay_statement.rb

@@ -370,6 +370,7 @@ module FinchAPI
 
           CHECK = :check
           DIRECT_DEPOSIT = :direct_deposit
+          OTHER = :other
 
           # @!method self.values
           #   @return [Array<Symbol>]

data/lib/finch_api/models/sandbox/payment_create_params.rb

@@ -423,6 +423,7 @@ module FinchAPI
 
             CHECK = :check
             DIRECT_DEPOSIT = :direct_deposit
+            OTHER = :other
 
             # @!method self.values
             #   @return [Array<Symbol>]

data/lib/finch_api/models/webhook_event.rb

@@ -25,6 +25,21 @@ module FinchAPI
 
       # @!method self.variants
       #   @return [Array(FinchAPI::AccountUpdateEvent, FinchAPI::CompanyEvent, FinchAPI::JobCompletionEvent, FinchAPI::DirectoryEvent, FinchAPI::EmploymentEvent, FinchAPI::IndividualEvent, FinchAPI::PaymentEvent, FinchAPI::PayStatementEvent)]
+
+      define_sorbet_constant!(:Variants) do
+        T.type_alias do
+          T.any(
+            FinchAPI::AccountUpdateEvent,
+            FinchAPI::CompanyEvent,
+            FinchAPI::JobCompletionEvent,
+            FinchAPI::DirectoryEvent,
+            FinchAPI::EmploymentEvent,
+            FinchAPI::IndividualEvent,
+            FinchAPI::PaymentEvent,
+            FinchAPI::PayStatementEvent
+          )
+        end
+      end
     end
   end
 end

data/lib/finch_api/models.rb

@@ -1,6 +1,33 @@
 # frozen_string_literal: true
 
 module FinchAPI
+  [FinchAPI::Internal::Type::BaseModel, *FinchAPI::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, FinchAPI::Internal::AnyHash) } }
+  end
+
+  [
+    *FinchAPI::Internal::Type::Enum.included_modules,
+    *FinchAPI::Internal::Type::Union.included_modules
+  ].each do |cls|
+    cls.constants.each do |name|
+      case cls.const_get(name)
+      in true | false
+        cls.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T.all(T::Boolean, cls) } }
+        cls.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+      in Integer
+        cls.define_sorbet_constant!(:TaggedInteger) { T.type_alias { T.all(Integer, cls) } }
+        cls.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+      in Float
+        cls.define_sorbet_constant!(:TaggedFloat) { T.type_alias { T.all(Float, cls) } }
+        cls.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+      in Symbol
+        cls.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { T.all(Symbol, cls) } }
+        cls.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+      else
+      end
+    end
+  end
+
   AccessTokenCreateParams = FinchAPI::Models::AccessTokenCreateParams
 
   AccountDisconnectParams = FinchAPI::Models::AccountDisconnectParams

data/lib/finch_api/request_options.rb

@@ -69,5 +69,9 @@ module FinchAPI
     #   Returns a new instance of RequestOptions.
     #
     #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(FinchAPI::RequestOptions, FinchAPI::Internal::AnyHash) }
+    end
   end
 end

data/lib/finch_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FinchAPI
-  VERSION = "0.1.0.pre.alpha.16"
+  VERSION = "0.1.0.pre.alpha.17"
 end

data/lib/finch_api.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 # Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
 require "English"
 require "cgi"
 require "date"
@@ -15,6 +16,7 @@ require "set"
 require "stringio"
 require "time"
 require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
 
 # We already ship the preferred sorbet manifests in the package itself.
 # `tapioca` currently does not offer us a way to opt out of unnecessary compilation.

data/rbi/finch_api/internal/transport/base_client.rbi

@@ -5,9 +5,11 @@ module FinchAPI
     module Transport
       # @api private
       class BaseClient
+        extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
         abstract!
 
-        RequestComponentsShape =
+        RequestComponents =
           T.type_alias do
             {
               method: Symbol,
@@ -53,7 +55,7 @@ module FinchAPI
             }
           end
 
-        RequestInputShape =
+        RequestInput =
           T.type_alias do
             {
               method: Symbol,
@@ -74,8 +76,7 @@ module FinchAPI
           # @api private
           sig do
             params(
-              req:
-                FinchAPI::Internal::Transport::BaseClient::RequestComponentsShape
+              req: FinchAPI::Internal::Transport::BaseClient::RequestComponents
             ).void
           end
           def validate!(req)
@@ -94,13 +95,10 @@ module FinchAPI
           # @api private
           sig do
             params(
-              request:
-                FinchAPI::Internal::Transport::BaseClient::RequestInputShape,
+              request: FinchAPI::Internal::Transport::BaseClient::RequestInput,
               status: Integer,
               response_headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-            ).returns(
-              FinchAPI::Internal::Transport::BaseClient::RequestInputShape
-            )
+            ).returns(FinchAPI::Internal::Transport::BaseClient::RequestInput)
           end
           def follow_redirect(request, status:, response_headers:)
           end
@@ -116,6 +114,27 @@ module FinchAPI
           end
         end
 
+        sig { returns(URI::Generic) }
+        attr_reader :base_url
+
+        sig { returns(Float) }
+        attr_reader :timeout
+
+        sig { returns(Integer) }
+        attr_reader :max_retries
+
+        sig { returns(Float) }
+        attr_reader :initial_retry_delay
+
+        sig { returns(Float) }
+        attr_reader :max_retry_delay
+
+        sig { returns(T::Hash[String, String]) }
+        attr_reader :headers
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :idempotency_header
+
         # @api private
         sig { returns(FinchAPI::Internal::Transport::PooledNetRequester) }
         attr_reader :requester
@@ -167,13 +186,10 @@ module FinchAPI
         sig do
           overridable
             .params(
-              req:
-                FinchAPI::Internal::Transport::BaseClient::RequestComponentsShape,
+              req: FinchAPI::Internal::Transport::BaseClient::RequestComponents,
               opts: FinchAPI::Internal::AnyHash
             )
-            .returns(
-              FinchAPI::Internal::Transport::BaseClient::RequestInputShape
-            )
+            .returns(FinchAPI::Internal::Transport::BaseClient::RequestInput)
         end
         private def build_request(req, opts)
         end
@@ -191,8 +207,7 @@ module FinchAPI
         # @api private
         sig do
           params(
-            request:
-              FinchAPI::Internal::Transport::BaseClient::RequestInputShape,
+            request: FinchAPI::Internal::Transport::BaseClient::RequestInput,
             redirect_count: Integer,
             retry_count: Integer,
             send_retry_header: T::Boolean

data/rbi/finch_api/internal/transport/pooled_net_requester.rbi

@@ -5,7 +5,9 @@ module FinchAPI
     module Transport
       # @api private
       class PooledNetRequester
-        RequestShape =
+        extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
+        Request =
           T.type_alias do
             {
               method: Symbol,
@@ -20,6 +22,8 @@ module FinchAPI
         # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
         KEEP_ALIVE_TIMEOUT = 30
 
+        DEFAULT_MAX_CONNECTIONS = T.let(T.unsafe(nil), Integer)
+
         class << self
           # @api private
           sig { params(url: URI::Generic).returns(Net::HTTP) }
@@ -35,7 +39,7 @@ module FinchAPI
           sig do
             params(
               request:
-                FinchAPI::Internal::Transport::PooledNetRequester::RequestShape,
+                FinchAPI::Internal::Transport::PooledNetRequester::Request,
               blk: T.proc.params(arg0: String).void
             ).returns([Net::HTTPGenericRequest, T.proc.void])
           end
@@ -57,8 +61,7 @@ module FinchAPI
         # @api private
         sig do
           params(
-            request:
-              FinchAPI::Internal::Transport::PooledNetRequester::RequestShape
+            request: FinchAPI::Internal::Transport::PooledNetRequester::Request
           ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
         end
         def execute(request)
@@ -66,7 +69,9 @@ module FinchAPI
 
         # @api private
         sig { params(size: Integer).returns(T.attached_class) }
-        def self.new(size: Etc.nprocessors)
+        def self.new(
+          size: FinchAPI::Internal::Transport::PooledNetRequester::DEFAULT_MAX_CONNECTIONS
+        )
         end
       end
     end

data/rbi/finch_api/internal/type/base_model.rbi

@@ -5,10 +5,11 @@ module FinchAPI
     module Type
       class BaseModel
         extend FinchAPI::Internal::Type::Converter
+        extend FinchAPI::Internal::Util::SorbetRuntimeSupport
 
         abstract!
 
-        KnownFieldShape =
+        KnownField =
           T.type_alias do
             {
               mode: T.nilable(Symbol),
@@ -18,19 +19,29 @@ module FinchAPI
           end
 
         OrHash =
-          T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+          T.type_alias do
+            T.any(
+              FinchAPI::Internal::Type::BaseModel,
+              FinchAPI::Internal::AnyHash
+            )
+          end
 
         class << self
           # @api private
           #
           # Assumes superclass fields are totally defined before fields are accessed /
           # defined on subclasses.
+          sig { params(child: T.self_type).void }
+          def inherited(child)
+          end
+
+          # @api private
           sig do
             returns(
               T::Hash[
                 Symbol,
                 T.all(
-                  FinchAPI::Internal::Type::BaseModel::KnownFieldShape,
+                  FinchAPI::Internal::Type::BaseModel::KnownField,
                   {
                     type_fn:
                       T.proc.returns(FinchAPI::Internal::Type::Converter::Input)
@@ -48,7 +59,7 @@ module FinchAPI
               T::Hash[
                 Symbol,
                 T.all(
-                  FinchAPI::Internal::Type::BaseModel::KnownFieldShape,
+                  FinchAPI::Internal::Type::BaseModel::KnownField,
                   { type: FinchAPI::Internal::Type::Converter::Input }
                 )
               ]
@@ -188,6 +199,18 @@ module FinchAPI
           end
         end
 
+        class << self
+          # @api private
+          sig do
+            params(
+              model: FinchAPI::Internal::Type::BaseModel,
+              convert: T::Boolean
+            ).returns(FinchAPI::Internal::AnyHash)
+          end
+          def recursively_to_h(model, convert:)
+          end
+        end
+
         # Returns the raw value associated with the given key, if found. Otherwise, nil is
         # returned.
         #
@@ -222,6 +245,12 @@ module FinchAPI
         def to_hash
         end
 
+        # In addition to the behaviour of `#to_h`, this method will recursively call
+        # `#to_h` on nested models.
+        sig { overridable.returns(FinchAPI::Internal::AnyHash) }
+        def deep_to_h
+        end
+
         sig do
           params(keys: T.nilable(T::Array[Symbol])).returns(
             FinchAPI::Internal::AnyHash
@@ -230,17 +259,6 @@ module FinchAPI
         def deconstruct_keys(keys)
         end
 
-        class << self
-          # @api private
-          sig do
-            params(model: FinchAPI::Internal::Type::BaseModel).returns(
-              FinchAPI::Internal::AnyHash
-            )
-          end
-          def walk(model)
-          end
-        end
-
         sig { params(a: T.anything).returns(String) }
         def to_json(*a)
         end

data/rbi/finch_api/internal/type/base_page.rbi

@@ -29,8 +29,7 @@ module FinchAPI
         sig do
           params(
             client: FinchAPI::Internal::Transport::BaseClient,
-            req:
-              FinchAPI::Internal::Transport::BaseClient::RequestComponentsShape,
+            req: FinchAPI::Internal::Transport::BaseClient::RequestComponents,
             headers: T.any(T::Hash[String, String], Net::HTTPHeader),
             page_data: T.anything
           ).void

data/rbi/finch_api/internal/type/converter.rbi

@@ -5,6 +5,8 @@ module FinchAPI
     module Type
       # @api private
       module Converter
+        extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
         Input =
           T.type_alias do
             T.any(FinchAPI::Internal::Type::Converter, T::Class[T.anything])

data/rbi/finch_api/internal/type/enum.rbi

@@ -17,6 +17,7 @@ module FinchAPI
       # values safely.
       module Enum
         include FinchAPI::Internal::Type::Converter
+        include FinchAPI::Internal::Util::SorbetRuntimeSupport
 
         # All of the valid Symbol values for this enum.
         sig do

data/rbi/finch_api/internal/type/union.rbi

@@ -6,6 +6,7 @@ module FinchAPI
       # @api private
       module Union
         include FinchAPI::Internal::Type::Converter
+        include FinchAPI::Internal::Util::SorbetRuntimeSupport
 
         # @api private
         #

data/rbi/finch_api/internal/util.rbi

@@ -4,6 +4,8 @@ module FinchAPI
   module Internal
     # @api private
     module Util
+      extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
       # @api private
       sig { returns(Float) }
       def self.monotonic_secs
@@ -172,7 +174,7 @@ module FinchAPI
         end
       end
 
-      ParsedUriShape =
+      ParsedUri =
         T.type_alias do
           {
             scheme: T.nilable(String),
@@ -187,7 +189,7 @@ module FinchAPI
         # @api private
         sig do
           params(url: T.any(URI::Generic, String)).returns(
-            FinchAPI::Internal::Util::ParsedUriShape
+            FinchAPI::Internal::Util::ParsedUri
           )
         end
         def parse_uri(url)
@@ -195,7 +197,7 @@ module FinchAPI
 
         # @api private
         sig do
-          params(parsed: FinchAPI::Internal::Util::ParsedUriShape).returns(
+          params(parsed: FinchAPI::Internal::Util::ParsedUri).returns(
             URI::Generic
           )
         end
@@ -205,8 +207,8 @@ module FinchAPI
         # @api private
         sig do
           params(
-            lhs: FinchAPI::Internal::Util::ParsedUriShape,
-            rhs: FinchAPI::Internal::Util::ParsedUriShape
+            lhs: FinchAPI::Internal::Util::ParsedUri,
+            rhs: FinchAPI::Internal::Util::ParsedUri
           ).returns(URI::Generic)
         end
         def join_parsed_uri(lhs, rhs)
@@ -423,6 +425,27 @@ module FinchAPI
         def decode_sse(lines)
         end
       end
+
+      # @api private
+      module SorbetRuntimeSupport
+        class MissingSorbetRuntimeError < ::RuntimeError
+        end
+
+        # @api private
+        sig { returns(T::Hash[Symbol, T.anything]) }
+        private def sorbet_runtime_constants
+        end
+
+        # @api private
+        sig { params(name: Symbol).void }
+        def const_missing(name)
+        end
+
+        # @api private
+        sig { params(name: Symbol, blk: T.proc.returns(T.anything)).void }
+        def define_sorbet_constant!(name, &blk)
+        end
+      end
     end
   end
 end

data/rbi/finch_api/internal.rbi

@@ -2,6 +2,8 @@
 
 module FinchAPI
   module Internal
+    extend FinchAPI::Internal::Util::SorbetRuntimeSupport
+
     # Due to the current WIP status of Shapes support in Sorbet, types referencing
     # this alias might be refined in the future.
     AnyHash = T.type_alias { T::Hash[Symbol, T.anything] }

data/rbi/finch_api/models/access_token_create_params.rbi

@@ -6,7 +6,10 @@ module FinchAPI
       extend FinchAPI::Internal::Type::RequestParameters::Converter
       include FinchAPI::Internal::Type::RequestParameters
 
-      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+      OrHash =
+        T.type_alias do
+          T.any(FinchAPI::AccessTokenCreateParams, FinchAPI::Internal::AnyHash)
+        end
 
       sig { returns(String) }
       attr_accessor :code

data/rbi/finch_api/models/account_disconnect_params.rbi

@@ -6,7 +6,10 @@ module FinchAPI
       extend FinchAPI::Internal::Type::RequestParameters::Converter
       include FinchAPI::Internal::Type::RequestParameters
 
-      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+      OrHash =
+        T.type_alias do
+          T.any(FinchAPI::AccountDisconnectParams, FinchAPI::Internal::AnyHash)
+        end
 
       sig do
         params(request_options: FinchAPI::RequestOptions::OrHash).returns(

data/rbi/finch_api/models/account_introspect_params.rbi

@@ -6,7 +6,10 @@ module FinchAPI
       extend FinchAPI::Internal::Type::RequestParameters::Converter
       include FinchAPI::Internal::Type::RequestParameters
 
-      OrHash = T.type_alias { T.any(T.self_type, FinchAPI::Internal::AnyHash) }
+      OrHash =
+        T.type_alias do
+          T.any(FinchAPI::AccountIntrospectParams, FinchAPI::Internal::AnyHash)
+        end
 
       sig do
         params(request_options: FinchAPI::RequestOptions::OrHash).returns(