pgoutput-decoder 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef596cb600c9565a1d4088f34af0877c1dc135bf23e785800ba79cfabb4bc23
-  data.tar.gz: d64785d16df4da805dcb358c8193b70e360e4fc07d7afe2e676f4248c1588cb1
+  metadata.gz: bc6535189e67a471cc685b43e61aa084fd8e5b109cbbff682494a49a936164e6
+  data.tar.gz: 93858268fe2519951b33561b5deec1da508f32b7d2fa00f1c364731d5c6715b7
 SHA512:
-  metadata.gz: eb5c9be51c3ca6cf6a575f3ef2f8c6eca2e32730a9804f590576c0d53f2daa8e184af4d92c3131e4f3d370b793bd1373fe8e722a6d266f7e02072aa18c666bc0
-  data.tar.gz: 669771765199e459020de5a22b87a3d70d4927b1fd5a7a7d59e9159f7944c32304c619920dcd4550711630d143ff20b1444e5ff1ee2d3b8e4b4ec5f19ecf9177
+  metadata.gz: 1fbac46c86f50fa10ccdb623cd301ce12b12f72bd271915d0fa567e4605f758b2961cfb466661c1e59918ef89829a8bf367d3e771bcd9d55ec31dbf3d6a2bea3
+  data.tar.gz: 3978a4c40f0939917ca97f129130995682602cadf2254b92bee9fa1fe56608baab401112efefc756ed5dc23ce9db837c6702ca9dbb5c71e403db23a1909c5bd1

data/CHANGELOG.md

@@ -1,5 +1,39 @@
+# Changelog
+
+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.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
 ## [Unreleased]
 
-## [0.1.0] - 2026-05-31
+### Added
+
+- Placeholder for future development.
+
+---
+
+## [0.1.0] - 2026-06-01
+
+### Added
+
+- Added initial `pgoutput-decoder` gem structure.
+- Added dependency on `pgoutput-parser`.
+- Added `Pgoutput::Decoder` facade.
+- Added decoded event models for Begin, Commit, Insert, Update, and Delete.
+- Added relation cache for parser Relation messages.
+- Added active transaction tracking using Begin message XID.
+- Added decoded row hash construction from relation columns and tuple values.
+- Added default PostgreSQL OID decoders for common scalar types.
+- Added conservative binary decoding for fixed-width scalar values.
+- Added custom OID decoder support.
+- Added Ractor-shareable decoded event outputs.
+- Added Minitest coverage for registry, value decoding, row building, relation cache, and integration flows.
+- Added RBS signatures.
+- Added README documentation.
+- Added CI and release workflow templates.
+
+---
 
-- Initial release
+[Unreleased]: https://github.com/kanutocd/pgoutput-decoder/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/kanutocd/pgoutput-decoder/releases/tag/v0.1.0

data/lib/pgoutput/decoder/errors.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Base decoder error.
+    class Error < StandardError; end
+
+    # Raised when a DML message references an unknown relation.
+    class UnknownRelationError < Error; end
+
+    # Raised when a message type cannot be decoded.
+    class UnsupportedMessageError < Error; end
+
+    # Raised when a value cannot be decoded for its PostgreSQL OID.
+    class ValueDecodeError < Error; end
+
+    # Raised when DML appears outside an active transaction.
+    class TransactionStateError < Error; end
+  end
+end

data/lib/pgoutput/decoder/events.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Immutable decoded event objects returned by Pgoutput::Decoder.
+    #
+    # These Data classes are intentionally value-oriented and are made shareable
+    # by Pgoutput::Decoder before they are returned to callers.
+    module Events
+      # Decoded transaction begin event class.
+      #
+      # @return [Class]
+      Begin = Data.define(:transaction_id, :final_lsn, :commit_timestamp)
+
+      # Decoded transaction commit event class.
+      #
+      # @return [Class]
+      Commit = Data.define(
+        :transaction_id,
+        :flags,
+        :commit_lsn,
+        :transaction_end_lsn,
+        :commit_timestamp
+      )
+
+      # Decoded insert row-change event class.
+      #
+      # @return [Class]
+      Insert = Data.define(:transaction_id, :relation_id, :schema, :table, :values)
+
+      # Decoded update row-change event class.
+      #
+      # @return [Class]
+      Update = Data.define(
+        :transaction_id,
+        :relation_id,
+        :schema,
+        :table,
+        :old_key,
+        :old_values,
+        :new_values
+      )
+
+      # Decoded delete row-change event class.
+      #
+      # @return [Class]
+      Delete = Data.define(:transaction_id, :relation_id, :schema, :table, :old_key, :old_values)
+    end
+  end
+end

