sorbet-schema 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32a23b4d9a5e1eda6fcf49b64428f55fbf1d89f63754de35bf2e0e3a875e018c
-  data.tar.gz: e76f273b8e566f78e6c18effa1699e3f6afa17311abee06a2183778e7a97f93a
+  metadata.gz: 1b4040ccaa87f90e0d32acee9868fffb0f4d645e599fe29726738fdb54c4f1e6
+  data.tar.gz: b83d96b38d8b7d786a3e174e576053f531bf03e237d7c1f049e98b9c813dc117
 SHA512:
-  metadata.gz: 5e7dcb508366dcda8311bf089ae6877c8ff5ba8fc41e0bec9adcd18ca8f3b3723693cd5139a1ee34d46dfcf0643d511edc04d689a93715e72aa33a2f764454e2
-  data.tar.gz: bf2c62a198b37caae70736bd1aa954476ef2697c44aa793381f91787b4ad6b78bad0e731a69c3dddb4c7398a3a07092cdebf779d95e27be1fbb68d43bf74958f
+  metadata.gz: 248121230fc7a86b616259a89db47c210360034aad0ec70a23e2b25d73b350e16eff09c09ea87efd0aa859ef86b6f5c7f7700043b2e0d3e1f570555e98baac31
+  data.tar.gz: 6f0c35a33ff1e84ebe704c30a6d0ba4b3520030c8ca59c897c33cc96f736c48c16e8672e7f4efef6f81f4a9816326db41c1cc625f49addd520a437066a04db1c

data/CHANGELOG.md

