vitable-connect 0.6.0 → 1.0.0

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

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module VitableConnect
+  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 < VitableConnect::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/VitableConnect/internal/types/type.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module VitableConnect
+  module Internal
+    module Types
+      # @abstract
+      module Type
+        include VitableConnect::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/VitableConnect/internal/types/union.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module VitableConnect
+  module Internal
+    module Types
+      # Define a union between two types
+      module Union
+        include VitableConnect::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 type_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 VitableConnect::Internal::Types::Hash
+            value.is_a?(::Hash)
+          when VitableConnect::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/VitableConnect/internal/types/unknown.rb

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

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module VitableConnect
+  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 # rubocop:disable Lint/Void
+            end
+          else
+            value # rubocop:disable Lint/Void
+          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