data/lib/pgoutput/decoder/relation_cache.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Mutable per-stream cache of pgoutput-parser Relation messages.
+    #
+    # @api public
+    class RelationCache
+      # @return [void]
+      def initialize
+        @relations = {} # : Hash[Integer, untyped]
+      end
+
+      # Store a relation message.
+      #
+      # @param relation [Pgoutput::Messages::Relation]
+      # @return [Pgoutput::Messages::Relation]
+      def store(relation)
+        @relations[relation.relation_id] = relation
+      end
+
+      # Fetch a relation message by id.
+      #
+      # @param relation_id [Integer]
+      # @return [Pgoutput::Messages::Relation]
+      # @raise [UnknownRelationError]
+      def fetch(relation_id)
+        @relations.fetch(relation_id) do
+          raise UnknownRelationError, "unknown relation id #{relation_id}; decode Relation message first"
+        end
+      end
+    end
+  end
+end

data/lib/pgoutput/decoder/row_builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Builds decoded row hashes from Relation metadata and TupleValue arrays.
+    #
+    # @api public
+    class RowBuilder
+      # @param type_registry [TypeRegistry]
+      # @return [void]
+      def initialize(type_registry: TypeRegistry.default)
+        @value_decoder = ValueDecoder.new(type_registry: type_registry)
+        freeze
+      end
+
+      # Build a decoded row hash.
+      #
+      # @param relation [Pgoutput::Messages::Relation]
+      # @param tuple [Array<Pgoutput::Messages::TupleValue>]
+      # @return [Hash<String, Object>]
+      def build(relation, tuple)
+        row = {}
+
+        tuple.each_with_index do |tuple_value, index|
+          column = relation.columns[index]
+          next unless column
+
+          normalized_value = normalize_oid(tuple_value, column.oid)
+          row[column.name] = @value_decoder.decode(normalized_value)
+        end
+
+        Ractor.make_shareable(row.freeze)
+      end
+
+      private
+
+      def normalize_oid(tuple_value, oid)
+        return tuple_value unless tuple_value.oid.nil?
+
+        Pgoutput::Messages::TupleValue.new(tuple_value.format, tuple_value.raw, oid)
+      end
+    end
+  end
+end

