sorbet-schema 0.9.1 → 0.9.3

data/lib/typed/schema.rb

@@ -20,12 +20,12 @@ module Typed
 
     sig { params(hash: Typed::HashSerializer::InputHash).returns(Typed::Serializer::DeserializeResult) }
     def from_hash(hash)
-      Typed::HashSerializer.new(schema: self).deserialize(hash)
+      hash_serializer.deserialize(hash)
     end
 
     sig { params(json: String).returns(Typed::Serializer::DeserializeResult) }
     def from_json(json)
-      Typed::JSONSerializer.new(schema: self).deserialize(json)
+      json_serializer.deserialize(json)
     end
 
     sig { params(field_name: Symbol, serializer: Field::InlineSerializer).returns(Schema) }
@@ -41,5 +41,19 @@ module Typed
         end
       )
     end
+
+    private
+
+    sig { returns(Typed::HashSerializer) }
+    def hash_serializer
+      @hash_serializer = T.let(@hash_serializer, T.nilable(Typed::HashSerializer))
+      @hash_serializer ||= Typed::HashSerializer.new(schema: self)
+    end
+
+    sig { returns(Typed::JSONSerializer) }
+    def json_serializer
+      @json_serializer = T.let(@json_serializer, T.nilable(Typed::JSONSerializer))
+      @json_serializer ||= Typed::JSONSerializer.new(schema: self)
+    end
   end
 end

data/lib/typed/serializer.rb

@@ -15,9 +15,13 @@ module Typed
     sig { returns(Schema) }
     attr_reader :schema
 
+    sig { returns(T::Hash[T::Types::Base, T.untyped]) }
+    attr_reader :coercer_cache
+
     sig { params(schema: Schema).void }
     def initialize(schema:)
       @schema = schema
+      @coercer_cache = T.let({}, T::Hash[T::Types::Base, T.untyped])
     end
 
     sig { abstract.params(source: Input).returns(DeserializeResult) }
@@ -39,33 +43,37 @@ module Typed
           Success.new(Validations::ValidatedValue.new(name: field.name, value: field.default))
         elsif value.nil? || field.works_with?(value)
           field.validate(value)
-        elsif field.type.class <= T::Types::Union
-          errors = []
-          validated_value = T.let(nil, T.nilable(Typed::Result[Typed::Validations::ValidatedValue, Typed::Validations::ValidationError]))
+        else
+          coercer_instance = fetch_coercer(field.type)
+          if !coercer_instance.nil?
+            result = coercer_instance.coerce(type: field.type, value:)
+            if result.success?
+              field.validate(result.payload)
+            else
+              Failure.new(Validations::ValidationError.new(result.error.message))
+            end
+          elsif field.type.class <= T::Types::Union
+            errors = []
+            validated_value = T.let(nil, T.nilable(Typed::Result[Typed::Validations::ValidatedValue, Typed::Validations::ValidationError]))
 
-          T.cast(field.type, T::Types::Union).types.each do |sub_type|
-            # the if clause took care of cases where value is nil so we can skip NilClass
-            next if sub_type.raw_type.equal?(NilClass)
+            T.cast(field.type, T::Types::Union).types.each do |sub_type|
+              # the if clause took care of cases where value is nil so we can skip NilClass
+              next if sub_type.raw_type.equal?(NilClass)
 
-            coercion_result = Coercion.coerce(type: sub_type, value: value)
+              coercion_result = Coercion.coerce(type: sub_type, value: value)
 
-            if coercion_result.success?
-              validated_value = field.validate(coercion_result.payload)
+              if coercion_result.success?
+                validated_value = field.validate(coercion_result.payload)
 
-              break
-            else
-              errors << Validations::ValidationError.new(coercion_result.error.message)
+                break
+              else
+                errors << Validations::ValidationError.new(coercion_result.error.message)
+              end
             end
-          end
 
-          validated_value.nil? ? Failure.new(Validations::ValidationError.new(errors.map(&:message).join(", "))) : validated_value
-        else
-          coercion_result = Coercion.coerce(type: field.type, value:)
-
-          if coercion_result.success?
-            field.validate(coercion_result.payload)
+            validated_value.nil? ? Failure.new(Validations::ValidationError.new(errors.map(&:message).join(", "))) : validated_value
           else
-            Failure.new(Validations::ValidationError.new(coercion_result.error.message))
+            Failure.new(Validations::ValidationError.new("Coercer not found for type #{field.type}."))
           end
         end
       end
@@ -88,5 +96,16 @@ module Typed
 
       hsh
     end
+
+    sig { params(type: T::Types::Base).returns(T.untyped) }
+    def fetch_coercer(type)
+      cached = coercer_cache[type]
+      return cached if cached
+
+      coercer_class = Coercion::CoercerRegistry.instance.select_coercer_by(type: type)
+      return nil if coercer_class.nil?
+
+      coercer_cache[type] = coercer_class.new
+    end
   end
 end