sourced-message 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab48ba13a4c9d34b8b50fac74177da86672fb65bc55ebccd869b53299c24129c
-  data.tar.gz: 7c055a6c838bc91f31971bbdc8eb1b1b598d2531ee8627317ba9e2eae572acb3
+  metadata.gz: a3c83eaa51d67e2693a9437766624a7331535d0580e3d7481a6b97baeb58f63f
+  data.tar.gz: 892f3f3a82b5d9063d830516d167c3f3e7b16b86e8ac2047f1614e787142b48f
 SHA512:
-  metadata.gz: 19774b1fa8a68caa0b3074da601e03710f94f7996a2b6ef2b7dcc593abb32d6c34f8a17a71ea7d5be5ad508e4dafde6ad617518de054f04e3b1f2c56e97c4ac1
-  data.tar.gz: b859d67f328cca620ffc66d15f87cfa33054d0b726bdbb17344a7a5d9f6be1adef325b8abfe960bc6f2a6d702dc95fb3583f2bb4ef42539d35251e851acf798d
+  metadata.gz: 0264f5b499a6d287ed286e0e80158dad36d171dd0da3ff9dfe8425dff0bab2884b64c2405eae964db1dcee415f20763df415b6938d95247e56e937f7d196daf8
+  data.tar.gz: 57dd69b783f5d076babe42d2e05ff4c654fc710da47098dafa8f20907f98347a6c0e3728e43505a9acf30a81b7cfb8635d35d16b388c88f8250a20010bffcc35

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.2.0]
+
+- Add `Sourced::Message::Codec`, the abstract serializer: it compiles a
+  `[decoder, encoder]` pair per registered message type over a `Plumb::Codec` format and
+  encodes/decodes whole messages. A subclass binds the format by answering
+  `.default_format`; each gets its own `.default` and pair cache.
+- Add `Sourced::Message::JSONCodec` (`Plumb::Codec::JSON`) and
+  `Sourced::Message::FormsCodec` (`Plumb::Codec::Forms`). The Forms one types string
+  params from a browser using the message's own schema.
+- Sourced's store and Sidereal's file store and socket pubsub carried near-identical
+  copies of this machinery; both now build on it. Three private seams —
+  `#compiled_type`, `#encode_subject`, `#build` — let a subclass change what is
+  compiled and encoded, which is how `Sourced::Store::MessageCodec` encodes payloads
+  alone while keeping its envelope in columns.
+- `Sourced::Message::VERSION` is now `0.2.0`.
+
 ## [0.1.0] - 2026-06-06
 
 - Initial release

data/README.md

@@ -10,6 +10,7 @@ A message is a [Plumb](https://github.com/ismasan/plumb)-typed value object with
 - `causation_id` / `correlation_id` for tracing causal chains across processes
 - arbitrary `metadata`
 - a global **type registry** that can reconstruct any message from a plain hash — handy for transports, queues and event stores
+- **codecs** that serialize messages to JSON or to form params and back, preserving the types each payload declares
 - scheduling helpers (`#at` / `#in`) for delayed messages
 
 Messages are immutable: every "mutating" method (`#with_payload`, `#with_metadata`, `#at`, `#correlate`) returns a copy.
@@ -127,6 +128,190 @@ Sourced::Message.registry.all.to_a      # => [CourseCreated, EnrollStudent, ...]
 Sourced::Message.registry['course.created'] # => CourseCreated
 ```
 
+### Serialization: codecs
+
+`.from` rebuilds the right class from a hash, but it does **not** translate values. Message types are declared with native Ruby types, and JSON has no `Date`, `Time`, `Symbol` or `BigDecimal` — so a naive `to_h` → JSON → `.from` round trip quietly hands back strings:
+
+```ruby
+CourseCreated = Sourced::Message.define('course.created') do
+  attribute :course_name, String
+  attribute :starts_on, Sourced::Message::Types::Date
+  attribute :level, Sourced::Message::Types::Symbol
+end
+
+msg = CourseCreated.new(
+  payload: { course_name: 'Ruby 101', starts_on: Date.new(2026, 9, 1), level: :beginner }
+)
+
+back = Sourced::Message.from(JSON.parse(JSON.dump(msg.to_h), symbolize_names: true))
+back.payload.starts_on # => "2026-09-01"  (a String!)
+back.payload.level     # => "beginner"    (a String!)
+back.valid?            # => false
+```
+
+Nothing raises along the way, because `.new` does not validate. The message is simply wrong, and you find out somewhere else entirely.
+
+A codec closes that gap. It compiles a `[decoder, encoder]` pair per registered message type and translates values in both directions. Two ship, differing only in the wire format they bind:
+
+| Class | Format | For |
+|---|---|---|
+| `Sourced::Message::JSONCodec` | `Plumb::Codec::JSON` | stores, queues, socket frames, files |
+| `Sourced::Message::FormsCodec` | `Plumb::Codec::Forms` | HTML form params and query strings |
+
+Both inherit their machinery from `Sourced::Message::Codec`, which is abstract — it has no format of its own and exists to be subclassed (or handed a `format:` for a one-off).
+
+```ruby
+codec = Sourced::Message::JSONCodec.default.compile!
+
+encoded = codec.encode(msg)
+# => { id: "8f1c…", causation_id: "8f1c…", correlation_id: "8f1c…",
+#      created_at: "2026-09-01T10:00:00.000000+01:00", metadata: {}, type: "course.created",
+#      payload: { course_name: "Ruby 101", starts_on: "2026-09-01", level: "beginner" } }
+
+decoded = codec.decode(JSON.parse(JSON.dump(encoded), symbolize_names: true))
+decoded.payload.starts_on # => #<Date: 2026-09-01>
+decoded.payload.level     # => :beginner
+```
+
+`#encode` returns JSON-native structures — Hashes, Arrays, Strings, numbers, booleans, `nil` — ready for `JSON.dump`. The codec never writes bytes itself, so the transport decides how they are stored or framed.
+
+#### Compiling is explicit
+
+A codec has no pairs until it is compiled, and it never compiles itself on first use. Compile once, wherever your process considers boot to be over and every message class has loaded:
+
+```ruby
+codec = Sourced::Message::JSONCodec.default
+codec.compiled?   # => false
+codec.compile!    # => the codec, pairs built and frozen
+codec.encode(msg) # ready
+```
+
+This is also the **boot check**. A message type the format cannot represent raises at `compile!`, naming the offending attribute, instead of failing on the first message that happens to carry it:
+
+```ruby
+Sourced::Message.define('reports.generated') { attribute :result, Plumb::Types::Any }
+Sourced::Message::JSONCodec.default.compile!
+# => Plumb::TypeError: cannot apply Plumb::Codec::JSON[…] (decode) to …:
+#    field `payload.result` (Plumb::Types::Any) matches no encoder and is not
+#    covered by its noop types. Register an encoder for it, or declare it with .noop.
+```
+
+The path is dotted from the message root, so `payload.result` points straight at the attribute to fix.
+
+`#compile!` is **idempotent**, so several collaborators sharing one codec can each call it on start without coordinating. A type registered *after* a compile stays invisible until you ask for a rebuild:
+
+```ruby
+codec.compile!    # cheap no-op once compiled
+codec.recompile!  # rebuild, picking up types and encoders registered since
+```
+
+#### Errors
+
+| Raised by | When |
+|---|---|
+| `Plumb::TypeError` | `#compile!` — a message type this format cannot represent |
+| `JSONCodec::EncodeError` | `#encode` — the message does not satisfy its own schema |
+| `JSONCodec::DecodeError` | `#decode` — the encoded values no longer fit the schema (a schema change, a hand-edited record, a foreign writer) |
+| `JSONCodec::UnregisteredTypeError` | either — nothing has compiled yet, or this type was not in the compiled set |
+| `Sourced::Message::UnknownMessageError` | `#decode` — the type string is not in the registry at all |
+
+`EncodeError` and `DecodeError` name the offending type and message id, so a bad record is findable.
+
+#### Teaching it your own types
+
+The format is `Plumb::Codec::JSON`, a process-wide global. Register an encoder on it and every codec in the process learns the type at once:
+
+```ruby
+Money = Data.define(:cents, :currency)
+
+class MoneyEncoder < Plumb::Encoder[
+  Plumb::Types::String[/\A-?\d+ [A-Z]{3}\z/] => Plumb::Types::Any[Money]
+]
+  def encode(money) = "#{money.cents} #{money.currency}"
+
+  def decode(str)
+    cents, currency = str.split
+    Money.new(cents: cents.to_i, currency:)
+  end
+end
+
+Plumb::Codec::JSON.encoder(MoneyEncoder)
+```
+
+Register at load time. A codec compiled before an encoder arrives never sees it.
+
+Note the constraint this creates: every message class in the registry must be encodable by the format, because `#compile!` walks all of them. A type carrying a value the format knows nothing about fails the compile for everyone.
+
+#### Decoding form params: `FormsCodec`
+
+Form params carry no types — every scalar arrives as a String. `FormsCodec` lets the message's own schema do the coercion a web handler would otherwise do by hand:
+
+```ruby
+codec = Sourced::Message::FormsCodec.default.compile!
+
+msg = codec.decode(
+  id: SecureRandom.uuid,
+  type: 'course.created',
+  created_at: Time.now.iso8601(6),
+  metadata: {},
+  payload: { course_name: 'Ruby 101', seats: '30', starts_on: '2026-09-01' }
+)
+
+msg.payload.seats     # => 30                  (Integer, from "30")
+msg.payload.starts_on # => #<Date: 2026-09-01> (from "2026-09-01")
+```
+
+Encoding renders the mirror image — every scalar a String — which is what a form needs to round-trip a message back to the browser.
+
+#### Encoding something other than the whole message
+
+`JSONCodec` encodes the entire message, envelope included, which suits a transport that carries one message as one document — a file body, a socket frame. A store that keeps the envelope in columns wants only the payload encoded. Subclass and override three private seams:
+
+```ruby
+class PayloadOnlyCodec < Sourced::Message::JSONCodec
+  private
+
+  # What Plumb type to compile for a message class.
+  def compiled_type(klass)
+    schema = klass._schema.to_h
+    schema[schema.keys.find { |k| k.to_sym == :payload }]
+  end
+
+  # What #encode feeds the encoder.
+  def encode_subject(message) = message.payload
+
+  # What #decode returns.
+  def build(klass, attrs, decoder)
+    klass.new(attrs.merge(payload: decoder.parse(attrs[:payload])))
+  end
+end
+```
+
+This is exactly what `Sourced::Store::MessageCodec` does. Subclasses get their own `.default` and pair cache automatically — which they need, since one message class compiles to a different pair on each side.
+
+#### Sharing, resetting and the pair cache
+
+`.default` is the shared instance, so a process compiles its pairs once. `.reset!` drops it — for tests between examples, and for a development-mode class reloader:
+
+```ruby
+Sourced::Message::JSONCodec.default   # the shared instance
+Sourced::Message::JSONCodec.reset!    # next .default compiles afresh
+```
+
+Compiled pairs are cached per message class on the codec class and **survive `reset!`**, because building a pair is the whole cost of a compile and a class that did not change does not need a new one. Redefining a type produces a new class, which misses the cache and compiles fresh. `.clear_pairs!` forces a cold rebuild — needed only for a class whose schema changed *in place*, which `.reset!` cannot detect since the class is the same object.
+
+A codec can also be scoped to its own set of encoders, or to a private registry:
+
+```ruby
+class AuditFormat < Plumb::Codec::JSON
+  encoder RedactedEmailEncoder
+end
+
+Sourced::Message::JSONCodec.new(format: AuditFormat, registry: my_registry).compile!
+```
+
+`registry:` needs only `#all(&block)` and `#[](type)` — that is the whole contract.
+
 ### Copying with changes
 
 Messages are immutable. Use the `#with_*` helpers to derive new copies:

data/lib/sourced/message/codec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'plumb'
+
+module Sourced
+  class Message
+    # Compiles a +[decoder, encoder]+ {Pair} per message class and serializes messages
+    # through it. Abstract: a subclass binds the wire format by answering
+    # {.default_format}. {JSONCodec} and {FormsCodec} are the two that ship.
+    #
+    #   codec = Sourced::Message::JSONCodec.default.compile!
+    #   codec.encode(message)  # => structures native to the format
+    #   codec.decode(attrs)    # => the message
+    #
+    # Pairs are keyed by type string and built by {#compile!} from a {Registry}; a type
+    # missing from the result raises, so a type defined after the compile stays invisible
+    # until a fresh codec is built. Compiling is always explicit — nothing here compiles
+    # itself on first use — which makes "when is serialization settled?" a question with
+    # one answer per process.
+    #
+    # It encodes the *whole* message, envelope included, which suits a transport carrying
+    # a message as a single document (a file, a socket frame, a form submission). A store
+    # that keeps the envelope in columns wants only the payload encoded;
+    # {Sourced::Store::MessageCodec} subclasses {JSONCodec} for exactly that. The three
+    # private seams below are the whole subclass contract:
+    #
+    #   #compiled_type(klass)           what Plumb type to compile for a message class
+    #   #encode_subject(message)        what #encode feeds the encoder
+    #   #build(klass, attrs, decoder)   what #decode returns
+    #
+    # Every subclass gets its own +.default+ and +.pairs+ for free (both are plain class
+    # ivars), which is load-bearing: one message class compiles to a different pair under
+    # each format and each seam set, and they must not collide.
+    class Codec
+      # The format a subclass serializes with. Abstract here: {Codec} itself has no
+      # format, so it can only be instantiated by passing one explicitly.
+      #
+      # @return [Class<Plumb::Codec>]
+      def self.default_format
+        raise NotImplementedError,
+              "#{name} has no format of its own; use a subclass (JSONCodec, FormsCodec) " \
+              'or pass format:'
+      end
+
+      # Raised when a message being written can't be represented in the codec's
+      # format, which in practice means the message itself is invalid.
+      EncodeError = Class.new(StandardError)
+
+      # Raised when a serialized message no longer satisfies its class's schema —
+      # a schema change, a hand-edited record, a foreign writer.
+      DecodeError = Class.new(StandardError)
+
+      # Raised when asked for a type this codec has no pair for: one defined after the
+      # compile, one absent from this process, or any type at all when nothing has
+      # compiled yet.
+      UnregisteredTypeError = Class.new(StandardError)
+
+      # A message class's compiled +[decoder, encoder]+ for one format.
+      Pair = Data.define(:decoder, :encoder)
+
+      # The instance that callers share. Holding no connections or file handles, it is
+      # safe to share, so a process compiles its pairs once.
+      #
+      # @return [Codec]
+      def self.default = @default ||= new
+
+      # Drop the shared instance, so the next {.default} compiles against the current
+      # registry — between tests, and for a development-mode class reloader.
+      #
+      # The {.pairs} cache deliberately survives: building a pair is the expensive part
+      # of a compile, and a class that did not change does not need a new one.
+      #
+      # @return [void]
+      def self.reset!
+        @default = nil
+      end
+
+      # Compiled pairs, keyed by message class, shared across every instance of this
+      # class and every reset. A class's schema is fixed once its +define+ block has
+      # run, so its pair is too — which makes recompiling a matter of re-collecting
+      # existing pairs. Redefining a message type produces a *new* class, so it misses
+      # the cache and compiles fresh; that is what makes the cache safe under reloading.
+      # (Reopening a class to add attributes after it has been compiled once would not
+      # be picked up; {.clear_pairs!} is the way out of that.)
+      #
+      # Keyed by the message class, not by the type {#compiled_type} returns: a class is
+      # identity-keyed and stable, where a Plumb node would put the cache at the mercy
+      # of that node's +#hash+/+#eql?+.
+      #
+      # Held strongly. A weakly-keyed map would not help: a pair is built from its class
+      # and refers back to it, so holding the pair keeps the class reachable either way.
+      # A reloader that discards classes should call {.clear_pairs!}.
+      #
+      # @return [Hash{Class => Hash{Class<Plumb::Codec> => Pair}}]
+      def self.pairs
+        @pairs ||= {}
+      end
+
+      # Discard cached pairs, so every class is compiled again. For a reloader dropping
+      # classes, and for a class whose schema changed in place — which {.reset!} cannot
+      # detect, since the class is the same object.
+      #
+      # @return [void]
+      def self.clear_pairs!
+        @pairs = nil
+      end
+
+      # @return [Class<Plumb::Codec>] the format compiled onto message types
+      attr_reader :format
+
+      # @param format [Class<Plumb::Codec>] the format compiled onto message types.
+      #   Defaults to the subclass's {.default_format}; pass one to scope a codec to its
+      #   own set of encoders, as specs do.
+      # @param registry [Registry] resolves type strings to classes. Needs only +#all+
+      #   and +#[]+. Defaults to the root registry, which recurses into every subclass
+      #   registry, so one codec covers every message type in the process.
+      def initialize(format: self.class.default_format, registry: Sourced::Message.registry)
+        @format = format
+        @registry = registry
+        @messages = nil
+      end
+
+      # +attr_reader :format+ shadows +Kernel#format+ in instance scope, so this
+      # interpolates.
+      #
+      # @return [String]
+      def inspect = "#<#{self.class.name} format=#{@format.name}#{compiled? ? '' : ' (not compiled)'}>"
+
+      # @return [Boolean] whether {#compile!} has run
+      def compiled? = !@messages.nil?
+
+      # Build a pair for every message class in the registry, frozen once they are all in.
+      #
+      # Also the boot check: a message type this format cannot represent raises here,
+      # naming the offending attribute path, so the failure lands at boot instead of on
+      # the first message that happens to carry the type.
+      #
+      # Idempotent, so several collaborators sharing a codec can each call it on start
+      # without coordinating. {#recompile!} is how to pick up types registered since.
+      #
+      # Note what it does *not* check: whether data already written satisfies its schema.
+      # That is a per-message question, answered by {#decode} when the message is read.
+      #
+      # @return [self]
+      # @raise [Plumb::TypeError] if any registered message type can't be serialized by
+      #   this format
+      def compile!
+        return self if compiled?
+
+        messages = {}
+        @registry.all { |klass| messages[klass.type] = pair_for(klass) }
+        @messages = messages.freeze
+        self
+      end
+
+      # Compile again from scratch, picking up message types and encoders registered
+      # since the last compile.
+      #
+      # @return [self]
+      # @raise [Plumb::TypeError] see {#compile!}
+      def recompile!
+        @messages = nil
+        compile!
+      end
+
+      # @param type [String] message type string
+      # @return [Boolean] whether a pair was compiled for this type
+      def registered?(type) = !@messages.nil? && @messages.key?(type)
+
+      # Encode a message into the format's native values, ready to serialize.
+      #
+      # @param message [Sourced::Message]
+      # @return [Object] whatever the format renders — a Hash for JSON
+      # @raise [EncodeError] if the message doesn't satisfy its own schema
+      # @raise [UnregisteredTypeError] if the type was not compiled
+      def encode(message)
+        pair(message.type, message.id).encoder.parse(encode_subject(message))
+      rescue Plumb::ParseError => e
+        raise EncodeError, "cannot encode #{label(message.type, message.id)}: #{e.message}"
+      end
+
+      # Rebuild a message from decoded attributes. An unknown type raises: a process
+      # reading types it doesn't know about is missing the class.
+      #
+      # @param attrs [Hash] symbol-keyed message attributes
+      # @return [Sourced::Message]
+      # @raise [UnknownMessageError] if the type isn't in the registry
+      # @raise [UnregisteredTypeError] if the type was not compiled
+      # @raise [DecodeError] if the attributes don't satisfy the schema
+      def decode(attrs)
+        type = attrs[:type]
+        klass = @registry[type]
+        raise UnknownMessageError, "Unknown message type: #{label(type, attrs[:id])}" unless klass
+
+        build(klass, attrs, pair(type, attrs[:id]).decoder)
+      rescue Plumb::ParseError => e
+        raise DecodeError, "cannot decode #{label(type, attrs[:id])}: #{e.message}"
+      end
+
+      private
+
+      # --- subclass seams -------------------------------------------------------
+
+      # @param klass [Class<Sourced::Message>]
+      # @return [Object] the Plumb type to compile a pair for
+      def compiled_type(klass) = klass
+
+      # @param message [Sourced::Message]
+      # @return [Object] what the encoder receives
+      def encode_subject(message) = message
+
+      # @param klass [Class<Sourced::Message>] resolved from the registry
+      # @param attrs [Hash] the encoded attributes
+      # @param decoder [Object] this type's compiled decoder
+      # @return [Sourced::Message]
+      def build(_klass, attrs, decoder) = decoder.parse(attrs)
+
+      # --------------------------------------------------------------------------
+
+      # @raise [UnregisteredTypeError] naming the message, and separating "nothing has
+      #   compiled" from "this type isn't in the compiled set" — the two are fixed in
+      #   different places
+      def pair(type, id)
+        raise UnregisteredTypeError, "codec has not compiled; #{label(type, id)} cannot be handled" if @messages.nil?
+
+        @messages[type] ||
+          raise(UnregisteredTypeError, "no encoder/decoder compiled for #{label(type, id)}")
+      end
+
+      # The class's pair for this format, built once per class and reused across every
+      # recompile. Building it is the whole cost of a compile — the rewrite walks the
+      # schema and resolves an encoder for every leaf.
+      def pair_for(klass)
+        by_format = self.class.pairs[klass] ||= {}
+        by_format[@format] ||= Pair.new(*@format.for(compiled_type(klass)))
+      end
+
+      # "orders.placed (a1b2c3…)" — enough to find the offending message.
+      def label(type, id) = "#{type} (#{id})"
+    end
+  end
+end

data/lib/sourced/message/forms_codec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'sourced/message/codec'
+
+module Sourced
+  class Message
+    # Serializes messages to and from the string-shaped structures of HTML forms and
+    # query strings, where every scalar arrives as a String.
+    #
+    # Decoding is the direction that earns its keep: form params carry no types, so a
+    # web handler would otherwise coerce each attribute by hand. Here the message's own
+    # schema does it.
+    #
+    #   codec = Sourced::Message::FormsCodec.default.compile!
+    #
+    #   codec.decode(
+    #     id: '…', type: 'course.created', created_at: '2026-09-01T10:00:00.000000+01:00',
+    #     metadata: {}, payload: { course_name: 'Ruby 101', seats: '30', starts_on: '2026-09-01' }
+    #   )
+    #   # => CourseCreated with seats: 30 (Integer) and starts_on: #<Date: 2026-09-01>
+    #
+    # Encoding renders the mirror image — every scalar a String — which is what a form
+    # needs to round-trip a message back to the browser.
+    #
+    # See {Codec} for the machinery, and for the seams a subclass overrides.
+    class FormsCodec < Codec
+      def self.default_format = Plumb::Codec::Forms
+    end
+  end
+end

data/lib/sourced/message/json_codec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'sourced/message/codec'
+
+module Sourced
+  class Message
+    # Serializes messages to and from JSON-native structures — Hashes, Arrays, Strings,
+    # numbers, booleans, +nil+ — ready for +JSON.dump+. The codec never writes bytes
+    # itself, so the transport decides how they are stored or framed.
+    #
+    #   codec = Sourced::Message::JSONCodec.default.compile!
+    #   codec.encode(message)  # => JSON-native Hash
+    #   codec.decode(attrs)    # => the message
+    #
+    # +Plumb::Codec::JSON+ is a process-wide global, so an encoder registered on it
+    # teaches every JSON codec in the process at once:
+    #
+    #   Plumb::Codec::JSON.encoder(MoneyEncoder)
+    #
+    # Register at load time — a codec compiled before an encoder arrives never sees it.
+    #
+    # See {Codec} for the machinery, and for the seams a subclass overrides.
+    class JSONCodec < Codec
+      def self.default_format = Plumb::Codec::JSON
+    end
+  end
+end

data/lib/sourced/message.rb

@@ -22,7 +22,7 @@ module Sourced
   # +Sourced::Message.registry[type]+ resolves a type registered under any
   # subclass. Resolve from this root to see the whole tree.
   class Message < Plumb::Types::Data
-    VERSION = '0.1.1'
+    VERSION = '0.2.1'
 
     EMPTY_ARRAY = [].freeze
 
@@ -270,3 +270,8 @@ module Sourced
   class Command < Message; end
   class Event < Message; end
 end
+
+# Required here so `require 'sourced/message'` gives you the whole gem.
+require 'sourced/message/codec'
+require 'sourced/message/json_codec'
+require 'sourced/message/forms_codec'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sourced-message
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Ismael Celis
@@ -13,16 +13,16 @@ dependencies:
   name: plumb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.18
+        version: 0.2.0.beta.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.18
+        version: 0.2.0.beta.2
 - !ruby/object:Gem::Dependency
   name: fugit
   requirement: !ruby/object:Gem::Requirement
@@ -51,6 +51,9 @@ files:
 - README.md
 - Rakefile
 - lib/sourced/message.rb
+- lib/sourced/message/codec.rb
+- lib/sourced/message/forms_codec.rb
+- lib/sourced/message/json_codec.rb
 homepage: https://github.com/ismasan/sourced-message
 licenses:
 - MIT