@@ -4,6 +4,25 @@ 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.6.0](https://github.com/maxveldink/sorbet-schema/compare/v0.5.1...v0.6.0) (2024-07-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* implement default handling for fields ([#105](https://github.com/maxveldink/sorbet-schema/issues/105))
+
+### Features
+
+* implement default handling for fields ([#105](https://github.com/maxveldink/sorbet-schema/issues/105)) ([054d59f](https://github.com/maxveldink/sorbet-schema/commit/054d59ff92c68b272d495a0816370b9a890f0f50))
+* implement SymbolCoercer ([#109](https://github.com/maxveldink/sorbet-schema/issues/109)) ([422a995](https://github.com/maxveldink/sorbet-schema/commit/422a9957177039a3dde5c4daa41d597fd44f2b48))
+* implement TypedHashCoercer ([#110](https://github.com/maxveldink/sorbet-schema/issues/110)) ([6d64db7](https://github.com/maxveldink/sorbet-schema/commit/6d64db7fcef8af56cb96f1ee6c42ba1e3ce076c3))
+* support T.any for deserialization ([#107](https://github.com/maxveldink/sorbet-schema/issues/107)) ([c0c2ca3](https://github.com/maxveldink/sorbet-schema/commit/c0c2ca369abef136943e633b7987decad7291d98))
+
+
+### Bug Fixes
+
+* default value set to true causes undefined method [] error ([#108](https://github.com/maxveldink/sorbet-schema/issues/108)) ([6829bbf](https://github.com/maxveldink/sorbet-schema/commit/6829bbf8b6bf47db51209e9874608b7e10c38b8e))
+
 ## [0.5.1](https://github.com/maxveldink/sorbet-schema/compare/v0.5.0...v0.5.1) (2024-06-26)
 
 

data/Gemfile.lock

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

data/lib/sorbet-schema/version.rb

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

data/lib/typed/coercion/coercer_registry.rb

@@ -14,13 +14,15 @@ module Typed
       DEFAULT_COERCERS = T.let(
         [
           StringCoercer,
+          SymbolCoercer,
           BooleanCoercer,
           IntegerCoercer,
           FloatCoercer,
           DateCoercer,
           EnumCoercer,
           StructCoercer,
-          TypedArrayCoercer
+          TypedArrayCoercer,
+          TypedHashCoercer
         ],
         Registry
       )

data/lib/typed/coercion/struct_coercer.rb

@@ -21,41 +21,15 @@ module Typed
 
         return Failure.new(CoercionError.new("Value of type '#{value.class}' cannot be coerced to #{type} Struct.")) unless value.is_a?(Hash)
 
-        values = {}
-
-        type = T.cast(type, T::Types::Simple)
-
-        type.raw_type.props.each do |name, prop|
-          attribute_type = prop[:type_object]
-          value = HashTransformer.new.deep_symbolize_keys(value)
-
-          if value[name].nil?
-            # if the value is nil but the type is nilable, no need to coerce
-            next if attribute_type.respond_to?(:valid?) && attribute_type.valid?(value[name])
-
-            return Typed::Failure.new(CoercionError.new("#{name} is required but nil given"))
-          end
-
-          # now that we've done the nil check, we can unwrap the nilable type to get the raw type
-          simple_attribute_type = attribute_type.respond_to?(:unwrap_nilable) ? attribute_type.unwrap_nilable : attribute_type
-
-          # if the prop is a struct, we need to recursively coerce it
-          if simple_attribute_type.respond_to?(:raw_type) && simple_attribute_type.raw_type <= T::Struct
-            Typed::HashSerializer
-              .new(schema: simple_attribute_type.raw_type.schema)
-              .deserialize(value[name])
-              .and_then { |struct| Typed::Success.new(values[name] = struct) }
-              .on_error { |error| return Typed::Failure.new(CoercionError.new("Nested hash for #{type} could not be coerced to #{name}, error: #{error}")) }
-          else
-            value = HashTransformer.new.deep_symbolize_keys(value)
-
-            Coercion
-              .coerce(type: attribute_type, value: value[name])
-              .and_then { |coerced_value| Typed::Success.new(values[name] = coerced_value) }
-          end
+        deserialization_result = T.cast(type, T::Types::Simple)
+          .raw_type
+          .deserialize_from(:hash, value)
+
+        if deserialization_result.success?
+          deserialization_result
+        else
+          Failure.new(CoercionError.new(deserialization_result.error.message))
         end
-
-        Success.new(type.raw_type.new(values))
       rescue ArgumentError, RuntimeError
         Failure.new(CoercionError.new("Given hash could not be coerced to #{type}."))
       end

data/lib/typed/coercion/symbol_coercer.rb

@@ -0,0 +1,27 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class SymbolCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: Symbol} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        type == T::Utils.coerce(Symbol)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a Symbol.")) unless used_for_type?(type)
+
+        if value.respond_to?(:to_sym)
+          Success.new(value.to_sym)
+        else
+          Failure.new(CoercionError.new("Value cannot be coerced into Symbol. Consider adding a #to_sym implementation."))
+        end
+      end
+    end
+  end
+end

data/lib/typed/coercion/typed_hash_coercer.rb

@@ -0,0 +1,50 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class TypedHashCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Hash[T.untyped, T.untyped]} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        type.is_a?(T::Types::TypedHash)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must be a T::Hash.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Value must be a Hash.")) unless value.is_a?(Hash)
+
+        return Success.new(value) if type.recursively_valid?(value)
+
+        coerced_hash = {}
+        errors = []
+
+        value.each do |k, v|
+          key_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.first), value: k)
+          value_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.last), value: v)
+
+          if key_result.success? && value_result.success?
+            coerced_hash[key_result.payload] = value_result.payload
+          else
+            if key_result.failure?
+              errors << key_result.error
+            end
+
+            if value_result.failure?
+              errors << value_result.error
+            end
+          end
+        end
+
+        if errors.empty?
+          Success.new(coerced_hash)
+        else
+          Failure.new(CoercionError.new(errors.map(&:message).join(" | ")))
+        end
+      end
+    end
+  end
+end

data/lib/typed/field.rb

@@ -12,6 +12,9 @@ module Typed
     sig { returns(T::Types::Base) }
     attr_reader :type
 
+    sig { returns(T.untyped) }
+    attr_reader :default
+
     sig { returns(T::Boolean) }
     attr_reader :required
 
@@ -22,15 +25,36 @@ module Typed
       params(
         name: Symbol,
         type: T.any(T::Class[T.anything], T::Types::Base),
-        required: T::Boolean,
+        optional: T::Boolean,
+        default: T.untyped,
         inline_serializer: T.nilable(InlineSerializer)
       ).void
     end
-    def initialize(name:, type:, required: true, inline_serializer: nil)
+    def initialize(name:, type:, optional: false, default: nil, inline_serializer: nil)
       @name = name
-      @type = T.let(T::Utils.coerce(type), T::Types::Base)
-      @required = required
+      # TODO: Guarentee type signature of the serializer will be valid
       @inline_serializer = inline_serializer
+
+      coerced_type = T::Utils.coerce(type)
+
+      if coerced_type.valid?(nil)
+        @required = T.let(false, T::Boolean)
+        @type = T.let(T.unsafe(coerced_type).unwrap_nilable, T::Types::Base)
+      else
+        @required = true
+        @type = coerced_type
+      end
+
+      if optional
+        @required = false
+      end
+
+      if !default.nil? && @type.valid?(default)
+        @default = T.let(default, T.untyped)
+        @required = false
+      elsif !default.nil? && @required
+        raise ArgumentError, "Given #{default} with class of #{default.class} for default, invalid with type #{@type}"
+      end
     end
 
     sig { params(other: Field).returns(T.nilable(T::Boolean)) }
@@ -38,6 +62,7 @@ module Typed
       name == other.name &&
         type == other.type &&
         required == other.required &&
+        default == other.default &&
         inline_serializer == other.inline_serializer
     end
 

data/lib/typed/schema.rb

@@ -13,7 +13,7 @@ module Typed
       Typed::Schema.new(
         target: struct,
         fields: struct.props.map do |name, properties|
-          Typed::Field.new(name: name, type: properties[:type], required: !properties[:fully_optional])
+          Typed::Field.new(name:, type: properties[:type_object], default: properties.fetch(:default, nil))
         end
       )
     end
@@ -34,7 +34,7 @@ module Typed
         target: target,
         fields: fields.map do |field|
           if field.name == field_name
-            Field.new(name: field.name, type: field.type, required: field.required, inline_serializer: serializer)
+            Field.new(name: field.name, type: field.type, default: field.default, inline_serializer: serializer)
           else
             field
           end

data/lib/typed/serializer.rb

@@ -33,12 +33,34 @@ module Typed
     sig { params(creation_params: Params).returns(DeserializeResult) }
     def deserialize_from_creation_params(creation_params)
       results = schema.fields.map do |field|
-        value = creation_params[field.name]
+        value = creation_params.fetch(field.name, nil)
 
-        if value.nil? || field.works_with?(value)
+        if value.nil? && !field.default.nil?
+          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]))
+
+          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)
+
+            if coercion_result.success?
+              validated_value = field.validate(coercion_result.payload)
+
+              break
+            else
+              errors << Validations::ValidationError.new(coercion_result.error.message)
+            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: value)
+          coercion_result = Coercion.coerce(type: field.type, value:)
 
           if coercion_result.success?
             field.validate(coercion_result.payload)