data/lib/pgoutput/decoder/type_registry.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Immutable PostgreSQL OID-to-decoder registry.
+    #
+    # The registry maps PostgreSQL type OIDs to callable decoders. It is
+    # intentionally separate from pgoutput-parser so the parser remains a pure
+    # protocol layer and the decoder owns value conversion policy.
+    #
+    # Registry instances are immutable after construction. Decoded values are
+    # passed through Ractor.make_shareable so caller-visible values can cross
+    # Ractor boundaries safely when Ruby supports the value shape.
+    #
+    # @api public
+    class TypeRegistry
+      # PostgreSQL bool OID.
+      BOOL = 16
+
+      # PostgreSQL int8 / bigint OID.
+      INT8 = 20
+
+      # PostgreSQL int2 / smallint OID.
+      INT2 = 21
+
+      # PostgreSQL int4 / integer OID.
+      INT4 = 23
+
+      # PostgreSQL text OID.
+      TEXT = 25
+
+      # PostgreSQL json OID.
+      JSON = 114
+
+      # PostgreSQL float4 / real OID.
+      FLOAT4 = 700
+
+      # PostgreSQL float8 / double precision OID.
+      FLOAT8 = 701
+
+      # PostgreSQL varchar OID.
+      VARCHAR = 1043
+
+      # PostgreSQL date OID.
+      DATE = 1082
+
+      # PostgreSQL timestamp without time zone OID.
+      TIMESTAMP = 1114
+
+      # PostgreSQL timestamp with time zone OID.
+      TIMESTAMPTZ = 1184
+
+      # PostgreSQL numeric OID.
+      NUMERIC = 1700
+
+      # PostgreSQL uuid OID.
+      UUID = 2950
+
+      # PostgreSQL jsonb OID.
+      JSONB = 3802
+
+      # Return the process-local default immutable registry.
+      #
+      # @return [TypeRegistry] default immutable registry.
+      def self.default
+        @default ||= new(default_decoders)
+      end
+
+      # Build the default OID decoder table.
+      #
+      # @return [Hash<Integer, Proc>] default decoder table.
+      def self.default_decoders
+        {
+          BOOL => ->(raw, format) { decode_bool(raw, format) },
+          INT2 => ->(raw, format) { decode_int(raw, format, 2, "s>") },
+          INT4 => ->(raw, format) { decode_int(raw, format, 4, "l>") },
+          INT8 => ->(raw, format) { decode_int(raw, format, 8, "q>") },
+          TEXT => ->(raw, _format) { raw.dup.freeze },
+          VARCHAR => ->(raw, _format) { raw.dup.freeze },
+          FLOAT4 => ->(raw, format) { decode_float(raw, format, 4, "g") },
+          FLOAT8 => ->(raw, format) { decode_float(raw, format, 8, "G") },
+          NUMERIC => ->(raw, format) { format == :text ? BigDecimal(raw) : raw.dup.freeze },
+          JSON => ->(raw, format) { format == :text ? ::JSON.parse(raw) : raw.dup.freeze },
+          JSONB => ->(raw, format) { decode_jsonb(raw, format) },
+          UUID => ->(raw, format) { format == :text ? raw.dup.freeze : decode_uuid_binary(raw) },
+          DATE => ->(raw, format) { format == :text ? Date.iso8601(raw) : raw.dup.freeze },
+          TIMESTAMP => ->(raw, format) { format == :text ? Time.parse(raw) : raw.dup.freeze },
+          TIMESTAMPTZ => ->(raw, format) { format == :text ? Time.parse(raw) : raw.dup.freeze }
+        }.freeze
+      end
+
+      # Create an immutable registry.
+      #
+      # @param decoders [Hash<Integer, Proc>] decoder table.
+      # @return [void]
+      def initialize(decoders = self.class.default_decoders)
+        @decoders = decoders.dup.freeze
+        freeze
+      end
+
+      # Decode a raw tuple payload.
+      #
+      # @param oid [Integer, nil] PostgreSQL type OID.
+      # @param raw [String, nil] raw payload.
+      # @param format [Symbol] tuple value format.
+      # @return [Object, nil]
+      def decode(oid, raw, format)
+        return nil if raw.nil?
+
+        decoder = @decoders[oid]
+        decoded = decoder ? decoder.call(raw, format) : raw.dup.freeze
+        Ractor.make_shareable(decoded)
+      end
+
+      # Create a new registry with one custom decoder.
+      #
+      # @param oid [Integer] PostgreSQL type OID.
+      # @yieldparam raw [String] raw payload.
+      # @yieldparam format [Symbol] tuple value format.
+      # @yieldreturn [Object]
+      # @return [TypeRegistry]
+      # @raise [ArgumentError] if no block is provided.
+      def with_decoder(oid, &block)
+        raise ArgumentError, "block required" unless block
+
+        self.class.new(@decoders.merge(Integer(oid) => block))
+      end
+
+      class << self
+        private
+
+        def decode_bool(raw, format)
+          return raw == "t" if format == :text
+
+          raw.unpack1("C") == 1
+        end
+
+        def decode_int(raw, format, expected_length, template)
+          return raw.to_i if format == :text
+          return raw.dup.freeze unless raw.bytesize == expected_length
+
+          raw.unpack1(template)
+        end
+
+        def decode_float(raw, format, expected_length, template)
+          return Float(raw) if format == :text
+          return raw.dup.freeze unless raw.bytesize == expected_length
+
+          raw.unpack1(template)
+        end
+
+        def decode_jsonb(raw, format)
+          return ::JSON.parse(raw) if format == :text
+
+          # PostgreSQL binary jsonb starts with a version byte. Version 1 is the
+          # current on-wire format; the remaining bytes contain JSON text.
+          return raw.dup.freeze unless raw.bytesize >= 2 && raw.getbyte(0) == 1
+
+          ::JSON.parse(raw.byteslice(1..))
+        end
+
+        def decode_uuid_binary(raw)
+          return raw.dup.freeze unless raw.bytesize == 16
+
+          hex = raw.unpack1("H*")
+          "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/pgoutput/decoder/value_decoder.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  class Decoder
+    # Decodes one pgoutput-parser TupleValue using a TypeRegistry.
+    #
+    # @api public
+    class ValueDecoder
+      # @param type_registry [TypeRegistry]
+      # @return [void]
+      def initialize(type_registry: TypeRegistry.default)
+        @type_registry = type_registry
+        freeze
+      end
+
+      # Decode one tuple value.
+      #
+      # @param tuple_value [Pgoutput::Messages::TupleValue]
+      # @return [Object, nil, Symbol]
+      def decode(tuple_value)
+        case tuple_value.format
+        when :null
+          nil
+        when :unchanged_toast
+          :unchanged_toast
+        when :text, :binary
+          @type_registry.decode(tuple_value.oid, tuple_value.raw, tuple_value.format)
+        else
+          raise ValueDecodeError, "unsupported tuple value format: #{tuple_value.format.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/pgoutput/decoder/version.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 module Pgoutput
-  module Decoder
-    VERSION = "0.0.0"
+  class Decoder
+    # Gem version.
+    VERSION = "0.1.0"
   end
 end

data/lib/pgoutput/decoder.rb

@@ -1,10 +1,174 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+require "date"
+require "json"
+require "time"
+require "pgoutput"
+
 require_relative "decoder/version"
+require_relative "decoder/errors"
+require_relative "decoder/events"
+require_relative "decoder/type_registry"
+require_relative "decoder/value_decoder"
+require_relative "decoder/relation_cache"
+require_relative "decoder/row_builder"
 
 module Pgoutput
-  module Decoder
-    class Error < StandardError; end
-    # Your code goes here...
+  # Stateful high-level decoder for pgoutput-parser protocol messages.
+  #
+  # Decoder accepts immutable protocol messages from pgoutput-parser and returns
+  # immutable, Ractor-shareable row-change events. The decoder maintains relation
+  # and active transaction context, so one instance should be used per logical
+  # replication stream.
+  #
+  # @api public
+  class Decoder
+    # @return [TypeRegistry]
+    attr_reader :type_registry
+
+    # @param type_registry [TypeRegistry] immutable OID decoder registry.
+    # @return [void]
+    def initialize(type_registry: TypeRegistry.default)
+      @type_registry = type_registry
+      @relations = RelationCache.new
+      @row_builder = RowBuilder.new(type_registry: type_registry)
+      @current_transaction_id = nil
+      @current_final_lsn = nil
+      @current_commit_timestamp = nil
+    end
+
+    # Decode one pgoutput-parser protocol message.
+    #
+    # @param message [Object] protocol message from pgoutput-parser.
+    # @return [Events::Begin, Events::Commit, Events::Insert, Events::Update, Events::Delete, nil]
+    # @raise [UnknownRelationError] if a DML message references an unknown relation.
+    # @raise [TransactionStateError] if DML arrives before Begin.
+    def decode(message)
+      case message
+      when parser_messages::Begin
+        decode_begin(message)
+      when parser_messages::Relation
+        @relations.store(message)
+        nil
+      when parser_messages::Insert
+        decode_insert(message)
+      when parser_messages::Update
+        decode_update(message)
+      when parser_messages::Delete
+        decode_delete(message)
+      when parser_messages::Commit
+        decode_commit(message)
+      else
+        raise UnsupportedMessageError, "unsupported message: #{message.class}"
+      end
+    end
+
+    private
+
+    def decode_begin(message)
+      @current_transaction_id = message.xid
+      @current_final_lsn = message.final_lsn
+      @current_commit_timestamp = message.commit_timestamp
+
+      share(
+        Events::Begin.new(
+          message.xid,
+          message.final_lsn,
+          message.commit_timestamp
+        )
+      )
+    end
+
+    def decode_commit(message)
+      transaction_id = @current_transaction_id
+
+      event = Events::Commit.new(
+        transaction_id,
+        message.flags,
+        message.commit_lsn,
+        message.transaction_end_lsn,
+        message.commit_timestamp
+      )
+
+      clear_transaction!
+      share(event)
+    end
+
+    def decode_insert(message)
+      relation = relation_for(message.relation_id)
+      transaction_id = require_transaction_id
+
+      share(
+        Events::Insert.new(
+          transaction_id,
+          message.relation_id,
+          relation.schema,
+          relation.table,
+          @row_builder.build(relation, message.tuple)
+        )
+      )
+    end
+
+    def decode_update(message)
+      relation = relation_for(message.relation_id)
+      transaction_id = require_transaction_id
+
+      share(
+        Events::Update.new(
+          transaction_id,
+          message.relation_id,
+          relation.schema,
+          relation.table,
+          optional_row(relation, message.old_key_tuple),
+          optional_row(relation, message.old_tuple),
+          @row_builder.build(relation, message.new_tuple)
+        )
+      )
+    end
+
+    def decode_delete(message)
+      relation = relation_for(message.relation_id)
+      transaction_id = require_transaction_id
+
+      share(
+        Events::Delete.new(
+          transaction_id,
+          message.relation_id,
+          relation.schema,
+          relation.table,
+          optional_row(relation, message.old_key_tuple),
+          optional_row(relation, message.old_tuple)
+        )
+      )
+    end
+
+    def optional_row(relation, tuple)
+      return nil if tuple.nil?
+
+      @row_builder.build(relation, tuple)
+    end
+
+    def relation_for(relation_id)
+      @relations.fetch(relation_id)
+    end
+
+    def require_transaction_id
+      @current_transaction_id || raise(TransactionStateError, "DML message received outside an active transaction")
+    end
+
+    def clear_transaction!
+      @current_transaction_id = nil
+      @current_final_lsn = nil
+      @current_commit_timestamp = nil
+    end
+
+    def parser_messages
+      Pgoutput::Messages
+    end
+
+    def share(object)
+      Ractor.make_shareable(object)
+    end
   end
 end

