pgoutput-source-adapter 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab9b7c87b7ede5dd583ae9457f30fe30fdfcf1dd55b2ca33e08162d23f36601b
-  data.tar.gz: 5c7a7b1a081f8a67a07397ecd8034a462e679e636dd2a51d71b9512e90333c85
+  metadata.gz: 96fa814d19258cf12c3f2d6398f72f21f1a2dfab59e89562b880f26fbb7bf1cd
+  data.tar.gz: 300f6a751391ee90ba84dfdbe743839e605fb6655aafc5057f9b87a1e25c3faf
 SHA512:
-  metadata.gz: 3a19f060ba7f5552dec37471a114fa4ee30f0c960d20a27c82676f888753c53fe76c4473038170185806dda76988217ab882cf90f5186fdfa28d5dfef438c12a
-  data.tar.gz: 00f2d815d0ff8f2d8b9865ecdbee82c528fba3341ecf0125c8f32ddc930365c669bb28ad0cc3c1274c7208089a4eca9ff05bf6d47a9061b234563c92b9c3fd18
+  metadata.gz: 314c92d8ec4d3853056f4c69d99eefb6794aaefbc58a1b5f9e0b2de25c372cce1e8c4864210ade04400d23feb60fc47d68d535c1df901d7ef60a373bc4c735b8
+  data.tar.gz: 88c5f21bc01667b196a1b347e176cca6aa7caa655a058fa1550bdee3bcb3b88c511fd9371225f5a95fe585dac572a219b46a14a7135e956c97ac47fd8466e986

data/CHANGELOG.md

@@ -1,5 +1,47 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-07-17
+
+### Added
+
+- Added `ReplicaIdentityResolver` for schema-aware non-`id` and composite keys,
+  keyed by relation id, schema/table pair, or qualified relation name.
+- Added default extraction from decoded relation key-column metadata when
+  events expose replica-identity columns or flagged relation columns.
+
+### Fixed
+
+- Preserved complete composite and non-`id` old-key tuples for normalized
+  UPDATE and DELETE events.
+- Fail closed when configured replica-key columns are absent instead of
+  emitting an incomplete `ChangeEvent#primary_key`.
+
+### Documentation
+
+- Documented relation metadata, schema-aware resolver configuration, and the
+  legacy `id` compatibility fallback.
+
+## [0.2.0] - 2026-07-17
+
+### Added
+
+- Added incremental `Cdc#each_normalized` transaction normalization for
+  unbounded replication streams.
+- Added `Cdc#stream_event` so source integrations can preserve transport WAL
+  positions without owning transaction buffering.
+
+### Documentation
+
+- Raised and enforced generated YARD API documentation coverage at 100%.
+
+### Quality
+
+- Raised and enforced SimpleCov line and branch coverage at 100%.
+
+## [0.1.1] - 2026-06-16
+
+- Improved gemspec summary and description
+
 ## [0.1.0] - 2026-06-16
 
 ### Added
@@ -31,4 +73,4 @@
 ### Coverage
 
 - Line Coverage: 97.62%
-- Branch Coverage: 91.18%
+- Branch Coverage: 91.18%

data/README.md

@@ -85,20 +85,57 @@ envelope = results.first
 # => CDC::Core::TransactionEnvelope
 ```
 
+Normalize an unbounded replication stream incrementally:
+
+```ruby
+inputs = Enumerator.new do |stream|
+  runner.start do |payload, metadata|
+    decoded = decoder.decode(parser.process(payload))
+    stream << adapter.stream_event(decoded, source_position: metadata.wal_end_lsn)
+  end
+end
+
+adapter.each_normalized(inputs) do |work|
+  processor.process(work)
+end
+```
+
+Transaction buffering belongs to the source adapter. Changes outside a
+transaction are yielded immediately; changes between `Begin` and `Commit` are
+yielded as a `CDC::Core::TransactionEnvelope`. `normalize_many` uses the same
+normalization path for finite batches.
+
 ## Primary keys
 
-For update and delete events, pgoutput may provide an old-key tuple. When it does, that tuple is used as the `CDC::Core::ChangeEvent#primary_key`.
+For update and delete events, pgoutput may provide an old-key tuple. When it
+does, the complete tuple is used as `CDC::Core::ChangeEvent#primary_key`,
+including composite and non-`id` replica keys.
 