@@ -49,7 +71,7 @@ module Typed
       end
 
       Validations::ValidationResults
-        .new(results: results)
+        .new(results:)
         .combine
         .and_then do |validated_params|
           Success.new(schema.target.new(**validated_params))

data/lib/typed/validations/field_type_validator.rb

@@ -10,11 +10,15 @@ module Typed
       sig { override.params(field: Field, value: Value).returns(ValidationResult) }
       def validate(field:, value:)
         if field.works_with?(value)
-          Success.new(ValidatedValue.new(name: field.name, value: value))
+          Success.new(ValidatedValue.new(name: field.name, value:))
         elsif field.required? && value.nil?
           Failure.new(RequiredFieldError.new(field_name: field.name))
         elsif field.optional? && value.nil?
-          Success.new(ValidatedValue.new(name: field.name, value: value))
+          if field.default.nil?
+            Success.new(ValidatedValue.new(name: field.name, value:))
+          else
+            Success.new(ValidatedValue.new(name: field.name, value: field.default))
+          end
         else
           Failure.new(TypeMismatchError.new(field_name: field.name, field_type: field.type, given_type: value.class))
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-schema
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Max VelDink
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-26 00:00:00.000000000 Z
+date: 2024-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-result
@@ -99,7 +99,9 @@ files:
 - lib/typed/coercion/integer_coercer.rb
 - lib/typed/coercion/string_coercer.rb
 - lib/typed/coercion/struct_coercer.rb
+- lib/typed/coercion/symbol_coercer.rb
 - lib/typed/coercion/typed_array_coercer.rb
+- lib/typed/coercion/typed_hash_coercer.rb
 - lib/typed/deserialize_error.rb
 - lib/typed/field.rb
 - lib/typed/hash_serializer.rb