sorbet-schema 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6e96bccc5924a52824327d2d5bc3b8e79b887ac31d13b292581c347c1d43480
-  data.tar.gz: 36896e42540d07c714b8075c7c2b89b4d47c5d09d1e098e83ecf050f6c68fa50
+  metadata.gz: b0c3bb89fee8f842f919e0cf1f53d8f97fb12e4464effb88c7e821134c531a1f
+  data.tar.gz: a78684855bb1bd76e6688b0daa04f026fcb55c23fd2f354daaea8e7a2f0f5cd3
 SHA512:
-  metadata.gz: c0a12cf7754d2e13eaebb5a0b042a2abea848dc79aeda84b2887f0c949b523c2aa8a1b3a842562ee053c15dcb3b5a13c6caf1e760bbf9c7f297ea39285c5e1e3
-  data.tar.gz: b72bc80795f41444f06b2aa9bc7186f3669993c95cb7e3e500e021fc2c053c2ac5088d2e3a0efae32aa4e1bd0d35c138602de08fba9f31ded554b43ae7aefd4d
+  metadata.gz: 28656d268e7861ae7e069ff30b024a2d063ee33f5824ca9bc1319cbe91555b2e80b402ee2438b975d299c58f624c4e8afba1ba8649a62c8d05a6efc3fa10fbac
+  data.tar.gz: 9faf4f7458d56d9a66645d1d25aa4d70a83eea9abba3e1021a5fe58a5978d0c309a987d20e5af1dfc538f5d0a550f40ed1afa6a35c39ff2e5173a9b44a6cd118

data/.ruby-version

@@ -1 +1 @@
-3.3.4
+3.4.7

data/AGENTS.md

@@ -0,0 +1,15 @@
+# Project agent memory
+
+This file is the project's committed home for project-intrinsic agent knowledge: build, test, release, architecture, and sharp-edge notes that should travel with the code.
+
+- Add durable project-specific notes here as they are discovered through real work.
+- Ruby 3.4+ unbundles former stdlib gems (e.g. `csv`) from the default load path, so `require "csv"` is not free — it needs the gem actually installed.
+- Format-specific serializers (`CSVSerializer`, `MessagePackSerializer`, `ActiveRecordSerializer`) treat their backing gem as optional: no top-level `require`, gem is `add_development_dependency` only (not `add_runtime_dependency`), the `require`/gem-presence check happens lazily in `initialize` with a clear `ArgumentError` on failure, and `T::Struct.serializer`'s factory (`lib/sorbet-schema/t/struct.rb`) mirrors that same guard via `defined?(...)`. Follow this pattern for any new serializer/coercer with a non-stdlib dependency; see `lib/typed/csv_serializer.rb` for the exact shape.
+- After adding a new *required* runtime gem dependency (not this optional-serializer case), run `bundle exec tapioca gem` (add the gem to `sorbet/tapioca/require.rb` first if it isn't required anywhere else) so `bundle exec rake` (which runs `srb tc`) has an RBI to check against.
+
+## Maintaining this file
+
+Keep this file for knowledge useful to almost every future agent session in this project.
+Do not repeat what the codebase already shows; point to the authoritative file or command instead.
+Prefer rewriting or pruning existing entries over appending new ones.
+When updating this file, preserve this bar for all agents and keep entries concise.

data/CHANGELOG.md

@@ -4,6 +4,30 @@ 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.10.0](https://github.com/maxveldink/sorbet-schema/compare/v0.9.3...v0.10.0) (2026-08-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* bump local Ruby to 3.4, add to matrix ([#138](https://github.com/maxveldink/sorbet-schema/issues/138))
+
+### Features
+
+* add Typed::CSVSerializer ([#12](https://github.com/maxveldink/sorbet-schema/issues/12)) ([#144](https://github.com/maxveldink/sorbet-schema/issues/144)) ([b2377f0](https://github.com/maxveldink/sorbet-schema/commit/b2377f083782c0eb39ab442b14cb4bf18a2a8922))
+* add Typed::MessagePackSerializer ([#145](https://github.com/maxveldink/sorbet-schema/issues/145)) ([d367da8](https://github.com/maxveldink/sorbet-schema/commit/d367da83b2d9e72f5099b70594243178c3df432c))
+* add Typed::YMLSerializer ([#13](https://github.com/maxveldink/sorbet-schema/issues/13)) ([#143](https://github.com/maxveldink/sorbet-schema/issues/143)) ([bcc7eb8](https://github.com/maxveldink/sorbet-schema/commit/bcc7eb810f32b46d454df3a0c19468b0de09f498))
+* **typed:** add ActiveRecord serializer ([#140](https://github.com/maxveldink/sorbet-schema/issues/140)) ([a815f9f](https://github.com/maxveldink/sorbet-schema/commit/a815f9f42cb36c26ead45630384eb6b5022cd43d))
+
+
+### Bug Fixes
+
+* **typed:** make csv and msgpack gem dependencies optional ([#146](https://github.com/maxveldink/sorbet-schema/issues/146)) ([db22258](https://github.com/maxveldink/sorbet-schema/commit/db222586207129fc46d981a8efd28413aea99c7b))
+
+
+### Miscellaneous Chores
+
+* bump local Ruby to 3.4, add to matrix ([#138](https://github.com/maxveldink/sorbet-schema/issues/138)) ([1cf6a5b](https://github.com/maxveldink/sorbet-schema/commit/1cf6a5bdb77137ee34aa5c1bca66dd1ede37f875))
+
 ## [0.9.3](https://github.com/maxveldink/sorbet-schema/compare/v0.9.2...v0.9.3) (2025-12-06)
 
 

data/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

data/Gemfile

@@ -12,7 +12,7 @@ group :development do
   gem "standard-performance"
   gem "standard-sorbet"
   gem "sorbet"
-  gem "tapioca", require: false
+  gem "tapioca", "~> 0.16.6", require: false
 end
 
 group :development, :test do
@@ -24,4 +24,7 @@ group :development, :test do
   gem "debug"
 
   gem "sorbet-struct-comparable"
+
+  gem "activerecord", ">= 6.0"
+  gem "sqlite3"
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.9.3)
+    sorbet-schema (0.10.0)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
@@ -10,15 +10,41 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    activemodel (8.1.2)
+      activesupport (= 8.1.2)
+    activerecord (8.1.2)
+      activemodel (= 8.1.2)
+      activesupport (= 8.1.2)
+      timeout (>= 0.4.0)
+    activesupport (8.1.2)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
     ansi (1.5.0)
     ast (2.4.2)
+    base64 (0.3.0)
     benchmark-ips (2.14.0)
     bigdecimal (3.1.8)
     builder (3.3.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    csv (3.3.6)
     debug (1.9.2)
       irb (~> 1.10)
       reline (>= 0.3.8)
+    drb (2.2.3)
     erubi (1.13.0)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
     io-console (0.7.2)
     irb (1.14.0)
       rdoc (>= 4.0.0)
@@ -26,6 +52,7 @@ GEM
     json (2.7.2)
     language_server-protocol (3.17.0.3)
     lint_roller (1.1.0)
+    logger (1.7.0)
     minitest (5.24.1)
     minitest-focus (1.4.0)
       minitest (>= 4, < 6)
@@ -34,20 +61,23 @@ GEM
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    msgpack (1.8.4)
     netrc (0.11.0)
     parallel (1.25.1)
     parser (3.3.3.0)
       ast (~> 2.4.1)
       racc
-    prism (0.30.0)
+    prism (1.6.0)
     psych (5.1.2)
       stringio
     racc (1.8.0)
     rainbow (3.1.1)
     rake (13.2.1)
-    rbi (0.1.13)
-      prism (>= 0.18.0, < 1.0.0)
-      sorbet-runtime (>= 0.5.9204)
+    rbi (0.3.7)
+      prism (~> 1.0)
+      rbs (>= 3.4.4)
+    rbs (3.9.5)
+      logger
     rdoc (6.7.0)
       psych (>= 4.0.0)
     regexp_parser (2.9.2)
@@ -74,6 +104,7 @@ GEM
     rubocop-sorbet (0.7.8)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
     sorbet (0.5.11475)
       sorbet-static (= 0.5.11475)
     sorbet-result (1.1.0)
@@ -91,6 +122,8 @@ GEM
       prism (>= 0.28.0)
       sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
+    sqlite3 (2.9.0-arm64-darwin)
+    sqlite3 (2.9.0-x86_64-linux-gnu)
     standard (1.39.1)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
@@ -108,17 +141,21 @@ GEM
       rubocop-sorbet (~> 0.7.0)
     stringio (3.1.1)
     strscan (3.1.0)
-    tapioca (0.15.0)
+    tapioca (0.16.6)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
-      rbi (>= 0.1.4, < 0.2)
+      rbi (~> 0.2)
       sorbet-static-and-runtime (>= 0.5.11087)
       spoom (>= 1.2.0)
       thor (>= 1.2.0)
       yard-sorbet
     thor (1.3.1)
+    timeout (0.6.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
     unicode-display_width (2.5.0)
+    uri (1.1.1)
     yard (0.9.36)
     yard-sorbet (0.9.0)
       sorbet-runtime
@@ -129,23 +166,28 @@ PLATFORMS
   arm64-darwin-22
   arm64-darwin-23
   arm64-darwin-25
+  arm64-darwin-27
   x86_64-linux
 
 DEPENDENCIES
+  activerecord (>= 6.0)
   benchmark-ips
   bigdecimal
+  csv (~> 3.3)
   debug
   minitest
   minitest-focus
   minitest-reporters
+  msgpack (~> 1.7)
   rake
   sorbet
   sorbet-schema!
   sorbet-struct-comparable
+  sqlite3
   standard
   standard-performance
   standard-sorbet
-  tapioca
+  tapioca (~> 0.16.6)
 
 BUNDLED WITH
-   2.5.15
+   2.7.2

data/README.md

@@ -54,6 +54,8 @@ result = max.serialize_to(:json)
 result.payload # == '{"name":"Max","age":29}'
 ```
 
+`:hash`, `:json`, `:csv`, `:yml`, and `:msgpack` are all supported as the first argument to `deserialize_from`/`serialize_to` (and the equivalent `from_hash`/`from_json`/`from_csv`/`from_yml`/`from_msgpack` methods on `Typed::Schema`), corresponding to the built-in serializers below.
+
 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.
@@ -109,6 +111,8 @@ end
 
 These are the currently available serializers. For more information about implementing a custom one (or contributing one back!), see [Custom Coercers](#custom-coercers).
 
+`HashSerializer`, `JSONSerializer`, and `YMLSerializer` work out of the box with no extra dependencies. `CSVSerializer` and `MessagePackSerializer` require you to add the `csv` and `msgpack` gems, respectively, to your own Gemfile - they are not pulled in as runtime dependencies of `sorbet-schema` itself. Referencing `:csv`/`:msgpack` via `serializer`/`deserialize_from`/`serialize_to` without the gem installed raises a clear `ArgumentError` telling you which gem to add.
+
 #### JSONSerializer
 
 See [Getting Started](#getting-started) for more information on how to use the JSONSerializer.
@@ -129,6 +133,86 @@ 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`.
 
+#### CSVSerializer
+
+Accepts and returns a CSV string representing a single record, with a header row followed by one data row:
+
+```ruby
+csv_serializer = Typed::CSVSerializer.new(schema: Person.schema)
+
+# Deserialize from target format
+result = csv_serializer.deserialize("name,age\nMax,29\n")
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+# Serialize to target format
+result = csv_serializer.serialize(max)
+result.payload # == "name,age\nMax,29\n"
+```
+
+CSV is a flat, row-based format, so nested `T::Struct`s, `Hash`es, and `Array`s cannot be represented as their own columns. Rather than writing a lossy representation into a cell that can never be parsed back correctly, `CSVSerializer#serialize` returns a `Typed::SerializeError` naming the offending field(s) when a struct has one. Prefer this serializer for schemas with scalar fields only, or use an `inline_serializer` (see [Inline Serializers](#inline-serializers)) to flatten a nested field into a scalar before serializing it to CSV.
+
+#### YMLSerializer
+
+Works just like the `JSONSerializer`, but with YAML strings:
+
+```ruby
+yml_serializer = Typed::YMLSerializer.new(schema: Person.schema)
+
+# Deserialize from target format
+result = yml_serializer.deserialize("---\nname: Max\nage: 29\n")
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+# Serialize to target format
+result = yml_serializer.serialize(max)
+result.payload # == "---\nname: Max\nage: 29\n"
+```
+
+#### MessagePackSerializer
+
+Works just like the `JSONSerializer`, but with [MessagePack](https://msgpack.org/) binary-encoded strings, using the [`msgpack`](https://github.com/msgpack/msgpack-ruby) gem:
+
+```ruby
+message_pack_serializer = Typed::MessagePackSerializer.new(schema: Person.schema)
+
+# Deserialize from target format
+result = message_pack_serializer.deserialize(MessagePack.pack({"name" => "Max", "age" => 29}))
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+# Serialize to target format
+result = message_pack_serializer.serialize(max)
+result.payload # == MessagePack.pack({"name" => "Max", "age" => 29})
+```
+
+Unlike `CSVSerializer`, MessagePack natively supports nested maps and arrays, so nested `T::Struct`s, `Hash`es, and `Array`s round-trip without any `inline_serializer` needed.
+
+#### ActiveRecordSerializer
+
+Requires the `activerecord` gem to be available. This is only checked when going through `.serializer(:activerecord)`, which raises an `ArgumentError` if the gem isn't loaded; calling `Typed::ActiveRecordSerializer.new` directly without ActiveRecord loaded instead raises a `NameError`, since the class itself references the `ActiveRecord` constant. The `Typed::ActiveRecordSerializer` converts between `ActiveRecord::Base` model instances and `T::Struct`s, matching fields by attribute name and mapping associated records through the model's declared associations. It requires a `model_class` option, in addition to `schema`, so it knows which `ActiveRecord::Base` subclass to deserialize from and serialize to:
+
+```ruby
+ar_serializer = Typed::ActiveRecordSerializer.new(schema: Person.schema, model_class: PersonModel)
+
+# Deserialize from target format
+result = ar_serializer.deserialize(PersonModel.new(name: "Max", age: 29))
+max = result.payload # == Person.new(name: "Max", age: 29)
+
+result = ar_serializer.serialize(max)
+result.payload # == PersonModel instance with name: "Max", age: 29
+```
+
+When serializing, only fields that map to a column (or to an association's declared foreign key) on `model_class` are assigned; the rest are ignored.
+
+Nested `belongs_to` associations are deserialized recursively to arbitrary depth, so a `T::Struct` field whose type is itself a `T::Struct` backed by a `belongs_to` association will have its own nested associations resolved too.
+
+Deserializing reads through the model's association readers, so it is subject to the same N+1 query behavior as any other Rails association access. Preloading with `includes` works transparently and is the recommended way to avoid a query per record per association when deserializing a collection:
+
+```ruby
+# 1 query for people + 1 query for locations, instead of 1 + N
+PersonModel.includes(:location).find_each do |person_model|
+  ar_serializer.deserialize(person_model)
+end
+```
+
 ### 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!

data/benchmarks/helpers.rb

@@ -236,4 +236,3 @@ module BenchmarkHelpers
     }
   end
 end
-

data/benchmarks/many_fields_serialization.rb

@@ -24,4 +24,3 @@ Benchmark.ips do |x|
 
   x.compare!
 end
-

data/benchmarks/simple_serialization.rb

@@ -24,4 +24,3 @@ Benchmark.ips do |x|
 
   x.compare!
 end
-

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

@@ -13,6 +13,16 @@ module T
           Typed::HashSerializer.new(**T.unsafe({schema:, **options}))
         when :json
           Typed::JSONSerializer.new(schema:)
+        when :csv
+          Typed::CSVSerializer.new(schema:)
+        when :yml
+          Typed::YMLSerializer.new(schema:)
+        when :msgpack
+          Typed::MessagePackSerializer.new(schema:)
+        when :activerecord
+          raise ArgumentError, "activerecord gem is required for ActiveRecord serialization" unless defined?(ActiveRecord)
+
+          Typed::ActiveRecordSerializer.new(**T.unsafe({schema:, **options}))
         else
           raise ArgumentError, "unknown serializer for #{type}"
         end

data/lib/sorbet-schema/version.rb

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

data/lib/sorbet-schema.rb

@@ -12,7 +12,9 @@ loader.push_dir(__dir__.to_s)
 loader.ignore(__FILE__)
 loader.ignore("#{__dir__}/sorbet-schema/**/*.rb")
 loader.inflector.inflect(
-  "json_serializer" => "JSONSerializer"
+  "json_serializer" => "JSONSerializer",
+  "csv_serializer" => "CSVSerializer",
+  "yml_serializer" => "YMLSerializer"
 )
 loader.setup
 

data/lib/typed/active_record_serializer.rb

@@ -0,0 +1,85 @@
+# typed: strict
+
+module Typed
+  class ActiveRecordSerializer < Serializer
+    Input = type_member { {fixed: T.untyped} }
+    Output = type_member { {fixed: ActiveRecord::Base} }
+
+    sig { returns(T.class_of(ActiveRecord::Base)) }
+    attr_reader :model_class
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    attr_reader :associations_by_name
+
+    sig { params(schema: Schema, model_class: T.class_of(ActiveRecord::Base)).void }
+    def initialize(schema:, model_class:)
+      @model_class = model_class
+      @associations_by_name = T.let(
+        model_class.reflect_on_all_associations.each_with_object({}) { |association, hsh| hsh[association.name.to_s] = association },
+        T::Hash[String, T.untyped]
+      )
+
+      super(schema: schema)
+    end
+
+    sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+    def deserialize(source)
+      return Failure.new(DeserializeError.new("Cannot deserialize a non-ActiveRecord object.")) unless source.is_a?(ActiveRecord::Base)
+
+      return Failure.new(DeserializeError.new("'#{source.class}' is not an instance of '#{model_class}'.")) unless source.class <= model_class
+
+      creation_params = schema.fields.each_with_object(T.let({}, Params)) do |field, hsh|
+        if source.respond_to?(field.name)
+          value = source.send(field.name)
+          hsh[field.name] = coerce_ar_value(field:, value:)
+        end
+      end
+
+      deserialize_from_creation_params(creation_params)
+    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
+
+      hsh = serialize_from_struct(struct:, should_serialize_values: true)
+      column_names = model_class.column_names
+
+      filtered = hsh.each_with_object(T.let({}, T::Hash[String, T.untyped])) do |(key, value), attrs|
+        key_s = key.to_s
+        association = associations_by_name[key_s]
+
+        if association
+          attrs[key_s] = association.klass.new(value) if column_names.include?(association.foreign_key)
+        elsif column_names.include?(key_s)
+          attrs[key_s] = value
+        end
+      end
+
+      Success.new(model_class.new(filtered))
+    rescue ActiveRecord::AssociationTypeMismatch => e
+      Failure.new(SerializeError.new(e.message))
+    end
+
+    private
+
+    sig { params(field: Field, value: T.untyped).returns(T.untyped) }
+    def coerce_ar_value(field:, value:)
+      return value unless value.is_a?(ActiveRecord::Base)
+
+      nested_struct_class = struct_class_for(field.type)
+      return value.attributes.transform_keys(&:to_sym) unless nested_struct_class
+
+      nested_result = ActiveRecordSerializer.new(schema: nested_struct_class.schema, model_class: value.class).deserialize(value)
+      nested_result.success? ? nested_result.payload : value.attributes.transform_keys(&:to_sym)
+    end
+
+    sig { params(type: T::Types::Base).returns(T.nilable(T.class_of(T::Struct))) }
+    def struct_class_for(type)
+      return nil unless type.respond_to?(:raw_type)
+
+      raw_type = T.cast(type, T::Types::Simple).raw_type
+      (raw_type < T::Struct) ? raw_type : nil
+    end
+  end
+end

data/lib/typed/csv_serializer.rb

@@ -0,0 +1,57 @@
+# typed: strict
+
+module Typed
+  # CSV is a flat, row-based format, so nested structs/hashes/arrays cannot be
+  # represented as their own columns. `serialize` fails with a `SerializeError`
+  # naming the offending field(s) rather than writing a lossy representation
+  # that `deserialize` could never parse back; see README's CSVSerializer
+  # section for the caveat.
+  class CSVSerializer < Serializer
+    Input = type_member { {fixed: String} }
+    Output = type_member { {fixed: String} }
+
+    sig { params(schema: Schema).void }
+    def initialize(schema:)
+      require "csv"
+      super
+    rescue LoadError
+      raise ArgumentError, "csv gem is required for CSV serialization - add it to your Gemfile"
+    end
+
+    sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+    def deserialize(source)
+      parsed = CSV.parse(source, headers: true)
+      return Failure.new(ParseError.new(format: :csv)) unless parsed.is_a?(CSV::Table)
+
+      row = parsed.first
+      return Failure.new(ParseError.new(format: :csv)) unless row.is_a?(CSV::Row)
+
+      creation_params = schema.fields.each_with_object(T.let({}, Params)) do |field, hsh|
+        hsh[field.name] = row[field.name.to_s]
+      end
+
+      deserialize_from_creation_params(creation_params)
+    rescue CSV::MalformedCSVError
+      Failure.new(ParseError.new(format: :csv))
+    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
+
+      hsh = serialize_from_struct(struct:, should_serialize_values: true)
+
+      non_scalar_fields = hsh.select { |_key, value| value.is_a?(Hash) || value.is_a?(Array) }.keys
+      unless non_scalar_fields.empty?
+        return Failure.new(SerializeError.new("'#{struct.class}' cannot be serialized to CSV because field(s) #{non_scalar_fields.join(", ")} are not scalar values."))
+      end
+
+      csv_string = CSV.generate do |csv|
+        csv << hsh.keys.map(&:to_s)
+        csv << hsh.values
+      end
+
+      Success.new(csv_string)
+    end
+  end
+end

data/lib/typed/message_pack_serializer.rb

@@ -0,0 +1,40 @@
+# typed: strict
+
+module Typed
+  class MessagePackSerializer < Serializer
+    # MessagePack packs to a binary (`ASCII-8BIT`) encoded string, not text,
+    # but `String` is still the correct Sorbet type for it, same as `Input`/`Output`
+    # on the other serializers.
+    Input = type_member { {fixed: String} }
+    Output = type_member { {fixed: String} }
+
+    sig { params(schema: Schema).void }
+    def initialize(schema:)
+      require "msgpack"
+      super
+    rescue LoadError
+      raise ArgumentError, "msgpack gem is required for MessagePack serialization - add it to your Gemfile"
+    end
+
+    sig { override.params(source: Input).returns(Result[T::Struct, DeserializeError]) }
+    def deserialize(source)
+      parsed_msgpack = MessagePack.unpack(source)
+      return Failure.new(ParseError.new(format: :msgpack)) unless parsed_msgpack.is_a?(Hash)
+
+      creation_params = schema.fields.each_with_object(T.let({}, Params)) do |field, hsh|
+        hsh[field.name] = parsed_msgpack[field.name.to_s]
+      end
+
+      deserialize_from_creation_params(creation_params)
+    rescue MessagePack::UnpackError, EOFError
+      Failure.new(ParseError.new(format: :msgpack))
+    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(MessagePack.pack(serialize_from_struct(struct:, should_serialize_values: true)))
+    end
+  end
+end

data/lib/typed/schema.rb

@@ -28,6 +28,21 @@ module Typed
       json_serializer.deserialize(json)
     end
 
+    sig { params(csv: String).returns(Typed::Serializer::DeserializeResult) }
+    def from_csv(csv)
+      csv_serializer.deserialize(csv)
+    end
+
+    sig { params(yml: String).returns(Typed::Serializer::DeserializeResult) }
+    def from_yml(yml)
+      yml_serializer.deserialize(yml)
+    end
+
+    sig { params(msgpack: String).returns(Typed::Serializer::DeserializeResult) }
+    def from_msgpack(msgpack)
+      message_pack_serializer.deserialize(msgpack)
+    end
+
     sig { params(field_name: Symbol, serializer: Field::InlineSerializer).returns(Schema) }
     def add_serializer(field_name, serializer)
       self.class.new(
@@ -55,5 +70,23 @@ module Typed
       @json_serializer = T.let(@json_serializer, T.nilable(Typed::JSONSerializer))
       @json_serializer ||= Typed::JSONSerializer.new(schema: self)
     end
+
+    sig { returns(Typed::CSVSerializer) }
+    def csv_serializer
+      @csv_serializer = T.let(@csv_serializer, T.nilable(Typed::CSVSerializer))
+      @csv_serializer ||= Typed::CSVSerializer.new(schema: self)
+    end
+
+    sig { returns(Typed::YMLSerializer) }
+    def yml_serializer
+      @yml_serializer = T.let(@yml_serializer, T.nilable(Typed::YMLSerializer))
+      @yml_serializer ||= Typed::YMLSerializer.new(schema: self)
+    end
+
+    sig { returns(Typed::MessagePackSerializer) }
+    def message_pack_serializer
+      @message_pack_serializer = T.let(@message_pack_serializer, T.nilable(Typed::MessagePackSerializer))
+      @message_pack_serializer ||= Typed::MessagePackSerializer.new(schema: self)
+    end
   end
 end