kintsugi_sdk 5.5.14 → 5.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8b653c7178491f4ebb3790a115ef8c4f4f3545f2c5b3eb7b0f8b975644695ca
-  data.tar.gz: 0b1b9a387fd230cbc5e14b9f971d5b12411218fec1f2ff8e5219510515030e6b
+  metadata.gz: 01dc6b44526f591a090a16bd42c48d838a75a72c6699abb75083c998ec6dc005
+  data.tar.gz: 6e77246bf663ad87704bd5e42b225c3ad3235de728e4531d3eaac302754e5ed5
 SHA512:
-  metadata.gz: 5cdba6a77c503d10437c7894058f25805da77558f0251340de297f69a6ff9a6ae827a51c2c8a53870a12fc7017d6cc33fc89af8d723fea3a3fd0a86debc464f0
-  data.tar.gz: 784486eff59bb37c722b6ac944cf38ce732324f297b5dfe4fee2af0ad9588739ed5bc046e4d002f4ece44e814b35d3f5da74237a2fa5d9c1c7965d1b7be26720
+  metadata.gz: c6ebbf8344599e17cbf97e52663c7b02f75f33749edc2af94fac1194306407fd5c520b3f87fbf08261db74e0668740b5e065e697e3125af38d7ee324a09d8a8b
+  data.tar.gz: 23614642b7ef742ae64adcdf75a3428afa55b2857ed7fa67e1b2310ab35a09b3268a266c67b16d00cba205a1f5c9d1bc444218fdb34fb8c469907472a5558dbd

data/lib/crystalline/enum.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+module Crystalline
+  module Enum
+    mixes_in_class_methods(ClassMethods)
+
+    module ClassMethods
+      def enums(&blk); end
+      def open!; end
+      def open?; end
+      def deserialize(val); end
+    end
+
+    def serialize; end
+    def known?; end
+  end
+end

data/lib/crystalline/metadata_fields.rb

@@ -37,19 +37,30 @@ module Crystalline
       def unmarshal_single(field_type, value, format_metadata = nil)
         decoder = format_metadata.fetch(:decoder, nil)
 
-        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+        # Delegate complex Crystalline types to unmarshal_json
+        if field_type.is_a?(Crystalline::DiscriminatedUnion) ||
+           Crystalline::Utils.arr?(field_type) ||
+           Crystalline::Utils.hash?(field_type) ||
+           Crystalline::Utils.union?(field_type)
+          return Crystalline.unmarshal_json(value, field_type)
+        elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           return field_type.from_dict(value)
         elsif field_type.to_s == 'Date'
           return Date.parse(value)
         elsif field_type.to_s == 'DateTime'
           return DateTime.parse(value)
         elsif field_type.to_s == 'Object'
-          # rubocop:disable Lint/SuppressedException
-          begin
-            value = JSON.parse(value)
-          rescue TypeError, JSON::ParserError
+          if value.is_a?(::String)
+            trimmed = value.lstrip
+            if trimmed.start_with?('{') || trimmed.start_with?('[')
+              # rubocop:disable Lint/SuppressedException
+              begin
+                value = JSON.parse(value)
+              rescue TypeError, JSON::ParserError
+              end
+              # rubocop:enable Lint/SuppressedException
+            end
           end
-          # rubocop:enable Lint/SuppressedException
           return value
         elsif field_type.to_s == 'Float'
           return value.to_f
@@ -62,29 +73,30 @@ module Crystalline
         end
       end
 
-      def from_json(json_obj)
-        case json_obj
-        when String
-          begin
-            d = JSON.parse(json_obj)
-          rescue JSON::ParserError
-            d = json_obj
-          end
-        else
-          d = json_obj
-        end
-        from_json(d)
-      end
-
       def from_dict(d)
         to_build = {}
 
+        # Collect lookup keys for regular fields so we can identify additional properties later
+        known_keys = {}
+        additional_props_fields = []
         fields.each do |field|
+          format_metadata = field.metadata.fetch(:format_json, {})
+          if format_metadata.fetch(:additional_properties, false)
+            additional_props_fields << field
+          else
+            lookup = format_metadata.fetch(:letter_case, nil).call
+            known_keys[lookup] = true
+          end
+        end
+
+        # Process regular fields
+        (fields - additional_props_fields).each do |field|
           key = field.name
           format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
           lookup = format_metadata.fetch(:letter_case, nil).call
           value = d[lookup]
-          field_type = field.type
           if ::Crystalline::Utils.nilable? field_type
             if value == 'null'
               to_build[key] = nil
@@ -92,13 +104,15 @@ module Crystalline
             end
             field_type = ::Crystalline::Utils.nilable_of(field_type)
           end