-For insert events, or for sources without old-key tuples, the adapter defaults to `id` / `"id"` when present.
+For inserts and events without an old-key tuple, the default resolver uses
+relation key-column metadata when the decoded event exposes
+`replica_identity_columns`, `key_columns`, or a relation whose column flags mark
+replica-key columns. The adapter extracts every declared column and raises
+`Pgoutput::SourceAdapter::Error` rather than returning a partial key.
 
-You can provide your own resolver:
+When decoded events do not carry relation key metadata, configure the reusable
+schema-aware resolver. Relations may be keyed by relation id,
+`[schema, table]`, or a qualified name:
 
 ```ruby
+resolver = Pgoutput::SourceAdapter::ReplicaIdentityResolver.new(
+  ["public", "memberships"] => ["tenant_id", "member_uuid"],
+  "public.accounts" => ["account_uuid"]
+)
+
 adapter = Pgoutput::SourceAdapter::Cdc.new(
-  primary_key_resolver: ->(_event, values) { { "uuid" => values.fetch("uuid") } }
+  primary_key_resolver: resolver
 )
 ```
 
+The legacy `id` / `"id"` inference remains as a compatibility fallback only
+when neither relation metadata nor an explicit resolver is available. Custom
+callables remain supported through `primary_key_resolver:`.
+
 ## Metadata
 
 Each normalized event includes pgoutput metadata:
@@ -124,6 +161,7 @@ adapter = Pgoutput::SourceAdapter::Cdc.new(
 ```ruby
 Pgoutput::SourceAdapter
 Pgoutput::SourceAdapter::Cdc
+Pgoutput::SourceAdapter::ReplicaIdentityResolver
 ```
 
 A compatibility alias is also provided for the generated gem path:
@@ -151,6 +189,10 @@ Those responsibilities belong to `pgoutput-client`, `pgoutput-parser`, `pgoutput
 bundle exec rake
 ```
 
+The default quality task enforces 100% line and branch coverage and 100% YARD
+API documentation coverage. Run `bundle exec yard stats --list-undoc` to inspect
+the documented public API objects.
+
 ## License
 
 [MIT](./LICENSE.txt).

data/Rakefile

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
+require 'open3'
 require 'rake/testtask'
 require 'rubocop/rake_task'
 require 'yard'
@@ -17,6 +18,16 @@ end
 
 YARD::Rake::YardocTask.new(:yard)
 
+desc 'Require complete public API documentation'
+task yard_coverage: :yard do
+  output, status = Open3.capture2e('bundle', 'exec', 'yard', 'stats', '--list-undoc')
+  puts output
+
+  next if status.success? && output.include?('100.00% documented')
+
+  abort 'YARD documentation coverage must remain at 100%'
+end
+
 desc 'Validate rbs sig files'
 task :steep do
   sh 'bundle exec steep check'
@@ -27,4 +38,4 @@ task :coverage do
   sh 'xdg-open coverage/index.html'
 end
 
-task default: %i[test rubocop steep yard]
+task default: %i[test rubocop steep yard_coverage]

data/lib/pgoutput/source/adapter.rb

@@ -2,7 +2,15 @@
 
 require_relative '../source_adapter'
 
+# Root namespace for pgoutput protocol libraries.
+#
+# @api public
 module Pgoutput
+  # Backward-compatible namespace for the original generated gem layout.
+  #
+  # New integrations should use {Pgoutput::SourceAdapter} directly.
+  #
+  # @api public
   module Source
     # Compatibility alias for {Pgoutput::SourceAdapter}.
     #

data/lib/pgoutput/source_adapter/cdc.rb

@@ -2,12 +2,20 @@
 
 require 'cdc/core'
 
-unless CDC::Core.const_defined?(:SourceAdapter)
-  raise LoadError, 'pgoutput-source-adapter requires a cdc-core version that defines CDC::Core::SourceAdapter'
-end
-
 module Pgoutput
   module SourceAdapter
+    # Resolves the required cdc-core adapter contract.
+    #
+    # @api private
+    def self.ensure_core_source_adapter!(core)
+      return if core.const_defined?(:SourceAdapter)
+
+      raise LoadError, 'pgoutput-source-adapter requires a cdc-core version that defines CDC::Core::SourceAdapter'
+    end
+    private_class_method :ensure_core_source_adapter!
+
+    ensure_core_source_adapter!(CDC::Core)
+
     # Normalizes Pgoutput::Decoder::Events into CDC::Core primitives.
     #
     # This adapter is intentionally located under the Pgoutput namespace because
@@ -22,10 +30,40 @@ module Pgoutput
     # @example Normalize a decoded transaction event batch
     #   envelope = adapter.normalize_many([begin_event, insert_event, commit_event]).first
     #
+    # @example Normalize an unbounded decoded event stream
+    #   adapter.each_normalized(decoded_events) { |work| process(work) }
+    #
     # @api public
+    # rubocop:disable Metrics/ClassLength
     class Cdc < CDC::Core::SourceAdapter
+      # Canonical source name included in normalized event metadata.
+      #
+      # @return [String]
       SOURCE_NAME = 'pgoutput'
 
+      # A decoded event paired with its transport-level source position.
+      #
+      # Source integrations use this value object to preserve WAL position
+      # metadata without teaching downstream applications about pgoutput
+      # transaction boundaries.
+      #
+      # @api public
+      class StreamEvent
+        # @return [Object] decoded pgoutput event
+        attr_reader :event
+        # @return [String, nil] transport WAL position
+        attr_reader :source_position
+
+        # @param event [Object] decoded pgoutput event
+        # @param source_position [String, nil] transport WAL position
+        # @return [void]
+        def initialize(event, source_position)
+          @event = event
+          @source_position = source_position
+          freeze
+        end
+      end
+
       # @param primary_key_resolver [#call, nil] optional callable used to infer
       #   primary keys from decoded row values when pgoutput does not provide an
       #   old-key tuple. The callable receives the decoded event and value hash.
@@ -50,7 +88,7 @@ module Pgoutput
       # @raise [Pgoutput::SourceAdapter::Error] when the decoded event type is
       #   unsupported.
       # rubocop:disable Metrics/MethodLength
-      def normalize(event)
+      def normalize(event, source_position: nil)
         case event_name(event)
         when 'Insert'
           change_event(
@@ -58,7 +96,8 @@ module Pgoutput
             operation: :insert,
             old_values: nil,
             new_values: event.values,
-            primary_key: primary_key_for(event, event.values)
+            primary_key: primary_key_for(event, event.values),
+            source_position: source_position
           )
         when 'Update'
           old_values = event.old_values || event.old_key
@@ -68,7 +107,8 @@ module Pgoutput
             operation: :update,
             old_values: old_values,
             new_values: event.new_values,
-            primary_key: primary_key_for(event, event.new_values)
+            primary_key: primary_key_for(event, event.new_values),
+            source_position: source_position
           )
         when 'Delete'
           old_values = event.old_values || event.old_key
@@ -78,7 +118,8 @@ module Pgoutput
             operation: :delete,
             old_values: old_values,
             new_values: nil,
-            primary_key: primary_key_for(event, old_values)
+            primary_key: primary_key_for(event, old_values),
+            source_position: source_position
           )
         when 'Begin', 'Commit'
           nil
@@ -88,6 +129,31 @@ module Pgoutput
       end
       # rubocop:enable Metrics/MethodLength
 
+      # Pair a decoded event with the source position supplied by its transport.
+      #
+      # @param event [Object] decoded pgoutput event
+      # @param source_position [Object, nil] WAL position associated with the event
+      # @return [StreamEvent] immutable streaming input
+      def stream_event(event, source_position: nil)
+        StreamEvent.new(event, lsn_string(source_position))
+      end
+
+      # Incrementally normalize a decoded pgoutput event stream.
+      #
+      # Transaction buffering belongs to this source adapter: row changes are
+      # retained after Begin and emitted as one CDC::Core::TransactionEnvelope
+      # at Commit. Changes outside a transaction are yielded immediately.
+      #
+      # @param events [Enumerable<Object, StreamEvent>] decoded stream
+      # @yieldparam work [CDC::Core::ChangeEvent, CDC::Core::TransactionEnvelope]
+      # @return [Enumerator, nil] enumerator without a block, otherwise nil
+      def each_normalized(events, &block)
+        return enum_for(:each_normalized, events) unless block
+
+        normalize_stream(events, flush_incomplete: false, &block)
+        nil
+      end
+
       # Normalize a sequence of decoded pgoutput events.
       #
       # If the sequence contains transaction boundaries, row changes between a
@@ -99,17 +165,28 @@ module Pgoutput
       #   normalized row changes and transaction envelopes in input order.
       # @raise [Pgoutput::SourceAdapter::Error] when any decoded event type is
       #   unsupported.
+      def normalize_many(events)
+        results = [] # : Array[CDC::Core::ChangeEvent | CDC::Core::TransactionEnvelope]
+        normalize_stream(events, flush_incomplete: true) { |work| results << work }
+        share(results.freeze)
+      end
+
+      private
+
+      attr_reader :primary_key_resolver, :metadata_builder
+
       # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/PerceivedComplexity
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/MethodLength
-      def normalize_many(events)
-        results = [] # : Array[CDC::Core::ChangeEvent | CDC::Core::TransactionEnvelope]
+      def normalize_stream(events, flush_incomplete:, &block)
         transaction_id = nil
         transaction_events = [] # : Array[CDC::Core::ChangeEvent]
         transaction_metadata = {} # : Hash[String, untyped]
 
-        events.each do |event|
+        # rubocop:disable Metrics/BlockLength
+        events.each do |input|
+          event, source_position = stream_input(input)
           case event_name(event)
           when 'Begin'
             transaction_id = event.transaction_id
@@ -120,11 +197,14 @@ module Pgoutput
             )
           when 'Commit'
             if transaction_id || !transaction_events.empty?
-              results << transaction_envelope(
-                event,
-                transaction_id: transaction_id || event.transaction_id,
-                events: transaction_events,
-                metadata: transaction_metadata
+              block.call(
+                transaction_envelope(
+                  event,
+                  transaction_id: transaction_id || event.transaction_id,
+                  events: transaction_events,
+                  metadata: transaction_metadata,
+                  source_position: source_position
+                )
               )
             end
 
@@ -132,30 +212,26 @@ module Pgoutput
             transaction_events = []
             transaction_metadata = {}
           else
-            normalized = normalize(event)
+            normalized = normalize(event, source_position: source_position)
             next if normalized.nil?
 
             if transaction_id
               transaction_events << normalized
             else
-              results << normalized
+              block.call(normalized)
             end
           end
         end
+        # rubocop:enable Metrics/BlockLength
 
-        results.concat(transaction_events) if transaction_id && !transaction_events.empty?
-        share(results.freeze)
+        transaction_events.each(&block) if flush_incomplete && transaction_id && !transaction_events.empty?
       end
       # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/PerceivedComplexity
       # rubocop:enable Metrics/CyclomaticComplexity
       # rubocop:enable Metrics/MethodLength
 
-      private
-
-      attr_reader :primary_key_resolver, :metadata_builder
-
-      def change_event(event, operation:, old_values:, new_values:, primary_key:)
+      def change_event(event, operation:, old_values:, new_values:, primary_key:, source_position:)
         share(
           CDC::Core::ChangeEvent.new(
             operation: operation,
@@ -165,17 +241,18 @@ module Pgoutput
             new_values: new_values,
             primary_key: primary_key,
             transaction_id: event.transaction_id,
+            commit_lsn: lsn_string(source_position),
             metadata: metadata_for(event)
           )
         )
       end
 
-      def transaction_envelope(event, transaction_id:, events:, metadata:)
+      def transaction_envelope(event, transaction_id:, events:, metadata:, source_position: nil)
         share(
           CDC::Core::TransactionEnvelope.new(
             transaction_id: transaction_id,
             events: events.freeze,
-            commit_lsn: lsn_string(event.commit_lsn),
+            commit_lsn: lsn_string(event.commit_lsn || source_position),
             committed_at: event.commit_timestamp,
             metadata: metadata.merge(metadata_for(event)).merge(
               'commit_flags' => event.flags,
@@ -191,7 +268,15 @@ module Pgoutput
         primary_key_resolver.call(event, values)
       end
 
-      def default_primary_key(_event, values)
+      def stream_input(input)
+        return [input.event, input.source_position] if input.is_a?(StreamEvent)
+
+        [input, nil]
+      end
+
+      def default_primary_key(event, values)
+        key_columns = replica_identity_columns_for(event)
+        return key_from_columns(event, values, key_columns) unless key_columns.nil?
         return nil unless values.respond_to?(:key?)
 
         if values.key?('id')
@@ -201,6 +286,27 @@ module Pgoutput
         end
       end
 
+      def replica_identity_columns_for(event)
+        return normalize_key_columns(event.replica_identity_columns) if event.respond_to?(:replica_identity_columns)
+        return normalize_key_columns(event.key_columns) if event.respond_to?(:key_columns)
+        return unless event.respond_to?(:relation) && event.relation.respond_to?(:columns)
+
+        normalize_key_columns(
+          event.relation.columns.select { |column| column.flags.allbits?(1) }.map(&:name)
+        )
+      end
+
+      def normalize_key_columns(columns)
+        column_list = Array(columns) # : Array[untyped]
+        column_list.map(&:to_s)
+      end
+
+      def key_from_columns(event, values, columns)
+        return nil if columns.empty?
+
+        ReplicaIdentityResolver.extract(event, values, columns)
+      end
+
       def metadata_for(event)
         metadata = {
           'source' => SOURCE_NAME,
@@ -232,11 +338,12 @@ module Pgoutput
         hash.compact
       end
 
-      def share(object)
-        Ractor.make_shareable(object)
+      def share(object, ractor: Ractor)
+        ractor.make_shareable(object)
       rescue Ractor::Error
         object
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/pgoutput/source_adapter/replica_identity_resolver.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Pgoutput
+  module SourceAdapter
+    # Resolves schema-aware replica keys from decoded row values.
+    #
+    # Relations may be keyed by pgoutput relation id, `[schema, table]`, or a
+    # `"schema.table"` string. Each value is the ordered list of replica-key
+    # columns. Relation-id mappings take precedence because they identify the
+    # exact relation metadata seen by the replication stream.
+    #
+    # @example Resolve a composite key
+    #   resolver = ReplicaIdentityResolver.new(
+    #     ["public", "memberships"] => ["tenant_id", "member_uuid"]
+    #   )
+    #
+    # @api public
+    class ReplicaIdentityResolver
+      # Normalized relation keys mapped to ordered replica-identity columns.
+      #
+      # @return [Hash]
+      attr_reader :relations
+
+      # Extract a complete replica key from an ordered column list.
+      #
+      # @param event [Object] decoded row event with schema/table metadata
+      # @param values [Hash, nil] decoded row values
+      # @param columns [Array<String>] ordered replica-key column names
+      # @return [Hash{String=>Object}] complete replica key
+      # @raise [Error] when values or any configured column are unavailable
+      def self.extract(event, values, columns)
+        unless values.respond_to?(:key?)
+          raise Error, "replica identity values are unavailable for #{qualified_name(event)}"
+        end
+
+        columns.to_h do |column|
+          [column, fetch_column(event, values, column)]
+        end
+      end
+
+      # @param relations [Hash{Integer, Array<String>, Array<String>=>Array<String>}]
+      #   relation identity to ordered replica-key column names
+      # @return [void]
+      def initialize(relations)
+        @relations = relations.to_h.transform_values { |columns| normalize_columns(columns) }.freeze
+        freeze
+      end
+
+      # Extract the configured replica key for a decoded row event.
+      #
+      # @param event [Object] decoded row event with relation/schema/table metadata
+      # @param values [Hash, nil] decoded row values
+      # @return [Hash{String=>Object}, nil] complete replica key, or `nil` when
+      #   the relation is not configured
+      # @raise [Error] when a configured key column is absent from row values
+      def call(event, values)
+        columns = columns_for(event)
+        return nil unless columns
+
+        self.class.extract(event, values, columns)
+      end
+
+      def self.fetch_column(event, values, column)
+        return values[column] if values.key?(column)
+
+        symbol = column.to_sym
+        return values[symbol] if values.key?(symbol)
+
+        raise Error, "replica identity column #{column.inspect} is missing from #{qualified_name(event)} values"
+      end
+      private_class_method :fetch_column
+
+      def self.qualified_name(event)
+        [event.schema, event.table].compact.join('.')
+      end
+      private_class_method :qualified_name
+
+      private
+
+      def normalize_columns(columns)
+        column_list = Array(columns) # : Array[untyped]
+        names = column_list.map(&:to_s)
+        raise ArgumentError, 'replica identity columns must not be empty' if names.empty?
+        raise ArgumentError, 'replica identity columns must be unique' unless names.uniq.length == names.length
+
+        names.freeze
+      end
+
+      def columns_for(event)
+        relation_id = event.relation_id if event.respond_to?(:relation_id)
+        return relations[relation_id] if relation_id && relations.key?(relation_id)
+
+        schema = event.schema
+        table = event.table
+        relations[[schema.to_s, table.to_s]] || relations["#{schema}.#{table}"]
+      end
+    end
+  end
+end

data/lib/pgoutput/source_adapter/version.rb

@@ -5,6 +5,6 @@ module Pgoutput
     # Current pgoutput-source-adapter gem version.
     #
     # @return [String] semantic version published to RubyGems.
-    VERSION = '0.1.1'
+    VERSION = '0.3.0'
   end
 end

data/lib/pgoutput/source_adapter.rb

@@ -24,4 +24,5 @@ module Pgoutput
   end
 end
 
+require_relative 'source_adapter/replica_identity_resolver'
 require_relative 'source_adapter/cdc'

data/sig/pgoutput/source_adapter/cdc.rbs

@@ -1,5 +1,7 @@
 module Pgoutput
   module SourceAdapter
+    def self.ensure_core_source_adapter!: (untyped core) -> nil
+
     # Normalizes Pgoutput::Decoder::Events into CDC::Core primitives.
     #
     # This adapter is intentionally located under the Pgoutput namespace because
@@ -22,6 +24,13 @@ module Pgoutput
 
       SOURCE_NAME: "pgoutput"
 
+      class StreamEvent
+        attr_reader event: untyped
+        attr_reader source_position: untyped
+
+        def initialize: (untyped event, untyped source_position) -> void
+      end
+
       # @param primary_key_resolver [#call, nil] optional callable used to infer
       #   primary keys from decoded row values when pgoutput does not provide an
       #   old-key tuple.
@@ -37,7 +46,13 @@ module Pgoutput
       #
       # @param event [Object] a Pgoutput::Decoder::Events object.
       # @return [CDC::Core::ChangeEvent, nil]
-      def normalize: (untyped event) -> untyped
+      def normalize: (untyped event, ?source_position: untyped) -> untyped
+
+      # Pair a decoded event with its transport-level source position.
+      def stream_event: (untyped event, ?source_position: untyped) -> StreamEvent
+
+      # Incrementally normalize an unbounded decoded event stream.
+      def each_normalized: (untyped events) ?{ (untyped work) -> untyped } -> (Enumerator[untyped, nil] | nil)
 
       # Normalize a sequence of decoded pgoutput events.
       #
@@ -55,13 +70,23 @@ module Pgoutput
 
       attr_reader metadata_builder: untyped
 
-      def change_event: (untyped event, operation: untyped, old_values: untyped, new_values: untyped, primary_key: untyped) -> untyped
+      def normalize_stream: (untyped events, flush_incomplete: bool) { (untyped work) -> untyped } -> void
 
-      def transaction_envelope: (untyped event, transaction_id: untyped, events: untyped, metadata: untyped) -> untyped
+      def change_event: (untyped event, operation: untyped, old_values: untyped, new_values: untyped, primary_key: untyped, source_position: untyped) -> untyped
+
+      def transaction_envelope: (untyped event, transaction_id: untyped, events: untyped, metadata: untyped, ?source_position: untyped) -> untyped
 
       def primary_key_for: (untyped event, untyped values) -> untyped
 
-      def default_primary_key: (untyped _event, untyped values) -> (nil | untyped)
+      def stream_input: (untyped input) -> [untyped, untyped]
+
+      def default_primary_key: (untyped event, untyped values) -> (nil | untyped)
+
+      def replica_identity_columns_for: (untyped event) -> untyped
+
+      def normalize_key_columns: (untyped columns) -> Array[String]
+
+      def key_from_columns: (untyped event, untyped values, Array[String] columns) -> untyped
 
       def metadata_for: (untyped event) -> untyped
 

data/sig/pgoutput/source_adapter/replica_identity_resolver.rbs

@@ -0,0 +1,20 @@
+module Pgoutput
+  module SourceAdapter
+    class ReplicaIdentityResolver
+      @relations: untyped
+
+      attr_reader relations: untyped
+
+      def self.extract: (untyped event, untyped values, Array[String] columns) -> Hash[String, untyped]
+      def initialize: (untyped relations) -> void
+      def call: (untyped event, untyped values) -> untyped
+
+      private
+
+      def self.fetch_column: (untyped event, untyped values, String column) -> untyped
+      def self.qualified_name: (untyped event) -> String
+      def normalize_columns: (untyped columns) -> Array[String]
+      def columns_for: (untyped event) -> untyped
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgoutput-source-adapter
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -64,11 +64,13 @@ files:
 - lib/pgoutput/source/adapter.rb
 - lib/pgoutput/source_adapter.rb
 - lib/pgoutput/source_adapter/cdc.rb
+- lib/pgoutput/source_adapter/replica_identity_resolver.rb
 - lib/pgoutput/source_adapter/version.rb
 - mise.toml
 - sig/pgoutput/source/adapter.rbs
 - sig/pgoutput/source_adapter.rbs
 - sig/pgoutput/source_adapter/cdc.rbs
+- sig/pgoutput/source_adapter/replica_identity_resolver.rbs
 - sig/pgoutput/source_adapter/version.rbs
 homepage: https://github.com/kanutocd/pgoutput-source-adapter
 licenses: