sorbet-schema 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca765b78224dee7c4f7bd3c5b8812e7b2a1f5e2d032449b1e51f70b433cbd078
-  data.tar.gz: 8ea2d3484c9fdd9e8d224255ada5896beaf85ea5f7b26c2d19570045dc8c2d51
+  metadata.gz: 9af17198e776435ac97075ce33b365c34fd539aa7998ca9f60f9eef1a57ddd95
+  data.tar.gz: 8afbc08bc51a6cdc849803273af0c44e9f8a86e04991d9cd70767e565b3c68ca
 SHA512:
-  metadata.gz: 77c4ac65f9c389b81da160c770a016bcdcee0f7473045e61c5a2faf6372564c9305ce961987dbf46edc56f62bfe3152fd33ab59021d5f701e12c3bfb6043a7ca
-  data.tar.gz: 475a44a999ab80d56537a8bf57358996963ce617e2846ebe024d4ae17df9fa37b3a05be1879a275766c5e43a4e08c805ac3366624f2ab3c52f03a2a8cc7d6591
+  metadata.gz: 260e1ee1603ef6ae6ddd5cc20544a874a097b65f95736e42dc97f489b979df5a6a41d48124d2a5f5c2643e9f0989de0e67ed7a7f787adabf39fd12168bc05b65
+  data.tar.gz: 94836f2ea97f2c4ac158562f2a6b9ffdd05d4ad2a0f34423e77d42b989c894caf08e6fdc28693491d8903d826aa3da860a4d85ceb14ba37b0a448542a41b51e7