-          
+
           # If field is not nilable, and the value is not in the dict, raise a KeyError
           raise KeyError, "key #{lookup} not found in hash" if value.nil? && !::Crystalline::Utils.nilable?(field.type)
           # If field is nilable, and the value is not in the dict, just move to the next field
           next if value.nil?
 
-          if Crystalline::Utils.arr? field_type
+          if field_type.is_a?(Crystalline::DiscriminatedUnion)
+            to_build[key] = field_type.parse(value)
+          elsif Crystalline::Utils.arr? field_type
             inner_type = Crystalline::Utils.arr_of(field_type)
             unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f, format_metadata) }
             to_build[key] = unmarshalled_array
@@ -111,25 +125,36 @@ module Crystalline
             to_build[key] = unmarshalled_hash
           elsif Crystalline::Utils.union? field_type
             discriminator = field.metadata.fetch(:discriminator, nil)
+            discriminator_mapping = field.metadata.fetch(:discriminator_mapping, nil)
             if !discriminator.nil?
-              type_to_deserialize = value.fetch(discriminator)
-              type_to_deserialize = Crystalline::Utils.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }
+              discriminator_value = value.fetch(discriminator)
+              if !discriminator_mapping.nil?
+                # Use explicit mapping from discriminator value to type
+                type_to_deserialize = discriminator_mapping[discriminator_value]
+              else
+                # Fallback: try to match discriminator value against type name
+                type_to_deserialize = Crystalline::Utils.get_union_types(field_type).find { |t| t.name.split('::').last == discriminator_value }
+              end
               to_build[key] = Crystalline.unmarshal_json(value, type_to_deserialize)
             else
               union_types = Crystalline::Utils.get_union_types(field_type)
               union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
 
-              union_types.each do |union_type|
-                begin
-                  to_build[key] = Crystalline.unmarshal_json(value, union_type)
-                rescue TypeError
-                  next
-                rescue NoMethodError
-                  next
-                rescue KeyError
-                  next
+              if Crystalline.union_strategy == :populated_fields
+                to_build[key] = Crystalline.unmarshal_union_populated_fields(value, union_types)
+              else
+                union_types.each do |union_type|
+                  begin
+                    to_build[key] = Crystalline.unmarshal_json(value, union_type)
+                  rescue TypeError
+                    next
+                  rescue NoMethodError
+                    next
+                  rescue KeyError
+                    next
+                  end
+                  break
                 end
-                break
               end
             end
           elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
@@ -138,6 +163,32 @@ module Crystalline
             to_build[key] = unmarshal_single(field_type, value, format_metadata)
           end
         end
+
+        # Process additional properties fields: collect remaining keys from the dict
+        additional_props_fields.each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
+          remaining = d.reject { |k, _| known_keys.key?(k) }
+          if remaining.empty?
+            next if ::Crystalline::Utils.nilable?(field.type)
+
+            raise KeyError, 'no additional properties found in hash'
+          end
+
+          inner_field_type = field_type
+          inner_field_type = ::Crystalline::Utils.nilable_of(inner_field_type) if ::Crystalline::Utils.nilable?(inner_field_type)
+          if Crystalline::Utils.hash?(inner_field_type)
+            val_type = Crystalline::Utils.hash_of(inner_field_type)
+            # rubocop:disable Style/HashTransformValues
+            to_build[key] = remaining.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+          else
+            to_build[key] = remaining
+          end
+        end
+
         new(**to_build)
       end
     end
@@ -179,6 +230,8 @@ module Crystalline
       fields.sort_by(&:name).each do |field|
         format_json_meta = field.metadata[:format_json]
         required = !format_json_meta.nil? && format_json_meta.include?(:required)
+        is_additional_props = !format_json_meta.nil? && format_json_meta.fetch(:additional_properties, false)
+
         if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
           key = format_json_meta[:letter_case].call(field.name)
         else
@@ -189,10 +242,13 @@ module Crystalline
         next if f.nil? && !required
         result[key] = nil if f.nil? && required
 
-        if f.is_a? Array
+        # Flatten additional properties into the parent object
+        if is_additional_props && f.is_a?(::Hash)
+          f.each { |k, v| result[k] = marshal_single(v) }
+        elsif f.is_a? ::Array
           result[key] = f.map { |o| marshal_single(o) }
-        elsif f.is_a? Hash
-          result[key] = f.map { |k, v| [k, marshal_single(v)] }
+        elsif f.is_a? ::Hash
+          result[key] = f.transform_values { |v| marshal_single(v) }
         else
           result[key] = marshal_single(f)
         end

data/lib/crystalline/module.rb

@@ -4,11 +4,16 @@
 # frozen_string_literal: true
 
 module Crystalline
+  @union_strategy = :left_to_right
+
+  class << self
+    attr_accessor :union_strategy
+  end
 
   def self.to_dict(complex)
