sorbet-schema 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3fc3ec89812a6517931d09a61a6f4049b85db1661b92e5cb7353c7c62207afab
-  data.tar.gz: 45daa92727807fb2c80bff1fad0b84684c435cde7c1460478741da74fcc0d9c3
+  metadata.gz: c06e03c3878ac6b3cf04305124e1d3786de57f0543ee320181565a8b59f8c4b3
+  data.tar.gz: 97d11102e65875b5f77f06095fdacf1dea0fabdd1fd1a91b5428a509dd6bac4b
 SHA512:
-  metadata.gz: 5ad688ac1f0b61c309d9e016baffcab03b61f6c1c0b17b86721580d9f9ed75b86901f9c31a2b3407356f3abaf0ed64c75294d8a6a60a39d11220320c80253308
-  data.tar.gz: d4ec8208184dfe939122d345ec1e1cbb2a8b3f9d840af984e772c6c85d7985fe34f5678ba6b2fa7ef9f85157af90c4e5990f1f2472a025c195255f0d9a5527fe
+  metadata.gz: 84e7f4308162784ee84b063ff743293cd6c72487479f23de3cf1ed31089f13ff8a148c4aad85854394343aa97eafbbab15551d54fd17ce8e390db343db5083c9
+  data.tar.gz: 37301dfecd29623d2f5be76220e70d0aa1a650dc2c792c3e01e15b4bce17abb2bf468f04dbfd5026686c11aa594590a91b369b49ef2a1de5393ff77af07d5d8b

data/.standard.yml

@@ -1,5 +1,6 @@
 parallel: true
-ruby_version: 3.0
+format: progress
+ruby_version: 3.1
 ignore:
   - 'vendor/**/*'
 plugins:

data/CHANGELOG.md