data/lib/pgoutput_decoder.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "pgoutput/decoder"

data/sig/pgoutput_decoder.rbs

@@ -0,0 +1,119 @@
+module Pgoutput
+  class Decoder
+    VERSION: String
+
+    type event =
+      Events::Begin |
+      Events::Commit |
+      Events::Insert |
+      Events::Update |
+      Events::Delete
+
+    def initialize: (?type_registry: TypeRegistry) -> void
+    def decode: (untyped message) -> event?
+    def type_registry: () -> TypeRegistry
+
+    class Error < StandardError
+    end
+
+    class UnknownRelationError < Error
+    end
+
+    class UnsupportedMessageError < Error
+    end
+
+    class ValueDecodeError < Error
+    end
+
+    class TransactionStateError < Error
+    end
+
+    module Events
+      class Begin < Data
+        attr_reader transaction_id: Integer
+        attr_reader final_lsn: Integer
+        attr_reader commit_timestamp: Integer
+        def self.new: (Integer transaction_id, Integer final_lsn, Integer commit_timestamp) -> Begin
+      end
+
+      class Commit < Data
+        attr_reader transaction_id: Integer?
+        attr_reader flags: Integer
+        attr_reader commit_lsn: Integer
+        attr_reader transaction_end_lsn: Integer
+        attr_reader commit_timestamp: Integer
+        def self.new: (Integer? transaction_id, Integer flags, Integer commit_lsn, Integer transaction_end_lsn, Integer commit_timestamp) -> Commit
+      end
+
+      class Insert < Data
+        attr_reader transaction_id: Integer
+        attr_reader relation_id: Integer
+        attr_reader schema: String
+        attr_reader table: String
+        attr_reader values: Hash[String, untyped]
+        def self.new: (Integer transaction_id, Integer relation_id, String schema, String table, Hash[String, untyped] values) -> Insert
+      end
+
+      class Update < Data
+        attr_reader transaction_id: Integer
+        attr_reader relation_id: Integer
+        attr_reader schema: String
+        attr_reader table: String
+        attr_reader old_key: Hash[String, untyped]?
+        attr_reader old_values: Hash[String, untyped]?
+        attr_reader new_values: Hash[String, untyped]
+        def self.new: (Integer transaction_id, Integer relation_id, String schema, String table, Hash[String, untyped]? old_key, Hash[String, untyped]? old_values, Hash[String, untyped] new_values) -> Update
+      end
+
+      class Delete < Data
+        attr_reader transaction_id: Integer
+        attr_reader relation_id: Integer
+        attr_reader schema: String
+        attr_reader table: String
+        attr_reader old_key: Hash[String, untyped]?
+        attr_reader old_values: Hash[String, untyped]?
+        def self.new: (Integer transaction_id, Integer relation_id, String schema, String table, Hash[String, untyped]? old_key, Hash[String, untyped]? old_values) -> Delete
+      end
+    end
+
+    class TypeRegistry
+      BOOL: Integer
+      INT8: Integer
+      INT2: Integer
+      INT4: Integer
+      TEXT: Integer
+      JSON: Integer
+      FLOAT4: Integer
+      FLOAT8: Integer
+      VARCHAR: Integer
+      DATE: Integer
+      TIMESTAMP: Integer
+      TIMESTAMPTZ: Integer
+      NUMERIC: Integer
+      UUID: Integer
+      JSONB: Integer
+
+      def self.default: () -> TypeRegistry
+      def self.default_decoders: () -> Hash[Integer, Proc]
+      def initialize: (?Hash[Integer, Proc] decoders) -> void
+      def decode: (Integer? oid, String? raw, Symbol format) -> untyped?
+      def with_decoder: (Integer oid) { (String raw, Symbol format) -> untyped } -> TypeRegistry
+    end
+
+    class ValueDecoder
+      def initialize: (?type_registry: TypeRegistry) -> void
+      def decode: (untyped tuple_value) -> untyped?
+    end
+
+    class RelationCache
+      def initialize: () -> void
+      def store: (untyped relation) -> untyped
+      def fetch: (Integer relation_id) -> untyped
+    end
+
+    class RowBuilder
+      def initialize: (?type_registry: TypeRegistry) -> void
+      def build: (untyped relation, Array[untyped] tuple) -> Hash[String, untyped]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgoutput-decoder
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -24,33 +24,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: '5.27'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.16.0
+        version: '5.27'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.27'
+        version: 0.16.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.27'
+        version: 0.16.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -133,8 +133,16 @@ files:
 - LICENSE.txt
 - README.md
 - lib/pgoutput/decoder.rb
+- lib/pgoutput/decoder/errors.rb
+- lib/pgoutput/decoder/events.rb
+- lib/pgoutput/decoder/relation_cache.rb
+- lib/pgoutput/decoder/row_builder.rb
+- lib/pgoutput/decoder/type_registry.rb
+- lib/pgoutput/decoder/value_decoder.rb
 - lib/pgoutput/decoder/version.rb
+- lib/pgoutput_decoder.rb
 - sig/pgoutput/decoder.rbs
+- sig/pgoutput_decoder.rbs
 homepage: https://github.com/kanutocd/pgoutput-decoder
 licenses:
 - MIT