-    if complex.is_a? Array
+    if complex.is_a? ::Array
       complex.map { |v| Crystalline.to_dict(v) }
-    elsif complex.is_a? Hash
+    elsif complex.is_a? ::Hash
       complex.transform_values { |v| Crystalline.to_dict(v) }
     elsif complex.respond_to?(:class) && complex.class.include?(::Crystalline::MetadataFields)
       complex.to_dict
@@ -29,21 +34,18 @@ module Crystalline
     if Crystalline::Utils.nilable? type
       type = Crystalline::Utils.nilable_of type
     end
-    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
+    if type.is_a?(Crystalline::DiscriminatedUnion)
+      type.parse(data)
+    elsif type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
       type.from_dict(data)
     elsif Crystalline::Utils.union? type
       union_types = Crystalline::Utils.get_union_types(type)
       union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
 
-      union_types.each do |union_type|
-        unmarshalled_val = Crystalline.unmarshal_json(data, union_type)
-        return unmarshalled_val
-      rescue TypeError
-        next
-      rescue NoMethodError
-        next
-      rescue KeyError
-        next
+      if Crystalline.union_strategy == :populated_fields
+        Crystalline.unmarshal_union_populated_fields(data, union_types)
+      else
+        Crystalline.unmarshal_union_left_to_right(data, union_types)
       end
     elsif Crystalline::Utils.arr? type
       data.map { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.arr_of(type)) }
@@ -51,6 +53,12 @@ module Crystalline
       data.transform_values { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.hash_of(type)) }
     elsif Crystalline::Utils.nilable?(type) && data == 'null'
       nil
+    elsif Crystalline::Utils.boolean? type
+      Crystalline::Utils.to_boolean(data)
+    elsif type.is_a?(Class) && type < T::Enum
+      type.deserialize(data)
+    elsif type.is_a?(Class) && type.respond_to?(:enums) && type.respond_to?(:deserialize)
+      type.deserialize(data)
     else
       data
     end
@@ -60,7 +68,7 @@ module Crystalline
     if val.class.respond_to? :enums
       val.serialize
     elsif val.is_a? DateTime
-      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ').sub(/(\.\d*[1-9])0+Z\z/, '\1Z').sub(/\.0+Z\z/, 'Z')
     elsif val.nil?
       nil
     elsif primitives
@@ -70,6 +78,88 @@ module Crystalline
     end
   end
 
+  def self.unmarshal_union_left_to_right(data, union_types)
+    union_types.each do |union_type|
+      return Crystalline.unmarshal_json(data, union_type)
+    rescue TypeError
+      next
+    rescue NoMethodError
+      next
+    rescue KeyError
+      next
+    end
+    nil
+  end
+
+  def self.unmarshal_union_populated_fields(data, union_types)
+    best_value = nil
+    best_matched = -1
+    best_inexact = 0
+    best_unmatched = 0
+
+    union_types.each do |union_type|
+      value = Crystalline.unmarshal_json(data, union_type)
+      matched, inexact, unmatched = count_matched_fields(value, data)
+
+      if best_value.nil? ||
+         matched > best_matched ||
+         (matched == best_matched && inexact < best_inexact) ||
+         (matched == best_matched && inexact == best_inexact && unmatched < best_unmatched)
+        best_value = value
+        best_matched = matched
+        best_inexact = inexact
+        best_unmatched = unmatched
+      end
+    rescue TypeError
+      next
+    rescue NoMethodError
+      next
+    rescue KeyError
+      next
+    end
+    best_value
+  end
+
+  def self.count_matched_fields(value, raw_data)
+    matched = 0
+    inexact = 0
+    unmatched = 0
+
+    if value.is_a?(Crystalline::Unknown)
+      return [0, 0, 0]
+    elsif value.class.include?(::Crystalline::MetadataFields)
+      value.fields.each do |field|
+        format_metadata = field.metadata.fetch(:format_json, {})
+        lookup = format_metadata.fetch(:letter_case, nil)&.call
+        field_val = value.send(field.name)
+
+        if raw_data.is_a?(::Hash) && lookup && raw_data.key?(lookup)
+          if field_val.class.include?(::Crystalline::MetadataFields) && raw_data[lookup].is_a?(::Hash)
+            nested_matched, nested_inexact, nested_unmatched = count_matched_fields(field_val, raw_data[lookup])
+            matched += nested_matched
+            inexact += nested_inexact
+            unmatched += nested_unmatched
+          else
+            matched += 1
+            if field_val.respond_to?(:known?) && !field_val.known?
+              inexact += 1
+            end
+          end
+        elsif !::Crystalline::Utils.nilable?(field.type)
+          unmatched += 1
+        end
+      end
+    elsif value.is_a?(::Array)
+      matched = value.length
+    elsif value.is_a?(::Hash)
+      matched = value.length
+    else
+      matched = 1
+    end
+
+    [matched, inexact, unmatched]
+  end
+
   def self.non_nilable_attr_count(klass)
     # somewhat sane sort ordering for Union deserialization.
     # All Crystalline objects return the number of non-nilable fields

data/lib/crystalline/types.rb

@@ -14,7 +14,7 @@ module Crystalline
 
   class Hash
     attr_accessor :key_type, :value_type
-    
+
     def initialize(key_type, value_type)
       @key_type = key_type
       @value_type = value_type
@@ -23,7 +23,7 @@ module Crystalline
 
   class Union
     attr_accessor :types
-    
+
     def initialize(*types)
       @types = types
     end
@@ -31,7 +31,7 @@ module Crystalline
 
   class Nilable
     attr_accessor :inner_type
-    
+
     def initialize(inner_type)
       @inner_type = inner_type
     end
@@ -40,26 +40,101 @@ module Crystalline
   class Boolean
   end
 
+  # Wraps an unrecognized payload from an open discriminated union.
+  # Produced when the discriminator value is missing, unknown, or schema validation fails.
+  class Unknown
+    attr_reader :raw
+
+    def initialize(raw:)
+      @raw = raw
+    end
+
+    def unknown?
+      true
+    end
+  end
+
+  # Forward-compatible discriminated union parser.
+  # Known discriminator values are deserialized to their mapped types.
+  # Unknown or invalid payloads are captured as Crystalline::Unknown.
+  class DiscriminatedUnion
+    attr_reader :discriminator, :variants
+
+    def initialize(discriminator, variants)
+      @discriminator = discriminator
+      @variants = variants
+    end
+
+    def parse(payload)
+      unless payload.is_a?(::Hash)
+        return Unknown.new(raw: payload)
+      end
+
+      disc_value = payload[@discriminator]
+      unless disc_value.is_a?(::String)
+        return Unknown.new(raw: payload)
+      end
+
+      variant_type = @variants[disc_value]
+      unless variant_type
+        return Unknown.new(raw: payload)
+      end
+
+      begin
+        Crystalline.unmarshal_json(payload, variant_type)
+      rescue StandardError
+        Unknown.new(raw: payload)
+      end
+    end
+  end
+
+  def self.unknown?(value)
+    value.is_a?(Unknown)
+  end
+
   module Enum
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
     def initialize(val)
-      puts methods
-      if instance_methods(false).include?(:initialize)
+      if self.class.instance_methods(false).include?(:initialize)
         super(val)
       else
         @val = val
       end
     end
 
-    def self.enums(&blk)
-      @mapping = {}
+    module ClassMethods
+      def enums(&blk)
+        @mapping = {}
 
-      yield
-      constants(false).each do |const_name|
-        instance = const_get(const_name, false)
-        unless instance.is_a? self
-          raise 'Enum constants must be instances of the Enum class (e.g. `Foo = new`)'
+        yield
+        constants(false).each do |const_name|
+          instance = const_get(const_name, false)
+          unless instance.is_a? self
+            raise 'Enum constants must be instances of the Enum class (e.g. `Foo = new`)'
+          end
+          @mapping[instance.serialize] = instance
+        end
+      end
+
+      def open!
+        @open = true
+      end
+
+      def open?
+        @open == true
+      end
+
+      def deserialize(val)
+        if @mapping.include? val
+          @mapping[val]
+        elsif open?
+          new(val)
+        else
+          raise "Invalid value for enum: #{val}"
         end
-        @mapping[instance.serialize] = instance
       end
     end
 
@@ -67,12 +142,29 @@ module Crystalline
       @val
     end
 
-    def deserialize(val)
-      if @mapping.include? val
-        @mapping[val]
-      else
-        raise "Invalid value for enum: #{val}"
-      end
+    def to_s
+      serialize.to_s
+    end
+
+    def inspect
+      "#<#{self.class} #{serialize.inspect}>"
+    end
+
+    def known?
+      self.class.instance_variable_get(:@mapping)&.value?(self) || false
+    end
+
+    def ==(other)
+      other = other.serialize if other.is_a?(self.class)
+      @val == other
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      @val.hash
     end
   end
 end

data/lib/crystalline/utils.rb

@@ -52,5 +52,18 @@ module Crystalline
     def self.get_union_types(t)
       t.types
     end
+
+    def self.boolean?(t)
+      t.instance_of? Crystalline::Boolean
+    end
+
+    def self.to_boolean(value)
+      case value
+      when true, false
+        value
+      else
+        raise TypeError, "Cannot convert #{value.inspect} to boolean. The value is of type #{value.class}"
+      end
+    end
   end
 end