sorbet-schema 0.5.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32a23b4d9a5e1eda6fcf49b64428f55fbf1d89f63754de35bf2e0e3a875e018c
-  data.tar.gz: e76f273b8e566f78e6c18effa1699e3f6afa17311abee06a2183778e7a97f93a
+  metadata.gz: d2adb1981aeb5218f9d137f472bd602a2b81bbe6e54166e2974f1c157f92d50a
+  data.tar.gz: 1f4ee3983069f2674aab270bb7d138ce3fc611154a4d5c37581b6698ac6f3189
 SHA512:
-  metadata.gz: 5e7dcb508366dcda8311bf089ae6877c8ff5ba8fc41e0bec9adcd18ca8f3b3723693cd5139a1ee34d46dfcf0643d511edc04d689a93715e72aa33a2f764454e2
-  data.tar.gz: bf2c62a198b37caae70736bd1aa954476ef2697c44aa793381f91787b4ad6b78bad0e731a69c3dddb4c7398a3a07092cdebf779d95e27be1fbb68d43bf74958f
+  metadata.gz: d8b876a03ee53cafde5a9bbd9f46823d517aa6d69a3417a4e3c04591f1471066bc2912c2c26e00ba9e9294642912e4a4d58dafada77e8206685b4f726c23ae52
+  data.tar.gz: 9bf510fe1ef9e4b56ef9206ed1c5ea43bcb3934b1749c427afe76291a9b09871383d443f226f15cac733c39540180c2eed810d653b1728f73e11a8572f5b80be

data/CHANGELOG.md

@@ -4,6 +4,36 @@ 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.7.0](https://github.com/maxveldink/sorbet-schema/compare/v0.6.0...v0.7.0) (2024-07-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* Fix mis-serializing hash keys that were suppose to be strings ([#111](https://github.com/maxveldink/sorbet-schema/issues/111))
+
+### Bug Fixes
+
+* Fix mis-serializing hash keys that were suppose to be strings ([#111](https://github.com/maxveldink/sorbet-schema/issues/111)) ([485a6c7](https://github.com/maxveldink/sorbet-schema/commit/485a6c7a83b9e70c731930d8406925304efa04a8))
+
+## [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.7.0)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)

data/lib/sorbet-schema/hash_transformer.rb

@@ -4,44 +4,21 @@
 # This is a simplified version of ActiveSupport's Key Hash extension
 # https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/hash/keys.rb
 class HashTransformer
-  extend T::Sig
+  class << self
+    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] = 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] = transform_value(value, hash_transformation_method: :deep_stringify_keys)
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key.to_sym] = value
+      end
     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
+    sig { params(hash: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
+    def serialize_values(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        result[key] = SerializeValue.serialize(value)
+      end
     end
   end
 end

data/lib/sorbet-schema/serialize_value.rb

@@ -0,0 +1,20 @@
+# typed: strict
+
+class SerializeValue
+  extend T::Sig
+
+  sig { params(value: T.untyped).returns(T.untyped) }
+  def self.serialize(value)
+    if value.is_a?(Hash)
+      HashTransformer.serialize_values(value)
+    elsif value.is_a?(Array)
+      value.map { |item| serialize(item) }
+    elsif value.is_a?(T::Struct)
+      value.serialize_to(:hash).payload_or(value)
+    elsif value.respond_to?(:serialize)
+      value.serialize
+    else
+      value
+    end
+  end
+end

data/lib/sorbet-schema/version.rb

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

data/lib/sorbet-schema.rb

@@ -16,10 +16,11 @@ loader.inflector.inflect(
 )
 loader.setup
 
-# We don't want to place this in the `Typed` module.
+# We don't want to place these in the `Typed` module.
 # `sorbet-schema` is a directory that is not autoloaded
 # but contains extensions, so we need to manually require it.
 require_relative "sorbet-schema/hash_transformer"
+require_relative "sorbet-schema/serialize_value"
 
 # We want to add a default `schema` method to structs
 # that will guarentee a schema can be created for use

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/hash_serializer.rb

@@ -15,14 +15,14 @@ module Typed
 
     sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
     def deserialize(source)
-      deserialize_from_creation_params(HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(source))
+      deserialize_from_creation_params(HashTransformer.symbolize_keys(source))
     end
 
     sig { override.params(struct: T::Struct).returns(Result[Output, SerializeError]) }
     def serialize(struct)
       return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to target type of '#{schema.target}'.")) if struct.class != schema.target
 
-      Success.new(serialize_from_struct(struct: struct, should_serialize_values: should_serialize_values))
+      Success.new(serialize_from_struct(struct:, should_serialize_values:))
     end
 
     private

data/lib/typed/json_serializer.rb

@@ -24,7 +24,7 @@ module Typed
     def serialize(struct)
       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(serialize_from_struct(struct: struct, should_serialize_values: true)))
+      Success.new(JSON.generate(serialize_from_struct(struct:, should_serialize_values: true)))
     end
   end
 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))
@@ -60,7 +82,11 @@ module Typed
     def serialize_from_struct(struct:, should_serialize_values: false)
       hsh = schema.fields.each_with_object({}) { |field, hsh| hsh[field.name] = field.serialize(struct.send(field.name)) }.compact
 
-      HashTransformer.new(should_serialize_values: should_serialize_values).deep_symbolize_keys(hsh)
+      if should_serialize_values
+        hsh = HashTransformer.serialize_values(hsh)
+      end
+
+      hsh
     end
   end
 end

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.7.0
 platform: ruby
 authors:
 - Max VelDink
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-26 00:00:00.000000000 Z
+date: 2024-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-result
@@ -85,6 +85,7 @@ files:
 - Rakefile
 - lib/sorbet-schema.rb
 - lib/sorbet-schema/hash_transformer.rb
+- lib/sorbet-schema/serialize_value.rb
 - lib/sorbet-schema/t/struct.rb
 - lib/sorbet-schema/version.rb
 - lib/typed/coercion.rb
@@ -99,7 +100,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