@@ -4,6 +4,22 @@ 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.5.0](https://github.com/maxveldink/sorbet-schema/compare/v0.4.2...v0.5.0) (2024-04-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* Set minimum Ruby to 3.1 ([#69](https://github.com/maxveldink/sorbet-schema/issues/69))
+
+### Features
+
+* Add schema method to structs ([#60](https://github.com/maxveldink/sorbet-schema/issues/60)) ([4b7ff34](https://github.com/maxveldink/sorbet-schema/commit/4b7ff34bc6a48c42d3ece8d1fad07bdecf0bdc11))
+
+
+### Miscellaneous Chores
+
+* Set minimum Ruby to 3.1 ([#69](https://github.com/maxveldink/sorbet-schema/issues/69)) ([d2b4ba2](https://github.com/maxveldink/sorbet-schema/commit/d2b4ba2099da24f93a22849e059627221bbda081))
+
 ## [0.4.2](https://github.com/maxveldink/sorbet-schema/compare/v0.4.1...v0.4.2) (2024-03-21)
 
 

data/Gemfile

@@ -15,6 +15,7 @@ group :development do
 end
 
 group :development, :test do
+  gem "bigdecimal" # used for testing un-matched coercer
   gem "minitest"
   gem "minitest-focus"
   gem "minitest-reporters"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.4.2)
+    sorbet-schema (0.5.0)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
@@ -12,19 +12,20 @@ GEM
   specs:
     ansi (1.5.0)
     ast (2.4.2)
+    bigdecimal (3.1.8)
     builder (3.2.4)
-    debug (1.9.1)
+    debug (1.9.2)
       irb (~> 1.10)
       reline (>= 0.3.8)
     erubi (1.12.0)
     io-console (0.7.2)
-    irb (1.12.0)
-      rdoc
+    irb (1.13.1)
+      rdoc (>= 4.0.0)
       reline (>= 0.4.2)
-    json (2.7.1)
+    json (2.7.2)
     language_server-protocol (3.17.0.3)
     lint_roller (1.1.0)
-    minitest (5.22.3)
+    minitest (5.23.1)
     minitest-focus (1.4.0)
       minitest (>= 4, < 6)
     minitest-reporters (1.6.1)
@@ -34,26 +35,26 @@ GEM
       ruby-progressbar
     netrc (0.11.0)
     parallel (1.24.0)
-    parser (3.3.0.5)
+    parser (3.3.1.0)
       ast (~> 2.4.1)
       racc
-    prettier_print (1.2.1)
-    prism (0.24.0)
+    prism (0.29.0)
     psych (5.1.2)
       stringio
-    racc (1.7.3)
+    racc (1.8.0)
     rainbow (3.1.1)
-    rake (13.1.0)
-    rbi (0.1.9)
-      prism (>= 0.18.0, < 0.25)
+    rake (13.2.1)
+    rbi (0.1.13)
+      prism (>= 0.18.0, < 1.0.0)
       sorbet-runtime (>= 0.5.9204)
-    rdoc (6.6.2)
+    rdoc (6.7.0)
       psych (>= 4.0.0)
-    regexp_parser (2.9.0)
-    reline (0.4.3)
+    regexp_parser (2.9.2)
+    reline (0.5.7)
       io-console (~> 0.5)
-    rexml (3.2.6)
-    rubocop (1.62.1)
+    rexml (3.2.8)
+      strscan (>= 3.0.9)
+    rubocop (1.63.5)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
@@ -64,56 +65,55 @@ GEM
       rubocop-ast (>= 1.31.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 3.0)
-    rubocop-ast (1.31.2)
-      parser (>= 3.3.0.4)
-    rubocop-performance (1.20.2)
+    rubocop-ast (1.31.3)
+      parser (>= 3.3.1.0)
+    rubocop-performance (1.21.0)
       rubocop (>= 1.48.1, < 2.0)
-      rubocop-ast (>= 1.30.0, < 2.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
     rubocop-sorbet (0.7.8)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.11295)
-      sorbet-static (= 0.5.11295)
+    sorbet (0.5.11391)
+      sorbet-static (= 0.5.11391)
     sorbet-result (1.1.0)
       sorbet-runtime (~> 0.5)
-    sorbet-runtime (0.5.11295)
-    sorbet-static (0.5.11295-universal-darwin)
-    sorbet-static (0.5.11295-x86_64-linux)
-    sorbet-static-and-runtime (0.5.11295)
-      sorbet (= 0.5.11295)
-      sorbet-runtime (= 0.5.11295)
+    sorbet-runtime (0.5.11391)
+    sorbet-static (0.5.11391-universal-darwin)
+    sorbet-static (0.5.11391-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11391)
+      sorbet (= 0.5.11391)
+      sorbet-runtime (= 0.5.11391)
     sorbet-struct-comparable (1.3.0)
       sorbet-runtime (>= 0.5)
-    spoom (1.2.4)
+    spoom (1.3.2)
       erubi (>= 1.10.0)
+      prism (>= 0.19.0)
       sorbet-static-and-runtime (>= 0.5.10187)
-      syntax_tree (>= 6.1.1)
       thor (>= 0.19.2)
-    standard (1.35.1)
+    standard (1.36.0)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
-      rubocop (~> 1.62.0)
+      rubocop (~> 1.63.0)
       standard-custom (~> 1.0.0)
-      standard-performance (~> 1.3)
+      standard-performance (~> 1.4)
     standard-custom (1.0.2)
       lint_roller (~> 1.0)
       rubocop (~> 1.50)
-    standard-performance (1.3.1)
+    standard-performance (1.4.0)
       lint_roller (~> 1.1)
-      rubocop-performance (~> 1.20.2)
+      rubocop-performance (~> 1.21.0)
     standard-sorbet (0.0.2)
       lint_roller (~> 1.1)
       rubocop-sorbet (~> 0.7.0)
     stringio (3.1.0)
-    syntax_tree (6.2.0)
-      prettier_print (>= 1.2.0)
-    tapioca (0.12.0)
+    strscan (3.1.0)
+    tapioca (0.14.2)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
       rbi (>= 0.1.4, < 0.2)
-      sorbet-static-and-runtime (>= 0.5.10820)
-      spoom (~> 1.2.0, >= 1.2.0)
+      sorbet-static-and-runtime (>= 0.5.11087)
+      spoom (>= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
     thor (1.3.1)
@@ -122,7 +122,7 @@ GEM
     yard-sorbet (0.8.1)
       sorbet-runtime (>= 0.5)
       yard (>= 0.9)
-    zeitwerk (2.6.13)
+    zeitwerk (2.6.15)
 
 PLATFORMS
   arm64-darwin-22
@@ -130,6 +130,7 @@ PLATFORMS
   x86_64-linux
 
 DEPENDENCIES
+  bigdecimal
   debug
   minitest
   minitest-focus
@@ -144,4 +145,4 @@ DEPENDENCIES
   tapioca
 
 BUNDLED WITH
-   2.5.6
+   2.5.9

data/README.md

@@ -1,6 +1,6 @@
 # Sorbet Schema
 
-
+Extendable serialization and deserialization to various formats for Sorbet `T::Struct`s.
 
 ## Installation
 
@@ -14,21 +14,244 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
+Sorbet Schema is designed to be compatible with Sorbet's `T::Struct` class, and seeks to update many of the common pitfalls developers encountering when deserializing to and serializing from a `T::Struct`.
+
 ### Getting Started
 
-### Chaining
+While you can directly define a `Typed::Schema` to be used for your serialization needs, you'll typically use the provided helper class method to generate a `Schema` from an existing `T::Struct`.
+
+```ruby
+class Person < T::Struct
+  const :name, String
+  const :age, Integer
+end
+
+schema = Person.schema # => <Typed::Schema
+#                              fields=[....]
+#                              target=Person>
+```
+
+Once you have a schema, you can use the built-in serializers (or a [custom one](#implementing-custom-serializers) that inherits from the [Typed::Serializer](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/serializer.rb) abstract base class) to create new instances of the struct or convert an instance of the struct to the target format.
+
+```ruby
+json_serializer = Typed::JSONSerializer.new(schema: Person.schema)
+
+# Deserialize from target format
+result = json_serializer.deserialize('{"name":"Max","age":29}')
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+result = json_serializer.serialize(max)
+result.payload # == '{"name":"Max","age":29}'
+```
+
+Alternatively, you can use the built-in helper methods added to `T::Struct`s to quickly use the built-in serializers.
+
+```ruby
+result = Person.deserialize_from(:json, '{"name":"Max","age":29}')
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+result = max.serialize_to(:json)
+result.payload # == '{"name":"Max","age":29}'
+```
+
+Notice that both `deserialize` and `serialize` return `Typed::Result`s (from the [sorbet-result gem](https://github.com/maxveldink/sorbet-result)) that need to be checked for success or failure before being used. Check out that gem's README for more information on how to interact with `Result`s.
+
+One benefit of using `Result`s is we can add much more details information about why a format is unsuccessfully deserialized or serialized, to provide call sites with more information for error handling, messaging and formatting.
+
+```ruby
+# Unparsable JSON
+result = json_serializer.deserialize('{"name""Max","age":29}')
+result.error # == Typed::ParseError: json could not be parsed. Check for typos.
+
+# Missing required field
+result = json_serializer.deserialize('{"age": 29}')
+result.error # == Typed::Validations::RequiredFieldError: name is required.
+
+result = json_serializer.deserialize('{"age":"29-0"}')
+result.error # == Typed::Validations::MultipleValidationError: Multiple validation errors found: name is required. | '29-0' cannot be coerced into Integer.
+```
+
+Finally, there are built-in coercers that do their best effort to convert common types from the source format to the required schema type.
+
+```ruby
+# Deserialize from target format, with integer coercion
+result = json_serializer.deserialize('{"name":"Max","age":"29"}')
+max = result.payload # == Person.new(name: "Max", age: 29)
+```
+
+### Rails Example
+
+Here's an extended example of how Sorbet Schema can be combined with a normal Rails request to easily convert between formats.
+
+```ruby
+def verify
+  Typed::HashSerializer
+    .new(schema: Address.schema) # Generate schema from the `Address` Struct
+    .deserialize(address_params.to_h) # Use Rails' strong parameters to deserialize into the struct
+    .and_then { |address| VerifyAddress.new.call(address: T.cast(address, Address)) } # Use sorbet-result's chaining
+    .and_then do |address|
+        return render json: Typed::JSONSerializer.new(schema: Address.schema).serialize(address).payload # return a JSON response from the Address struct instance
+    end
+    .on_error do |failure| # Use sorbet-result's error handling
+      case failure
+      when AddressNotFoundError
+        head :not_found
+      when GeoNotSupportedError
+        head :not_implemented
+      else
+        render json: failure, status: :bad_request # use `Typed::Failure`s built-in `to_json` behavior
+      end
+    end
+end
+```
+
+### Available Serializers
+
+These are the currently available serializers. For more information about implementing a custom one (or contributing one back!), see [Custom Coercers](#custom-coercers).
+
+#### JSONSerializer
+
+See [Getting Started](#getting-started) for more information on how to use the JSONSerializer.
+
+#### HashSerializer
+
+While not strictly serialization, converting `T::Struct`s to and from Ruby `Hash`es has traditionally had many pitfalls ([well-documented](https://sorbet.org/docs/tstruct#legacy-code-and-historical-context) in the Sorbet docs). The `Typed::HashSerializer` aims to address several common issues, while providing the same `Result` handling for invalid or missing data and coercion behavior.
+
+To use it, simply instantiate and use it like the `JSONSerializer`:
+
+```ruby
+hash_serializer = Typed::HashSerializer.new(schema: Person.schema)
+
+# Deserialize from target format
+result = hash_serializer.deserialize({"name" => "Max", age: 29})
+max = result.payload # == Person.new(name: "Max", age: 29)
+```
+
+By default, the `HashSerializer` will _not_ serialize values when converting to a Hash. For instance, if a field is an `T::Enum` type, when it is serialized to a `Hash` the value will be the `Enum` and not the `String` representation. The `should_serialize_values` option can be passed during initialization to serialize the values when converting to the `Hash`.
+
+### Customization
+
+From the get-go, Sorbet Schema is designed to be extensible to model more complex data validation requirements and many serialization formats. We try out best to include built-in, battle-tested coercers and serializers from real world use cases and would love to see/upstream any customizations that the community have found useful!
+
+#### Custom Coercers
+
+At their simplest forms, coercers are any class that inherit from the [Typed::Coercion::Coercer](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/coercion/coercer.rb) abstract base class. The list of default coercers that are applied can be found in the [CoercerRegistry](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/coercion/coercer_registry.rb). Let's look at the [DateCoercer's implementation](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/coercion/date_coercer.rb):
+
+```ruby
+require "date"
+
+class DateCoercer < Coercer
+  extend T::Generic
+
+  Target = type_member { {fixed: Date} }
+
+  sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+  def used_for_type?(type)
+    T::Utils.coerce(type) == T::Utils.coerce(Date)
+  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 Date.")) unless used_for_type?(type)
+
+    return Success.new(value) if value.is_a?(Date)
+
+    Success.new(Date.parse(value))
+  rescue Date::Error, TypeError
+    Failure.new(CoercionError.new("'#{value}' cannot be coerced into Date."))
+  end
+end
+```
+
+Notice that this utilizes sorbet generic, so the target type must be defined using `type_member`. For dates, this is the built-in std lib type `Date`.
+
+From there, implement the `used_for_type?` method which receives a type and returns `true` if the coercer can be used to coerce to that type or `false` if it should not be used. Notice that we use the `T::Types` module directly from Sorbet, which allows us to model the built-in Sorbet types, such as `T::Boolean` and `T::Array`. Typically, `T::Utils.coerce(TargetType)` is used to match the target type. For dates, this is a very simple type check for a `Date`.
+
+Finally, implement the `coerce` method. If a coercion is successful, return a `Success.new(coerced_value)`. If not, return a Failure with a coercion error `Failure.new(CoercionError.new("I can't coerce to the type"))`. Take care to handle any exceptions that could arise from the attempted coercion. For dates, first it checks and make sure the type given matches the target type. This is a common check and is largely an edge case check for completeness. Next, if the value is already a Date we simply return a `Success` with it. Finally, we use the built-in `Date.parse` method to actually attempt a coercion. Since this can throw a `Date::Error` and a `TypeError`, rescue from those with a `Failure`.
+
+Once a custom coercer is defined, the last step is to register it with Sorbet Schema during initialization. Typically, this is after `sorbet-schema` has been required or during the bootstrapping step of a framework, such as Rails' initializers. Call `register_coercer` like so:
+
+```ruby
+Typed::Coercion.register_coercer(MyCoercer) # make sure `MyCoercer` is loaded by this point
+```
+
+**Note** Custom coercers are prepended to the list of available coercers so that they are checked during deserialization before the built-in coercers. This allows consuming projects to override default behavior by creating a coercer that re-implements the `coerce` method for that type.
+
+#### Inline Serializers
+
+Sometimes, there is custom behavior that needs to be added to how a field is serialized (represented as a `String`), such as when you need to use a different `strftime` format for `Date`s and `Time`s. This can be accomplished with an `InlineSerializer` (defined in [Typed::Field](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/field.rb)), which is a `Proc` that takes the value and returns a different representation. At present, these are both very loose `T.untyped` types to allow for flexibility. Typically, a `String` is returned.
+
+The serializer can be used when creating a `Schema` and defining its `fields`, or with the `add_serializer` helper on `Schema`s.
+
+```ruby
+my_date_serializer = ->(date) { date.strftime("%Y/%m") }
+
+# use directly on a Schema
+Typed::Schema.new(
+  target: SchemaWithDateField,
+  fields: [
+    Typed::Field.new(name: :date, type: Date, serializer: my_date_serializer)
+  ]
+)
+
+# use `add_serializer` helper
+SchemaWithDateField.schema.add_serializer(:date, my_date_serializer)
+```
+
+#### Implementing Custom Serializers
+
+While Sorbet Schema ships with popular serializers, you can define your own by inheriting from [Typed::Serializer](https://github.com/maxveldink/sorbet-schema/blob/main/lib/typed/serializer.rb). Let's look at the `JSONSerializer`:
+
+```ruby
+require "json"
+
+class JSONSerializer < Serializer
+  Input = type_member { {fixed: String} }
+  Output = type_member { {fixed: String} }
+
+  sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+  def deserialize(source)
+    parsed_json = JSON.parse(source)
+
+    creation_params = schema.fields.each_with_object(T.let({}, Params)) do |field, hsh|
+      hsh[field.name] = parsed_json[field.name.to_s]
+    end
+
+    deserialize_from_creation_params(creation_params)
+  rescue JSON::ParserError
+    Failure.new(ParseError.new(format: :json))
+  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(JSON.generate(serialize_from_struct(struct: struct, should_serialize_values: true)))
+  end
+end
+```
+
+Since `Serializer` is a generic class, we need to define our `Input` and `Output` types. For JSON, deserialization and serialization both use JSON strings, so these are both strings.
+
+Next, the `deserialize` and `serialize` methods must be implemented. Notice that both of these return `Result`s.
+
+For deserialization, the JSON is parsed (and a parse error is handled). Then we build up a creation params hash from the parsed json to pass to the `deserialize_from_creation_params` helper, defined on `Serializer`.
+
+For serialization, the passed struct is checked to make sure it matches the `Schema`. Then it uses the `serialize_from_struct` helper and passes the resulting `Hash` to generate JSON.
+
+## Inspirations
 
-## Why use Options?
+This project is heavily inspired by [serde](https://serde.rs/) from the Rust community and the [dry-rb](https://dry-rb.org/) family of gems.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run Rubocop and the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake` to run Standard and the tests. `bin/console` for an interactive prompt that aids with experimentation.
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+To install this gem onto a local machine, run `bundle exec rake install`.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/maxveldink/sorbet-option. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/maxveldink/sorbet-option/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/maxveldink/sorbet-schema. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/maxveldink/sorbet-schema/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -36,7 +259,7 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in this project's codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/maxveldink/sorbet-option/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in this project's codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/maxveldink/sorbet-schema/blob/master/CODE_OF_CONDUCT.md).
 
 ## Sponsorships
 

data/lib/sorbet-schema/t/struct.rb

@@ -0,0 +1,38 @@
+# typed: strict
+
+module T
+  class Struct
+    extend T::Sig
+
+    class << self
+      extend T::Sig
+
+      sig { overridable.returns(Typed::Schema) }
+      def schema
+        Typed::Schema.from_struct(self)
+      end
+
+      sig { params(type: Symbol).returns(Typed::Serializer[T.untyped, T.untyped]) }
+      def serializer(type)
+        case type
+        when :hash
+          Typed::HashSerializer.new(schema:)
+        when :json
+          Typed::JSONSerializer.new(schema:)
+        else
+          raise ArgumentError, "unknown serializer for #{type}"
+        end
+      end
+
+      sig { params(serializer_type: Symbol, source: T.untyped).returns(Typed::Serializer::DeserializeResult) }
+      def deserialize_from(serializer_type, source)
+        serializer(serializer_type).deserialize(source)
+      end
+    end
+
+    sig { params(serializer_type: Symbol).returns(Typed::Result[T.untyped, Typed::SerializeError]) }
+    def serialize_to(serializer_type)
+      self.class.serializer(serializer_type).serialize(self)
+    end
+  end
+end

data/lib/sorbet-schema/version.rb

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

data/lib/sorbet-schema.rb

@@ -10,7 +10,7 @@ require "zeitwerk"
 loader = Zeitwerk::Loader.new
 loader.push_dir(__dir__.to_s)
 loader.ignore(__FILE__)
-loader.ignore("#{__dir__}/sorbet-schema/*.rb")
+loader.ignore("#{__dir__}/sorbet-schema/**/*.rb")
 loader.inflector.inflect(
   "json_serializer" => "JSONSerializer"
 )
@@ -21,6 +21,12 @@ loader.setup
 # but contains extensions, so we need to manually require it.
 require_relative "sorbet-schema/hash_transformer"
 
+# We want to add a default `schema` method to structs
+# that will guarentee a schema can be created for use
+# with serialization. This can (and should) be overridden
+# in child struct classes.
+require_relative "sorbet-schema/t/struct"
+
 # Sorbet-aware namespace to super-charge your projects
 module Typed
   Value = T.type_alias { T.untyped }

data/lib/typed/serializer.rb

@@ -10,7 +10,7 @@ module Typed
     Input = type_member
     Output = type_member
     Params = T.type_alias { T::Hash[Symbol, T.untyped] }
-    DeserializeResult = T.type_alias { Typed::Result[T::Struct, DeserializeError] }
+    DeserializeResult = T.type_alias { Result[T::Struct, DeserializeError] }
 
     sig { returns(Schema) }
     attr_reader :schema

data/sorbet/rbi/gems/ansi@1.5.0.rbi

@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `ansi` gem.
 # Please instead update this file by running `bin/tapioca gem ansi`.
 
+
 # ANSI namespace module contains all the ANSI related classes.
 #
 # source://ansi//lib/ansi/code.rb#1

data/sorbet/rbi/gems/ast@2.4.2.rbi

@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `ast` gem.
 # Please instead update this file by running `bin/tapioca gem ast`.
 
+
 # {AST} is a library for manipulating abstract syntax trees.
 #
 # It embraces immutability; each AST node is inherently frozen at

data/sorbet/rbi/gems/bigdecimal@3.1.8.rbi

@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `bigdecimal` gem.
+# Please instead update this file by running `bin/tapioca gem bigdecimal`.
+
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem

data/sorbet/rbi/gems/builder@3.2.4.rbi

@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `builder` gem.
 # Please instead update this file by running `bin/tapioca gem builder`.
 
+
 # If the Builder::XChar module is not currently defined, fail on any
 # name clashes in standard library classes.
 #

data/sorbet/rbi/gems/erubi@1.12.0.rbi

@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `erubi` gem.
 # Please instead update this file by running `bin/tapioca gem erubi`.
 
+
 # source://erubi//lib/erubi.rb#3
 module Erubi
   class << self

data/sorbet/rbi/gems/io-console@0.7.2.rbi

@@ -4,5 +4,6 @@
 # This is an autogenerated file for types exported from the `io-console` gem.
 # Please instead update this file by running `bin/tapioca gem io-console`.
 
+
 # THIS IS AN EMPTY RBI FILE.
 # see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem