pgoutput-decoder 0.0.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ef596cb600c9565a1d4088f34af0877c1dc135bf23e785800ba79cfabb4bc23
-  data.tar.gz: d64785d16df4da805dcb358c8193b70e360e4fc07d7afe2e676f4248c1588cb1
+  metadata.gz: a1a32b04410b404b4eb936eac7e3cae1548830c13cdbe7a1eb5e1604fb2bdabe
+  data.tar.gz: b14c651c88ea56ef70b9674def89cfd774de17c1efaf9894544e6d5212061045
 SHA512:
-  metadata.gz: eb5c9be51c3ca6cf6a575f3ef2f8c6eca2e32730a9804f590576c0d53f2daa8e184af4d92c3131e4f3d370b793bd1373fe8e722a6d266f7e02072aa18c666bc0
-  data.tar.gz: 669771765199e459020de5a22b87a3d70d4927b1fd5a7a7d59e9159f7944c32304c619920dcd4550711630d143ff20b1444e5ff1ee2d3b8e4b4ec5f19ecf9177
+  metadata.gz: aa2a36f348bab0d37668e40909acefc4b101e38a8ee990ef217848087eaaa5b3473741e33238a5fff6106e660138a946451f42ba9db25ca069ee49117cc72973
+  data.tar.gz: a965ef38835a5134b0ebd7f9a5eca4a54bf3786421f8365fc9110907088b797a7d2d8e86b14d2321ed37af4633df1f03ccf68b317d9209a0b43d94adc64606ee

data/CHANGELOG.md

@@ -1,5 +1,49 @@
+# Changelog
+
 ## [Unreleased]
 
-## [0.1.0] - 2026-05-31
+## 0.1.1 - 2026-06-17
+
+### Fixed
+
+* Curated RBS signatures shipped with the gem.
+* Fixed duplicate `Pgoutput::Decoder` type declarations that caused Steep/RBS environment loading failures.
+* Corrected decoder type signatures to align with actual runtime behavior.
+* Improved `TypeRegistry` type annotations and value narrowing.
+* Fixed Steep type-checking issues around decoder lookup, JSON decoding, UUID decoding, and numeric value decoding.
+* Added missing standard library type dependencies required by Steep.
+* Improved compatibility with downstream consumers using:
+
+  * `library "pgoutput-decoder"`
+  * `bundle exec steep check`
+
+### Documentation
+
+* Refined shipped type definitions to better reflect the public API surface.
+
+### Internal
+
+* No runtime behavior changes.
+* No protocol decoding changes.
+* No public API changes.
+* This release focuses on RBS, Steep, and developer tooling correctness.
+
+## [0.1.0] - 2026-06-01
+
+### Added
 
-- Initial release
+- 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.

data/README.md

@@ -1,5 +1,10 @@
 # pgoutput-decoder
 
