fastpixapi 0.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2eff6b879ab56e0014de49b73002d24bc42fea9d708940b3675c0abeff0fcf94
-  data.tar.gz: 8539b2b948cf503c1743b2772fba64f9b9b05e580cd81ff2f2a80ef0df574912
+  metadata.gz: 7a3c437a7561c393c84e02f8ba6cbf46cefbc88d5086b539ba48f6c6af728788
+  data.tar.gz: a2d2809644b100069e7fa167d81566c86d68295d8ee6e8050de5ab237283641f
 SHA512:
-  metadata.gz: e73482d1529a0a0b33fe5239e084c12634d0f57b8a1401cb76209e722255899e49807372432fc13c7fe6c51644f2eb7c802f2fdb9a14c1c122ddf8a2e586fdc1
-  data.tar.gz: '0076889ee5f69e540d4ee427210b6097f76733a9892c5f69732c9693fea4cf4049c1fd258581cd04c75af3a634c45a25a084106e20e55c9b9174b13022ce92b6'
+  metadata.gz: 6987a3abaafd87e0c3a04d249c21886509cd5ceecfb869c626958411e4e416b717334c5787e3d5e4ca929b86ca4470e6db01568be8ddb302281a189f7c2f51b9
+  data.tar.gz: 93f166294f695d8db8ca9223150538fec53f904a42caec0e6dc4b771218210185e073344d326a293c3b43b689d6ea9f21a08f2d0a56e2d069a4e7fd699757f7c

data/lib/crystalline/metadata_fields.rb

@@ -1,12 +1,10 @@
-# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# Generated code for FastPix API SDK.
 
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Crystalline
-  extend T::Sig
   module MetadataFields
-    extend T::Sig
 
     class Field
       attr_accessor :name, :type, :metadata
@@ -19,7 +17,6 @@ module Crystalline
     end
 
     module ClassMethods
-      extend T::Sig
 
       def fields
         @__fields__ = [] if @__fields__.nil?
@@ -65,17 +62,6 @@ module Crystalline
         end
       end
 
-      sig { params(json_obj: T.any(String, T::Hash[Symbol, String])).returns(Object) }
-      def from_json(json_obj)
-        begin
-          d = JSON.parse(json_obj)
-        rescue TypeError, JSON::ParserError
-          d = json_obj
-        end
-        from_dict(d)
-      end
-
-      sig { params(d: T::Hash[Symbol, String]).returns(Object) }
       def from_dict(d)
         to_build = {}
 
@@ -85,45 +71,50 @@ module Crystalline
           lookup = format_metadata.fetch(:letter_case, nil).call
           value = d[lookup]
           field_type = field.type
-          if T.nilable? field_type
+          if ::Crystalline::Utils.nilable? field_type
             if value == 'null'
               to_build[key] = nil
               next
             end
-            field_type = T.nilable_of(field_type)
+            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? && !T.nilable?(field.type)
+          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 T.arr? field_type
-            inner_type = T.arr_of(field_type)
+          if 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
-          elsif T.hash? field_type
-            val_type = T.hash_of(field_type)
+          elsif Crystalline::Utils.hash? field_type
+            val_type = Crystalline::Utils.hash_of(field_type)
 
             # rubocop:disable Style/HashTransformValues
             unmarshalled_hash = value.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
             # rubocop:enable Style/HashTransformValues
             to_build[key] = unmarshalled_hash
-          elsif T.union? field_type
+          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 = T.get_union_types(field_type).find { |t| t.name.split('::').last == type_to_deserialize }              
-              unmarshalled_val = Crystalline.unmarshal_json(value, type_to_deserialize)
-              to_build[key] = unmarshalled_val
+              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 = T.get_union_types(field_type)
+              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
-                  unmarshalled_val = Crystalline.unmarshal_json(value, union_type)
-                  to_build[key] = unmarshalled_val
+                  to_build[key] = Crystalline.unmarshal_json(value, union_type)
                 rescue TypeError
                   next
                 rescue NoMethodError
@@ -135,14 +126,11 @@ module Crystalline
               end
             end
           elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
-            unmarshalled = Crystalline.unmarshal_json(value, field_type)
-            to_build[key] = unmarshalled
+            to_build[key] = Crystalline.unmarshal_json(value, field_type)
           else
-            final_value = unmarshal_single(field_type, value, format_metadata)
-            to_build[key] = final_value
+            to_build[key] = unmarshal_single(field_type, value, format_metadata)
           end
         end
-
         new(**to_build)
       end
     end
@@ -171,7 +159,11 @@ module Crystalline
       if field.class.include? ::Crystalline::MetadataFields
         field.to_dict
       else
-        ::Crystalline.val_to_string(field, primitives: false)
+        if ::Crystalline.needs_string_conversion field
+          ::Crystalline.json_encode field
+        else
+          field
+        end
       end
     end
 

data/lib/crystalline/module.rb

