rcs 2.0.5.pre.rc.1 → 2.0.5

data/lib/pinnacle/internal/types/hash.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      class Hash
-        include Type
-
-        attr_reader :key_type, :value_type
-
-        class << self
-          def [](key_type, value_type)
-            new(key_type, value_type)
-          end
-        end
-
-        def initialize(key_type, value_type)
-          @key_type = key_type
-          @value_type = value_type
-        end
-
-        def coerce(value, strict: strict?)
-          unless value.is_a?(::Hash)
-            raise Errors::TypeError, "not hash" if strict
-
-            return value
-          end
-
-          value.to_h do |k, v|
-            [Utils.coerce(key_type, k, strict: strict), Utils.coerce(value_type, v, strict: strict)]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/model/field.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      class Model
-        # Definition of a field on a model
-        class Field
-          SENSITIVE_FIELD_NAMES = %i[
-            password secret token api_key apikey access_token refresh_token
-            client_secret client_id credential bearer authorization
-          ].freeze
-
-          attr_reader :name, :type, :optional, :nullable, :api_name, :value, :default
-
-          def initialize(name:, type:, optional: false, nullable: false, api_name: nil, value: nil, default: nil)
-            @name = name.to_sym
-            @type = type
-            @optional = optional
-            @nullable = nullable
-            @api_name = api_name || name.to_s
-            @value = value
-            @default = default
-          end
-
-          def literal?
-            !value.nil?
-          end
-
-          def sensitive?
-            SENSITIVE_FIELD_NAMES.include?(@name) ||
-              SENSITIVE_FIELD_NAMES.any? { |sensitive| @name.to_s.include?(sensitive.to_s) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/model.rb

@@ -1,208 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      # @abstract
-      #
-      # An abstract model that all data objects will inherit from
-      class Model
-        include Type
-
-        class << self
-          # The defined fields for this model
-          #
-          # @api private
-          #
-          # @return [Hash<Symbol, Field>]
-          def fields
-            @fields ||= if self < Pinnacle::Internal::Types::Model
-                          superclass.fields.dup
-                        else
-                          {}
-                        end
-          end
-
-          # Any extra fields that have been created from instantiation
-          #
-          # @api private
-          #
-          # @return [Hash<Symbol, Field>]
-          def extra_fields
-            @extra_fields ||= {}
-          end
-
-          # Define a new field on this model
-          #
-          # @param name [Symbol] The name of the field
-          # @param type [Class] Type of the field
-          # @option optional [Boolean] If it is an optional field
-          # @option nullable [Boolean] If it is a nullable field
-          # @option api_name [Symbol, String] Name in the API of this field. When serializing/deserializing, will use
-          #   this field name
-          # @return [void]
-          def field(name, type, optional: false, nullable: false, api_name: nil, default: nil)
-            add_field_definition(name: name, type: type, optional: optional, nullable: nullable, api_name: api_name,
-                                 default: default)
-
-            define_accessor(name)
-            define_setter(name)
-          end
-
-          # Define a new literal for this model
-          #
-          # @param name [Symbol]
-          # @param value [Object]
-          # @option api_name [Symbol, String]
-          # @return [void]
-          def literal(name, value, api_name: nil)
-            add_field_definition(name: name, type: value.class, optional: false, nullable: false, api_name: api_name,
-                                 value: value)
-
-            define_accessor(name)
-          end
-
-          # Adds a new field definition into the class's fields registry
-          #
-          # @api private
-          #
-          # @param name [Symbol]
-          # @param type [Class]
-          # @option optional [Boolean]
-          # @return [void]
-          private def add_field_definition(name:, type:, optional:, nullable:, api_name:, default: nil, value: nil)
-            fields[name.to_sym] =
-              Field.new(name: name, type: type, optional: optional, nullable: nullable, api_name: api_name,
-                        value: value, default: default)
-          end
-
-          # Adds a new field definition into the class's extra fields registry
-          #
-          # @api private
-          #
-          # @param name [Symbol]
-          # @param type [Class]
-          # @option required [Boolean]
-          # @option optional [Boolean]
-          # @return [void]
-          def add_extra_field_definition(name:, type:)
-            return if extra_fields.key?(name.to_sym)
-
-            extra_fields[name.to_sym] = Field.new(name: name, type: type, optional: true, nullable: false)
-
-            define_accessor(name)
-            define_setter(name)
-          end
-
-          # @api private
-          private def define_accessor(name)
-            method_name = name.to_sym
-
-            define_method(method_name) do
-              @data[name]
-            end
-          end
-
-          # @api private
-          private def define_setter(name)
-            method_name = :"#{name}="
-
-            define_method(method_name) do |val|
-              @data[name] = val
-            end
-          end
-
-          def coerce(value, strict: (respond_to?(:strict?) ? strict? : false)) # rubocop:disable Lint/UnusedMethodArgument
-            return value if value.is_a?(self)
-
-            return value unless value.is_a?(::Hash)
-
-            new(value)
-          end
-
-          def load(str)
-            coerce(::JSON.parse(str, symbolize_names: true))
-          end
-
-          def ===(instance)
-            instance.class.ancestors.include?(self)
-          end
-        end
-
-        # Creates a new instance of this model
-        # TODO: Should all this logic be in `#coerce` instead?
-        #
-        # @param values [Hash]
-        # @option strict [Boolean]
-        # @return [self]
-        def initialize(values = {})
-          @data = {}
-
-          values = Utils.symbolize_keys(values.dup)
-
-          self.class.fields.each do |field_name, field|
-            value = values.delete(field.api_name.to_sym) || values.delete(field.api_name) || values.delete(field_name)
-
-            field_value = value || (if field.literal?
-                                      field.value
-                                    elsif field.default
-                                      field.default
-                                    end)
-
-            @data[field_name] = Utils.coerce(field.type, field_value)
-          end
-
-          # Any remaining values in the input become extra fields
-          values.each do |name, value|
-            self.class.add_extra_field_definition(name: name, type: value.class)
-
-            @data[name.to_sym] = value
-          end
-        end
-
-        def to_h
-          result = self.class.fields.merge(self.class.extra_fields).each_with_object({}) do |(name, field), acc|
-            # If there is a value present in the data, use that value
-            # If there is a `nil` value present in the data, and it is optional but NOT nullable, exclude key altogether
-            # If there is a `nil` value present in the data, and it is optional and nullable, use the nil value
-
-            value = @data[name]
-
-            next if value.nil? && field.optional && !field.nullable
-
-            if value.is_a?(::Array)
-              value = value.map { |item| item.respond_to?(:to_h) ? item.to_h : item }
-            elsif value.respond_to?(:to_h)
-              value = value.to_h
-            end
-
-            acc[field.api_name] = value
-          end
-
-          # Inject union discriminant if this instance was coerced from a discriminated union
-          # and the discriminant key is not already present in the result
-          discriminant_key = instance_variable_get(:@_fern_union_discriminant_key)
-          discriminant_value = instance_variable_get(:@_fern_union_discriminant_value)
-          result[discriminant_key] = discriminant_value if discriminant_key && discriminant_value && !result.key?(discriminant_key)
-
-          result
-        end
-
-        def ==(other)
-          self.class == other.class && to_h == other.to_h
-        end
-
-        # @return [String]
-        def inspect
-          attrs = @data.map do |name, value|
-            field = self.class.fields[name] || self.class.extra_fields[name]
-            display_value = field&.sensitive? ? "[REDACTED]" : value.inspect
-            "#{name}=#{display_value}"
-          end
-
-          "#<#{self.class.name}:0x#{object_id&.to_s(16)} #{attrs.join(" ")}>"
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/type.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      # @abstract
-      module Type
-        include Pinnacle::Internal::JSON::Serializable
-
-        # Coerces a value to this type
-        #
-        # @param value [unknown]
-        # @option strict [Boolean] If we should strictly coerce this value
-        def coerce(value, strict: strict?)
-          raise NotImplementedError
-        end
-
-        # Returns if strictness is on for this type, defaults to `false`
-        #
-        # @return [Boolean]
-        def strict?
-          @strict ||= false
-        end
-
-        # Enable strictness by default for this type
-        #
-        # @return [void]
-        def strict!
-          @strict = true
-          self
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/union.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      # Define a union between two types
-      module Union
-        include Pinnacle::Internal::Types::Type
-
-        def members
-          @members ||= []
-        end
-
-        # Add a member to this union
-        #
-        # @param type [Object]
-        # @option key [Symbol, String]
-        # @return [void]
-        def member(type, key: nil)
-          members.push([key, Utils.wrap_type(type)])
-          self
-        end
-
-        def member?(type)
-          members.any? { |_key, type_fn| type == type_fn.call }
-        end
-
-        # Set the discriminant for this union
-        #
-        # @param key [Symbol, String]
-        # @return [void]
-        def discriminant(key)
-          @discriminant = key
-        end
-
-        # @api private
-        private def discriminated?
-          !@discriminant.nil?
-        end
-
-        # Check if value matches a type, handling type wrapper instances
-        # (Internal::Types::Hash and Internal::Types::Array instances)
-        #
-        # @param value [Object]
-        # @param member_type [Object]
-        # @return [Boolean]
-        private def type_matches?(value, member_type)
-          case member_type
-          when Pinnacle::Internal::Types::Hash
-            value.is_a?(::Hash)
-          when Pinnacle::Internal::Types::Array
-            value.is_a?(::Array)
-          when Class, Module
-            value.is_a?(member_type)
-          else
-            false
-          end
-        end
-
-        # Resolves the type of a value to be one of the members
-        #
-        # @param value [Object]
-        # @return [Class]
-        private def resolve_member(value)
-          if discriminated? && value.is_a?(::Hash)
-            # Try both symbol and string keys for the discriminant
-            discriminant_value = value.fetch(@discriminant, nil) || value.fetch(@discriminant.to_s, nil)
-
-            return if discriminant_value.nil?
-
-            # Convert to string for consistent comparison
-            discriminant_str = discriminant_value.to_s
-
-            # First try exact match
-            members_hash = members.to_h
-            result = members_hash[discriminant_str]&.call
-            return result if result
-
-            # Try case-insensitive match as fallback
-            discriminant_lower = discriminant_str.downcase
-            matching_keys = members_hash.keys.select { |k| k.to_s.downcase == discriminant_lower }
-
-            # Only use case-insensitive match if exactly one key matches (avoid ambiguity)
-            return members_hash[matching_keys.first]&.call if matching_keys.length == 1
-
-            nil
-          else
-            # First try exact type matching
-            result = members.find do |_key, mem|
-              member_type = Utils.unwrap_type(mem)
-              type_matches?(value, member_type)
-            end&.last&.call
-
-            return result if result
-
-            # For Hash values, try to coerce into Model member types
-            if value.is_a?(::Hash)
-              members.find do |_key, mem|
-                member_type = Utils.unwrap_type(mem)
-                # Check if member_type is a Model class
-                next unless member_type.is_a?(Class) && member_type <= Model
-
-                # Try to coerce the hash into this model type with strict mode
-                begin
-                  candidate = Utils.coerce(member_type, value, strict: true)
-
-                  # Validate that all required (non-optional) fields are present
-                  # This ensures undiscriminated unions properly distinguish between member types
-                  member_type.fields.each do |field_name, field|
-                    raise Errors::TypeError, "Required field `#{field_name}` missing for union member #{member_type.name}" if candidate.instance_variable_get(:@data)[field_name].nil? && !field.optional
-                  end
-
-                  true
-                rescue Errors::TypeError
-                  false
-                end
-              end&.last&.call
-            end
-          end
-        end
-
-        def coerce(value, strict: strict?)
-          type = resolve_member(value)
-
-          unless type
-            return value unless strict
-
-            if discriminated?
-              raise Errors::TypeError,
-                    "value of type `#{value.class}` not member of union #{self}"
-            end
-
-            raise Errors::TypeError, "could not resolve to member of union #{self}"
-          end
-
-          coerced = Utils.coerce(type, value, strict: strict)
-
-          # For discriminated unions, store the discriminant info on the coerced instance
-          # so it can be injected back during serialization (to_h)
-          if discriminated? && value.is_a?(::Hash) && coerced.is_a?(Model)
-            discriminant_value = value.fetch(@discriminant, nil) || value.fetch(@discriminant.to_s, nil)
-            if discriminant_value
-              coerced.instance_variable_set(:@_fern_union_discriminant_key, @discriminant.to_s)
-              coerced.instance_variable_set(:@_fern_union_discriminant_value, discriminant_value)
-            end
-          end
-
-          coerced
-        end
-
-        # Parse JSON string and coerce to the correct union member type
-        #
-        # @param str [String] JSON string to parse
-        # @return [Object] Coerced value matching a union member
-        def load(str)
-          coerce(::JSON.parse(str, symbolize_names: true))
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/unknown.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      module Unknown
-        include Pinnacle::Internal::Types::Type
-
-        def coerce(value)
-          value
-        end
-      end
-    end
-  end
-end

data/lib/pinnacle/internal/types/utils.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-module Pinnacle
-  module Internal
-    module Types
-      # Utilities for dealing with and checking types
-      module Utils
-        # Wraps a type into a type function
-        #
-        # @param type [Proc, Object]
-        # @return [Proc]
-        def self.wrap_type(type)
-          case type
-          when Proc
-            type
-          else
-            -> { type }
-          end
-        end
-
-        # Resolves a type or type function into a type
-        #
-        # @param type [Proc, Object]
-        # @return [Object]
-        def self.unwrap_type(type)
-          type.is_a?(Proc) ? type.call : type
-        end
-
-        def self.coerce(target, value, strict: false)
-          type = unwrap_type(target)
-
-          case type
-          in Array
-            case value
-            when ::Array
-              return type.coerce(value, strict: strict)
-            when Set, ::Hash
-              return coerce(type, value.to_a)
-            end
-          in Hash
-            case value
-            when ::Hash
-              return type.coerce(value, strict: strict)
-            when ::Array
-              return coerce(type, value.to_h)
-            end
-          in ->(t) { t <= NilClass }
-            return nil
-          in ->(t) { t <= String }
-            case value
-            when String, Symbol, Numeric, TrueClass, FalseClass
-              return value.to_s
-            end
-          in ->(t) { t <= Symbol }
-            case value
-            when Symbol, String
-              return value.to_sym
-            end
-          in ->(t) { t <= Integer }
-            case value
-            when Numeric, String, Time
-              return value.to_i
-            end
-          in ->(t) { t <= Float }
-            case value
-            when Numeric, Time, String
-              return value.to_f
-            end
-          in ->(t) { t <= Model }
-            case value
-            when type
-              return value
-            when ::Hash
-              return type.coerce(value, strict: strict)
-            end
-          in Module
-            case type
-            in ->(t) {
-                 t.singleton_class.included_modules.include?(Enum) ||
-                   t.singleton_class.included_modules.include?(Union)
-               }
-              return type.coerce(value, strict: strict)
-            else
-              value
-            end
-          else
-            value
-          end
-
-          raise Errors::TypeError, "cannot coerce value of type `#{value.class}` to `#{target}`" if strict
-
-          value
-        end
-
-        def self.symbolize_keys(hash)
-          hash.transform_keys(&:to_sym)
-        end
-
-        # Converts camelCase keys to snake_case symbols
-        # This allows SDK methods to accept both snake_case and camelCase keys
-        # e.g., { refundMethod: ... } becomes { refund_method: ... }
-        #
-        # @param hash [Hash]
-        # @return [Hash]
-        def self.normalize_keys(hash)
-          hash.transform_keys do |key|
-            key_str = key.to_s
-            # Convert camelCase to snake_case
-            snake_case = key_str.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
-            snake_case.to_sym
-          end
-        end
-      end
-    end
-  end
-end