data/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0](https://github.com/maxveldink/sorbet-schema/compare/v0.3.0...v0.4.0) (2024-03-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* Have coercers take in a type instead of the full field
+* Update Field's types to a support Sorbets T::Types::Base classes
+* Changed serialize return value to a Result
+* adds SerializationError ancestor
+
+### Features
+
+* Add BooleanCoercer ([acd220f](https://github.com/maxveldink/sorbet-schema/commit/acd220f55fe0ebc823de6cc43776a1f510a4acd0))
+* Add EnumCoercer ([5c0e2b5](https://github.com/maxveldink/sorbet-schema/commit/5c0e2b51990dfb72218129b0935f881622324194))
+* Add from_hash and from_json helpers to Schemas ([#44](https://github.com/maxveldink/sorbet-schema/issues/44)) ([55c2da7](https://github.com/maxveldink/sorbet-schema/commit/55c2da77b7c2636339c684560bf15c51ff3ff4b1))
+* Add idempotency to Struct coercer ([3a42957](https://github.com/maxveldink/sorbet-schema/commit/3a42957836afee55b074fc5c8a41eac6d31ada70))
+* Add option to serialize values to HashSerializer ([710d365](https://github.com/maxveldink/sorbet-schema/commit/710d365d477bd6c6bff20929fcdcc1d1cc95bdb3))
+* Adds TypedArray coercer ([795ddd9](https://github.com/maxveldink/sorbet-schema/commit/795ddd97f05502b154d4cb165878c1f78935cb3c))
+
+
+### Code Refactoring
+
+* adds SerializationError ancestor ([f8ea753](https://github.com/maxveldink/sorbet-schema/commit/f8ea75304613cbab17f698006698a2524a44b538))
+* Changed serialize return value to a Result ([948c678](https://github.com/maxveldink/sorbet-schema/commit/948c67815dab19793dd2f321a90797d123740e0e))
+* Have coercers take in a type instead of the full field ([c06169e](https://github.com/maxveldink/sorbet-schema/commit/c06169e0fa1cf7c8f645ecabef19cc2f5facffe4))
+* Update Field's types to a support Sorbets T::Types::Base classes ([9ef1cd5](https://github.com/maxveldink/sorbet-schema/commit/9ef1cd5caf09396d8dae6a4db1feeb4f88dd25e9))
+
+## [0.3.0](https://github.com/maxveldink/sorbet-schema/compare/v0.2.2...v0.3.0) (2024-03-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* Remove struct_ext for now
+
+### Code Refactoring
+
+* Remove struct_ext for now ([4a505cb](https://github.com/maxveldink/sorbet-schema/commit/4a505cba47b7fd0ae96d76a543f97228a3cd00d7))
+
 ## [0.2.2](https://github.com/maxveldink/sorbet-schema/compare/v0.2.1...v0.2.2) (2024-03-12)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.2.2)
+    sorbet-schema (0.4.0)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)

data/lib/sorbet-schema/hash_transformer.rb

@@ -6,17 +6,42 @@
 class HashTransformer
   extend T::Sig
 
+  sig { params(should_serialize_values: T::Boolean).void }
+  def initialize(should_serialize_values: false)
+    @should_serialize_values = should_serialize_values
+  end
+
   sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
   def deep_symbolize_keys(hash)
     hash.each_with_object({}) do |(key, value), result|
-      result[key.to_sym] = value.is_a?(Hash) ? deep_symbolize_keys(value) : value
+      result[key.to_sym] = transform_value(value, hash_transformation_method: :deep_symbolize_keys)
     end
   end
 
   sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[String, T.untyped]) }
   def deep_stringify_keys(hash)
     hash.each_with_object({}) do |(key, value), result|
-      result[key.to_s] = value.is_a?(Hash) ? deep_stringify_keys(value) : value
+      result[key.to_s] = transform_value(value, hash_transformation_method: :deep_stringify_keys)
+    end
+  end
+
+  private
+
+  sig { returns(T::Boolean) }
+  attr_reader :should_serialize_values
+
+  sig { params(value: T.untyped, hash_transformation_method: Symbol).returns(T.untyped) }
+  def transform_value(value, hash_transformation_method:)
+    if value.is_a?(Hash)
+      send(hash_transformation_method, value)
+    elsif value.is_a?(Array)
+      value.map { |inner_val| transform_value(inner_val, hash_transformation_method: hash_transformation_method) }
+    elsif value.is_a?(T::Struct) && should_serialize_values
+      deep_symbolize_keys(value.serialize)
+    elsif value.respond_to?(:serialize) && should_serialize_values
+      value.serialize
+    else
+      value
     end
   end
 end

data/lib/sorbet-schema/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module SorbetSchema
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/typed/coercion/boolean_coercer.rb

@@ -0,0 +1,31 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class BooleanCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Boolean} }
+
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      def used_for_type?(type)
+        type == T::Utils.coerce(T::Boolean)
+      end
+
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        if T.cast(type, T::Types::Base).recursively_valid?(value)
+          Success.new(value)
+        elsif value == "true"
+          Success.new(true)
+        elsif value == "false"
+          Success.new(false)
+        else
+          Failure.new(CoercionError.new)
+        end
+      rescue TypeError
+        Failure.new(CoercionError.new("Field type must be a T::Boolean."))
+      end
+    end
+  end
+end

data/lib/typed/coercion/coercer.rb

@@ -10,12 +10,12 @@ module Typed
 
       Target = type_member(:out)
 
-      sig { abstract.params(type: T::Class[T.anything]).returns(T::Boolean) }
+      sig { abstract.params(type: Field::Type).returns(T::Boolean) }
       def used_for_type?(type)
       end
 
-      sig { abstract.params(field: Field, value: Value).returns(Result[Target, CoercionError]) }
-      def coerce(field:, value:)
+      sig { abstract.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
       end
     end
   end

data/lib/typed/coercion/coercer_registry.rb

@@ -11,7 +11,18 @@ module Typed
 
       Registry = T.type_alias { T::Array[T.class_of(Coercer)] }
 
-      DEFAULT_COERCERS = T.let([StringCoercer, IntegerCoercer, FloatCoercer, StructCoercer], Registry)
+      DEFAULT_COERCERS = T.let(
+        [
+          StringCoercer,
+          BooleanCoercer,
+          IntegerCoercer,
+          FloatCoercer,
+          EnumCoercer,
+          StructCoercer,
+          TypedArrayCoercer
+        ],
+        Registry
+      )
 
       sig { void }
       def initialize
@@ -28,7 +39,7 @@ module Typed
         @available = DEFAULT_COERCERS.clone
       end
 
-      sig { params(type: T::Class[T.anything]).returns(T.nilable(T.class_of(Coercer))) }
+      sig { params(type: Field::Type).returns(T.nilable(T.class_of(Coercer))) }
       def select_coercer_by(type:)
         @available.find { |coercer| coercer.new.used_for_type?(type) }
       end

data/lib/typed/coercion/enum_coercer.rb

@@ -0,0 +1,25 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class EnumCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Enum} }
+
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      def used_for_type?(type)
+        type.is_a?(Class) && !!(type < T::Enum)
+      end
+
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Enum for Enum coercion.")) unless type.is_a?(Class) && !!(type < T::Enum)
+
+        Success.new(type.from_serialized(value))
+      rescue KeyError => e
+        Failure.new(CoercionError.new(e.message))
+      end
+    end
+  end
+end

data/lib/typed/coercion/float_coercer.rb

@@ -7,13 +7,13 @@ module Typed
 
       Target = type_member { {fixed: Float} }
 
-      sig { override.params(type: T::Class[T.anything]).returns(T::Boolean) }
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
       def used_for_type?(type)
-        type == Float
+        T::Utils.coerce(type) == T::Utils.coerce(Float)
       end
 
-      sig { override.params(field: Field, value: Value).returns(Result[Target, CoercionError]) }
-      def coerce(field:, value:)
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
         Success.new(Float(value))
       rescue ArgumentError, TypeError
         Failure.new(CoercionError.new("'#{value}' cannot be coerced into Float."))

data/lib/typed/coercion/integer_coercer.rb

@@ -7,13 +7,13 @@ module Typed
 
       Target = type_member { {fixed: Integer} }
 
-      sig { override.params(type: T::Class[T.anything]).returns(T::Boolean) }
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
       def used_for_type?(type)
         type == Integer
       end
 
-      sig { override.params(field: Field, value: Value).returns(Result[Target, CoercionError]) }
-      def coerce(field:, value:)
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
         Success.new(Integer(value))
       rescue ArgumentError, TypeError
         Failure.new(CoercionError.new("'#{value}' cannot be coerced into Integer."))

data/lib/typed/coercion/string_coercer.rb

@@ -7,13 +7,13 @@ module Typed
 
       Target = type_member { {fixed: String} }
 
-      sig { override.params(type: T::Class[T.anything]).returns(T::Boolean) }
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
       def used_for_type?(type)
         type == String
       end
 
-      sig { override.params(field: Field, value: Value).returns(Result[Target, CoercionError]) }
-      def coerce(field:, value:)
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
         Success.new(String(value))
       end
     end

data/lib/typed/coercion/struct_coercer.rb

@@ -7,17 +7,17 @@ module Typed
 
       Target = type_member { {fixed: T::Struct} }
 
-      sig { override.params(type: T::Class[T.anything]).returns(T::Boolean) }
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
       def used_for_type?(type)
-        !!(type < T::Struct)
+        type.is_a?(Class) && !!(type < T::Struct)
       end
 
-      sig { override.params(field: Field, value: Value).returns(Result[Target, CoercionError]) }
-      def coerce(field:, value:)
-        type = field.type
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless type.is_a?(Class) && type < T::Struct
+        return Success.new(value) if value.instance_of?(type)
 
-        return Failure.new(CoercionError.new("Field type must inherit from T::Struct for Struct coercion.")) unless type < T::Struct
-        return Failure.new(CoercionError.new("Value must be a Hash for Struct coercion.")) unless value.is_a?(Hash)
+        return Failure.new(CoercionError.new("Value of type '#{value.class}' cannot be coerced to #{type} Struct.")) unless value.is_a?(Hash)
 
         Success.new(type.from_hash!(HashTransformer.new.deep_stringify_keys(value)))
       rescue ArgumentError => e

data/lib/typed/coercion/typed_array_coercer.rb

@@ -0,0 +1,34 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class TypedArrayCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Array[T.untyped]} }
+
+      sig { override.params(type: Field::Type).returns(T::Boolean) }
+      def used_for_type?(type)
+        type.is_a?(T::Types::TypedArray)
+      end
+
+      sig { override.params(type: Field::Type, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must be a T::Array.")) unless type.is_a?(T::Types::TypedArray)
+        return Failure.new(CoercionError.new("Value must be an Array.")) unless value.is_a?(Array)
+
+        return Success.new(value) if type.recursively_valid?(value)
+
+        coerced_results = value.map do |item|
+          Coercion.coerce(type: type.type.raw_type, value: item)
+        end
+
+        if coerced_results.all?(&:success?)
+          Success.new(coerced_results.map(&:payload))
+        else
+          Failure.new(CoercionError.new(coerced_results.select(&:failure?).map(&:error).map(&:message).join(" | ")))
+        end
+      end
+    end
+  end
+end

data/lib/typed/coercion.rb

@@ -9,13 +9,13 @@ module Typed
       CoercerRegistry.instance.register(coercer)
     end
 
-    sig { type_parameters(:U).params(field: Field, value: Value).returns(Result[Value, CoercionError]) }
-    def self.coerce(field:, value:)
-      coercer = CoercerRegistry.instance.select_coercer_by(type: field.type)
+    sig { type_parameters(:U).params(type: Field::Type, value: Value).returns(Result[Value, CoercionError]) }
+    def self.coerce(type:, value:)
+      coercer = CoercerRegistry.instance.select_coercer_by(type: type)
 
       return Failure.new(CoercionNotSupportedError.new) unless coercer
 
-      coercer.new.coerce(field: field, value: value)
+      coercer.new.coerce(type: type, value: value)
     end
   end
 end

data/lib/typed/deserialize_error.rb

@@ -1,7 +1,7 @@
 # typed: strict
 
 module Typed
-  class DeserializeError < StandardError
+  class DeserializeError < SerializationError
     extend T::Sig
 
     sig { returns({error: String}) }

data/lib/typed/field.rb

@@ -6,8 +6,10 @@ module Typed
 
     include ActsAsComparable
 
+    Type = T.type_alias { T.any(T::Class[T.anything], T::Types::Base) }
+
     const :name, Symbol
-    const :type, T::Class[T.anything]
+    const :type, Type
     const :required, T::Boolean, default: true
 
     sig { returns(T::Boolean) }
@@ -24,5 +26,12 @@ module Typed
     def validate(value)
       Validations::FieldTypeValidator.new.validate(field: self, value: value)
     end
+
+    sig { params(value: Value).returns(T::Boolean) }
+    def works_with?(value)
+      value.class == type || T.cast(type, T::Types::Base).recursively_valid?(value) # standard:disable Style/ClassEqualityComparison
+    rescue TypeError
+      false
+    end
   end
 end

data/lib/typed/hash_serializer.rb

@@ -3,19 +3,33 @@
 module Typed
   class HashSerializer < Serializer
     InputHash = T.type_alias { T::Hash[T.any(Symbol, String), T.untyped] }
-    OutputHash = T.type_alias { Params }
-
     Input = type_member { {fixed: InputHash} }
-    Output = type_member { {fixed: OutputHash} }
+    Output = type_member { {fixed: Params} }
+
+    sig { params(schema: Schema, should_serialize_values: T::Boolean).void }
+    def initialize(schema:, should_serialize_values: false)
+      @should_serialize_values = should_serialize_values
+
+      super(schema: schema)
+    end
 
     sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
     def deserialize(source)
-      deserialize_from_creation_params(HashTransformer.new.deep_symbolize_keys(source))
+      deserialize_from_creation_params(HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(source))
     end
 
-    sig { override.params(struct: T::Struct).returns(Output) }
+    sig { override.params(struct: T::Struct).returns(Result[Output, SerializeError]) }
     def serialize(struct)
-      HashTransformer.new.deep_symbolize_keys(struct.serialize)
+      return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to target type of '#{schema.target}'.")) if struct.class != schema.target
+
+      hsh = schema.fields.each_with_object({}) { |field, hsh| hsh[field.name] = struct.send(field.name) }
+
+      Success.new(HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(hsh.compact))
     end
+
+    private
+
+    sig { returns(T::Boolean) }
+    attr_reader :should_serialize_values
   end
 end

data/lib/typed/json_serializer.rb

@@ -20,9 +20,11 @@ module Typed
       Failure.new(ParseError.new(format: :json))
     end
 
-    sig { override.params(struct: T::Struct).returns(Output) }
+    sig { override.params(struct: T::Struct).returns(Result[Output, SerializeError]) }
     def serialize(struct)
-      JSON.generate(struct.serialize)
+      return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to target type of '#{schema.target}'.")) if struct.class != schema.target
+
+      Success.new(JSON.generate(struct.serialize))
     end
   end
 end

data/lib/typed/schema.rb

@@ -2,9 +2,30 @@
 
 module Typed
   class Schema < T::Struct
+    extend T::Sig
     include ActsAsComparable
 
     const :fields, T::Array[Field], default: []
     const :target, T.class_of(T::Struct)
+
+    sig { params(struct: T.class_of(T::Struct)).returns(Typed::Schema) }
+    def self.from_struct(struct)
+      Typed::Schema.new(
+        target: struct,
+        fields: struct.props.map do |name, properties|
+          Typed::Field.new(name: name, type: properties[:type], required: !properties[:fully_optional])
+        end
+      )
+    end
+
+    sig { params(hash: Typed::HashSerializer::InputHash).returns(Typed::Serializer::DeserializeResult) }
+    def from_hash(hash)
+      Typed::HashSerializer.new(schema: self).deserialize(hash)
+    end
+
+    sig { params(json: String).returns(Typed::Serializer::DeserializeResult) }
+    def from_json(json)
+      Typed::JSONSerializer.new(schema: self).deserialize(json)
+    end
   end
 end

data/lib/typed/serialization_error.rb

@@ -0,0 +1,17 @@
+# typed: strict
+
+module Typed
+  class SerializationError < StandardError
+    extend T::Sig
+
+    sig { returns({error: String}) }
+    def to_h
+      {error: message}
+    end
+
+    sig { params(_options: T::Hash[T.untyped, T.untyped]).returns(String) }
+    def to_json(_options = {})
+      JSON.generate(to_h)
+    end
+  end
+end

data/lib/typed/serialize_error.rb

@@ -0,0 +1,6 @@
+# typed: strict
+
+module Typed
+  class SerializeError < SerializationError
+  end
+end

data/lib/typed/serializer.rb

@@ -20,11 +20,11 @@ module Typed
       @schema = schema
     end
 
-    sig { abstract.params(source: Output).returns(DeserializeResult) }
+    sig { abstract.params(source: Input).returns(DeserializeResult) }
     def deserialize(source)
     end
 
-    sig { abstract.params(struct: T::Struct).returns(Output) }
+    sig { abstract.params(struct: T::Struct).returns(Result[Output, SerializeError]) }
     def serialize(struct)
     end
 
@@ -35,18 +35,16 @@ module Typed
       results = schema.fields.map do |field|
         value = creation_params[field.name]
 
-        if value.nil?
+        if value.nil? || field.works_with?(value)
           field.validate(value)
-        elsif value.class != field.type
-          coercion_result = Coercion.coerce(field: field, value: value)
+        else
+          coercion_result = Coercion.coerce(type: field.type, value: value)
 
           if coercion_result.success?
             field.validate(coercion_result.payload)
           else
             Failure.new(Validations::ValidationError.new(coercion_result.error.message))
           end
-        else
-          field.validate(value)
         end
       end
 

data/lib/typed/validations/field_type_validator.rb

@@ -9,7 +9,7 @@ module Typed
 
       sig { override.params(field: Field, value: Value).returns(ValidationResult) }
       def validate(field:, value:)
-        if field.type == value.class
+        if field.works_with?(value)
           Success.new(ValidatedValue.new(name: field.name, value: value))
         elsif field.required? && value.nil?
           Failure.new(RequiredFieldError.new(field_name: field.name))

data/lib/typed/validations/type_mismatch_error.rb

@@ -5,7 +5,7 @@ module Typed
     class TypeMismatchError < ValidationError
       extend T::Sig
 
-      sig { params(field_name: Symbol, field_type: T::Class[T.anything], given_type: T::Class[T.anything]).void }
+      sig { params(field_name: Symbol, field_type: Field::Type, given_type: T::Class[T.anything]).void }
       def initialize(field_name:, field_type:, given_type:)
         super("Invalid type given to #{field_name}. Expected #{field_type}, got #{given_type}.")
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-schema
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Max VelDink
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-03-12 00:00:00.000000000 Z
+date: 2024-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-result
@@ -85,23 +85,27 @@ files:
 - Rakefile
 - lib/sorbet-schema.rb
 - lib/sorbet-schema/hash_transformer.rb
-- lib/sorbet-schema/struct_ext.rb
 - lib/sorbet-schema/version.rb
 - lib/typed/coercion.rb
+- lib/typed/coercion/boolean_coercer.rb
 - lib/typed/coercion/coercer.rb
 - lib/typed/coercion/coercer_registry.rb
 - lib/typed/coercion/coercion_error.rb
 - lib/typed/coercion/coercion_not_supported_error.rb
+- lib/typed/coercion/enum_coercer.rb
 - lib/typed/coercion/float_coercer.rb
 - lib/typed/coercion/integer_coercer.rb
 - lib/typed/coercion/string_coercer.rb
 - lib/typed/coercion/struct_coercer.rb
+- lib/typed/coercion/typed_array_coercer.rb
 - lib/typed/deserialize_error.rb
 - lib/typed/field.rb
 - lib/typed/hash_serializer.rb
 - lib/typed/json_serializer.rb
 - lib/typed/parse_error.rb
 - lib/typed/schema.rb
+- lib/typed/serialization_error.rb
+- lib/typed/serialize_error.rb
 - lib/typed/serializer.rb
 - lib/typed/validations.rb
 - lib/typed/validations/field_type_validator.rb

data/lib/sorbet-schema/struct_ext.rb

@@ -1,37 +0,0 @@
-# typed: strict
-
-module T
-  class Struct
-    extend T::Sig
-
-    sig { returns(Typed::Schema) }
-    def self.create_schema
-      Typed::Schema.new(
-        target: self,
-        fields: props.map do |name, properties|
-          Typed::Field.new(name: name, type: properties[:type], required: !properties[:fully_optional])
-        end
-      )
-    end
-
-    sig { params(hash: Typed::HashSerializer::InputHash).returns(Typed::Serializer::DeserializeResult) }
-    def self.from_hash(hash)
-      Typed::HashSerializer.new(schema: create_schema).deserialize(hash)
-    end
-
-    sig { params(json: String).returns(Typed::Serializer::DeserializeResult) }
-    def self.from_json(json)
-      Typed::JSONSerializer.new(schema: create_schema).deserialize(json)
-    end
-
-    sig { returns(Typed::HashSerializer::OutputHash) }
-    def to_hash
-      Typed::HashSerializer.new(schema: self.class.create_schema).serialize(self)
-    end
-
-    sig { params(_options: T::Hash[T.untyped, T.untyped]).returns(String) }
-    def to_json(_options = {})
-      Typed::JSONSerializer.new(schema: self.class.create_schema).serialize(self)
-    end
-  end
-end