+[![Gem Version](https://badge.fury.io/rb/pgoutput-decoder.svg)](https://badge.fury.io/rb/pgoutput-decoder)
+[![CI](https://github.com/kanutocd/pgoutput-decoder/workflows/CI/badge.svg)](https://github.com/kanutocd/pgoutput-decoder/actions)
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.4-ruby.svg)](https://www.ruby-lang.org/en/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 A high-level PostgreSQL `pgoutput` logical replication value decoder for Ruby.
 
 `pgoutput-decoder` is the companion layer to [`pgoutput-parser`](https://rubygems.org/gems/pgoutput-parser). It accepts immutable protocol messages produced by `pgoutput-parser` and turns tuple payloads into application-friendly Ruby row-change events.
@@ -275,4 +280,4 @@ bundle exec steep check
 
 ## License
 
-MIT.
+[MIT](LICENSE.txt).

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 = {} # : Hash[String, untyped]
+
+        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 ? Kernel.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 = oid ? @decoders[oid] : nil
+        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
+
+          Integer(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
+
+          Float(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..).to_s)
+        end
+
+        def decode_uuid_binary(raw)
+          return raw.dup.freeze unless raw.bytesize == 16
+
+          hex = raw.unpack1("H*").to_s
+          "#{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.1"
   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,165 @@
+module Pgoutput
+  class Decoder
+    VERSION: String
+
+    type parser_message = untyped
+    type relation = untyped
+    type tuple = Array[untyped]
+    type event =
+      Events::Begin |
+      Events::Commit |
+      Events::Insert |
+      Events::Update |
+      Events::Delete
+
+    @type_registry: TypeRegistry
+    @relations: RelationCache
+    @row_builder: RowBuilder
+    @current_transaction_id: Integer?
+    @current_final_lsn: Integer?
+    @current_commit_timestamp: Integer?
+
+    def initialize: (?type_registry: TypeRegistry) -> void
+    def decode: (parser_message message) -> event?
+    def type_registry: () -> TypeRegistry
+
+    private
+
+    def decode_begin: (parser_message message) -> Events::Begin
+    def decode_commit: (parser_message message) -> Events::Commit
+    def decode_insert: (parser_message message) -> Events::Insert
+    def decode_update: (parser_message message) -> Events::Update
+    def decode_delete: (parser_message message) -> Events::Delete
+    def optional_row: (relation relation, tuple? tuple) -> Hash[String, untyped]?
+    def relation_for: (Integer relation_id) -> relation
+    def require_transaction_id: () -> Integer
+    def clear_transaction!: () -> nil
+    def parser_messages: () -> untyped
+    def share: [T] (T object) -> T
+
+    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
+
+      type decoder = ^(String raw, Symbol format) -> untyped
+
+      @decoders: Hash[Integer, decoder]
+
+      def self.default: () -> TypeRegistry
+      def self.default_decoders: () -> Hash[Integer, decoder]
+      def initialize: (?Hash[Integer, decoder] decoders) -> void
+      def decode: (Integer? oid, String? raw, Symbol format) -> untyped?
+      def with_decoder: (Integer oid) { (String raw, Symbol format) -> untyped } -> TypeRegistry
+
+      private
+
+      def self.decode_bool: (String raw, Symbol format) -> bool
+      def self.decode_int: (String raw, Symbol format, Integer expected_length, String template) -> (Integer | String)
+      def self.decode_float: (String raw, Symbol format, Integer expected_length, String template) -> (Float | String)
+      def self.decode_jsonb: (String raw, Symbol format) -> untyped
+      def self.decode_uuid_binary: (String raw) -> String
+    end
+
+    class ValueDecoder
+      @type_registry: TypeRegistry
+
+      def initialize: (?type_registry: TypeRegistry) -> void
+      def decode: (untyped tuple_value) -> untyped?
+    end
+
+    class RelationCache
+      @relations: Hash[Integer, relation]
+
+      def initialize: () -> void
+      def store: (relation relation) -> relation
+      def fetch: (Integer relation_id) -> relation
+    end
+
+    class RowBuilder
+      @value_decoder: ValueDecoder
+
+      def initialize: (?type_registry: TypeRegistry) -> void
+      def build: (relation relation, tuple tuple) -> Hash[String, untyped]
+
+      private
+
+      def normalize_oid: (untyped tuple_value, Integer oid) -> 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.1
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -10,117 +10,33 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pgoutput-parser
+  name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.16.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.16.0
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.27'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.27'
+        version: '4.1'
 - !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.4'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.87'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.87'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.22.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.22.0
-- !ruby/object:Gem::Dependency
-  name: steep
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-- !ruby/object:Gem::Dependency
-  name: yard
+  name: pgoutput-parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.44
-  type: :development
+        version: '0.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.44
+        version: '0.1'
 description: Decodes pgoutput-parser protocol messages into immutable Ruby row-change
   events.
 email:
@@ -133,8 +49,15 @@ 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
-- sig/pgoutput/decoder.rbs
+- lib/pgoutput_decoder.rb
+- sig/pgoutput_decoder.rbs
 homepage: https://github.com/kanutocd/pgoutput-decoder
 licenses:
 - MIT

data/sig/pgoutput/decoder.rbs

@@ -1,6 +0,0 @@
-module Pgoutput
-  module Decoder
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-  end
-end