@@ -0,0 +1,96 @@
+# Generated code for FastPix API SDK.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+
+  def self.to_dict(complex)
+    if complex.is_a? Array
+      complex.map { |v| Crystalline.to_dict(v) }
+    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
+    else
+      json_encode complex, primitives: false
+    end
+  end
+
+  def self.needs_string_conversion(val)
+    val.class.respond_to?(:enums) || val.is_a?(DateTime) || val.nil?
+  end
+
+  def self.to_json(complex)
+    JSON.dump(to_dict(complex))
+  end
+
+  def self.unmarshal_json(data, type)
+    if Crystalline::Utils.nilable? type
+      type = Crystalline::Utils.nilable_of type
+    end
+    if 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
+      end
+    elsif Crystalline::Utils.arr? type
+      data.map { |v| Crystalline.unmarshal_json(v, Crystalline::Utils.arr_of(type)) }
+    elsif Crystalline::Utils.hash? type
+      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)
+    else
+      data
+    end
+  end
+
+  def self.json_encode(val, primitives: true)
+    if val.class.respond_to? :enums
+      val.serialize
+    elsif val.is_a? DateTime
+      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+    elsif val.nil?
+      nil
+    elsif primitives
+      val.to_s
+    else
+      val
+    end
+  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
+    # All non-string primitives return 2
+    # All arrays and hashes return 1
+    # Strings return 0 (since any data can deserialize to a string, it should be our last attempt)
+    if klass.respond_to? :fields
+      return -1 * klass.fields.count do |field|
+        !::Crystalline::Utils.nilable? field.type
+      end
+    else
+      if klass == String
+        return 0
+      elsif klass.is_a?(T::Types::TypedArray) || klass.is_a?(T::Types::TypedHash)
+        return 1
+      end
+      return 2
+    end
+  end
+end

data/lib/crystalline/types.rb

@@ -0,0 +1,83 @@
+# Generated code for FastPix API SDK.
+
+# typed: false
+# frozen_string_literal: true
+
+module Crystalline
+  class Array
+    attr_accessor :inner_type
+
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+  end
+
+  class Hash
+    attr_accessor :key_type, :value_type
+    
+    def initialize(key_type, value_type)
+      @key_type = key_type
+      @value_type = value_type
+    end
+  end
+
+  class Union
+    attr_accessor :types
+    
+    def initialize(*types)
+      @types = types
+    end
+  end
+
+  class Nilable
+    attr_accessor :inner_type
+    
+    def initialize(inner_type)
+      @inner_type = inner_type
+    end
+  end
+
+  class Boolean
+  end
+
+  module Enum
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(val)
+      if self.class.instance_methods(false).include?(:initialize)
+        super(val)
+      else
+        @val = val
+      end
+    end
+
+    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`)'
+          end
+          @mapping[instance.serialize] = instance
+        end
+      end
+
+      def deserialize(val)
+        if @mapping.include? val
+          @mapping[val]
+        else
+          raise "Invalid value for enum: #{val}"
+        end
+      end
+    end
+
+    def serialize
+      @val
+    end
+  end
+end

data/lib/crystalline/utils.rb

@@ -1,95 +1,69 @@
-# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# Generated code for FastPix API SDK.
 
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
-
 module Crystalline
-  extend T::Sig
+  module Utils
+    def self.arr?(t)
+      if t.instance_of? Crystalline::Array
+        return true
+      end
+      false
+    end
 
-  sig { params(complex: Object).returns(Object) }
-  def self.to_dict(complex)
-    if complex.is_a? Array
-      complex.map { |v| Crystalline.to_dict(v) }
-    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
-    else
-      val_to_string complex, primitives: false
+    def self.arr_of(t)
+      t.inner_type
     end
-  end
 
-  def self.to_json(complex)
-    JSON.dump(to_dict(complex))
-  end
+    def self.hash?(t)
+      if t.instance_of? Crystalline::Hash
+        return true
+      end
+      false
+    end
 
-  sig { params(data: Object, type: Object).returns(Object) }
-  def self.unmarshal_json(data, type)
-    if T.simplifiable? type
-      type = T.simplify_type type
+    def self.hash_of(t)
+      t.value_type
     end
-    if type.instance_of?(Class) && type.include?(::Crystalline::MetadataFields)
-      type.from_dict(data)
-    elsif T.union? type
-      union_types = T.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
+    def self.nilable?(t)
+      if t.instance_of? Crystalline::Nilable
+        return true
       end
-    elsif T.arr? type
-      data.map { |v| Crystalline.unmarshal_json(v, T.arr_of(type)) }
-    elsif T.hash? type
-      data.transform_values { |v| Crystalline.unmarshal_json(v, T.hash_of(type)) }
-    elsif T.nilable?(type) && data == 'null'
-      nil
-    else
-      data
+      if t.instance_of? Crystalline::Union
+        return t.types.any? { |tt| tt.instance_of? Crystalline::Nilable }
+      end
+      false
     end
-  end
 
-  sig { params(val: Object, primitives: T::Boolean).returns(Object) }
-  def self.val_to_string(val, primitives: true)
-    if val.is_a? T::Enum
-      val.serialize
-    elsif val.is_a? DateTime
-      val.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-    elsif val.nil?
+    def self.nilable_of(t)
+      
+      if nilable? t
+        return t.inner_type
+      end
       nil
-    elsif primitives
-      val.to_s
-    else
-      val
     end
-  end
 
-  sig { params(klass: T.any(Class, T::Types::TypedArray, T::Types::TypedHash)).returns(Integer) }
-  def self.non_nilable_attr_count(klass)
-    # somewhat sane sort ordering for Union deserialization.
-    # All Crystalline objects return the number of non-nilable fields
-    # All non-string primitives return 2
-    # All arrays and hashes return 1
-    # Strings return 0 (since any data can deserialize to a string, it should be our last attempt)
-    if klass.respond_to? :fields
-      return -1 * klass.fields.count do |field|
-        !T.nilable? field.type
-      end
-    else
-      if klass == String
-        return 0
-      elsif klass.is_a?(T::Types::TypedArray) || klass.is_a?(T::Types::TypedHash)
-        return 1
+    def self.union?(t)
+      return t.instance_of? Crystalline::Union
+    end
+
+    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
-      return 2
     end
   end
 end

data/lib/crystalline.rb

@@ -1,6 +1,6 @@
-# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+# Generated code for FastPix API SDK.
 
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Crystalline
@@ -9,4 +9,5 @@ end
 
 
 require_relative 'crystalline/utils'
-require_relative 'crystalline/t'
+require_relative 'crystalline/module'
+require_relative 'crystalline/types'