wal 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3df0dd993bf343f90d54d4b60f52504ca2a84d4fd839c5c952e6f866b40a46cd
-  data.tar.gz: 8e8b568f3a26ed687e9010bd9c69ea4a656e6af59be20449a9142b61c61fe4ad
+  metadata.gz: 15525cced6fec830b09643dfa43d867090a7393a41575cf463445d4b89a664f8
+  data.tar.gz: ea86cbc0117bb0c180021cb618975ceb11df8827ca651f2626dfd2b09e9cda34
 SHA512:
-  metadata.gz: '09591c7506a7b29d9261574f9a512f120862b58d08ae71d31501147076bbae7f9ab65c9c0ded4fe3c15ddfaa9ec1881ebebf934069c08847d8b486d4fcdfc6f7'
-  data.tar.gz: c09c1417b8021fde2890f9dd38d32cec9e64e9fec6d1341613b2a8c4522edd60c0ae34e78fdee3c45e8257c6be66d480fb8ad5f3d52fcec5fb0955d79c054a63
+  metadata.gz: 70d0acc4046bc00f58e29f2e943cba4dd86e0aa4e7303f6cbe9c57a80fc579023194f58c11e4ee42f6f9622baf69f797babf38eb942e814697b820b380ea81d3
+  data.tar.gz: 07b6d3496f3cc1e1c65b0880e91c84bdbd14ca1cfcbc667735f16fcce275fa8a2d148d08390736a6428d1b9b3d50a121764ffa1f4360c8b2ba348b33b6e684e9

data/exe/wal

@@ -5,16 +5,19 @@ require "docopt"
 begin
   cli = Docopt.docopt(<<~DOCOPT)
     Usage:
-      wal watch --watcher <watcher-class> (--slot <replication-slot> | --tmp-slot) [--publication=<publication>...] [--with-timings]
+      wal watch --watcher <watcher-class>
+        (--slot <replication-slot> | --tmp-slot)
+        [--publication=<publication>...]
+        [--replicator <replicator-class>]
       wal start <config-file>
 
     Options:
-      -h --help                         Show this screen.
-      --watcher=<watcher-class>         The watcher class to be used to listen for WAL changes.
-      --slot=<replication-slot>         The replication slot that will be used.
-      --tmp-slot                        Use a temporary replication slot.
-      [--publication=<publication>...]  Force using the informed Postgres publications.
-      [--with-timings]                  Add timing logs to the output.
+      -h --help                          Show this screen.
+      --watcher=<watcher-class>          The watcher class to be used to listen for WAL changes.
+      --slot=<replication-slot>          The replication slot that will be used.
+      --tmp-slot                         Use a temporary replication slot.
+      [--publication=<publication>...]   Force using the informed Postgres publications.
+      [--replicator=<replicatior_class>] Change the replication driver class
   DOCOPT
 rescue Docopt::Exit => err
   puts err.message
@@ -23,31 +26,32 @@ end
 
 require "./config/environment"
 
+db_config = ActiveRecord::Base.configurations.configs_for(name: "primary").configuration_hash
+
 if cli["watch"]
   watcher = cli["--watcher"].constantize.new
-  watcher = Wal::MonitoringWatcher.new(watcher) if cli["--with-timings"]
-
   use_temporary_slot = cli["--tmp-slot"] || false
   replication_slot = cli["--slot"]
   replication_slot = replication_slot.presence || "wal_watcher_#{SecureRandom.alphanumeric(4)}" if use_temporary_slot
+  replicator = cli["--replicator"]&.constantize || Wal::Replicator
 
-  Wal::Replicator
-    .new(replication_slot:, use_temporary_slot:)
+  replicator
+    .new(replication_slot:, use_temporary_slot:, db_config:)
     .replicate_forever(watcher, publications: cli["--publication"])
 
 elsif cli["start"]
   workers = YAML.load_file(cli["<config-file>"])["slots"].map do |slot, config|
     watcher = config["watcher"].constantize.new
-    watcher = Wal::MonitoringWatcher.new(watcher) if config["log_execution_time"]
     temporary = config["temporary"] || false
     publications = config["publications"] || []
+    replicator = config["replicator"]&.constantize || Wal::Replicator
 
     Thread.new(slot, watcher, temporary, publications) do |replication_slot, watcher, use_temporary_slot, publications|
       replication_slot = "#{replication_slot}_#{SecureRandom.alphanumeric(4)}" if use_temporary_slot
       puts "Watcher started for #{replication_slot} slot (#{publications.join(", ")})"
 
-      Wal::Replicator
-        .new(replication_slot:, use_temporary_slot:)
+      replicator
+        .new(replication_slot:, use_temporary_slot:, db_config:)
         .replicate_forever(watcher, publications:)
 
       puts "Watcher finished for #{replication_slot}"

data/lib/wal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wal
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/rbi/wal.rbi

@@ -103,7 +103,7 @@ module Wal
     include Wal::Watcher
     extend T::Sig
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::Event).void }
     def on_event(event); end
   end
 
@@ -113,21 +113,21 @@ module Wal
     include Wal::Watcher
     extend T::Sig
     extend T::Helpers
-    RecordEvent = T.type_alias { T.any(InsertEvent, UpdateEvent, DeleteEvent) }
+    RecordEvent = T.type_alias { T.any(Wal::InsertEvent, Wal::UpdateEvent, Wal::DeleteEvent) }
 
     sig { params(subclass: T.untyped).returns(T.untyped) }
     def self.inherited(subclass); end
 
-    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: InsertEvent).void).void }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: Wal::InsertEvent).void).void }
     def self.on_insert(table, &block); end
 
-    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: UpdateEvent).void).void }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: Wal::UpdateEvent).void).void }
     def self.on_update(table, changed: nil, &block); end
 
-    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: T.any(InsertEvent, UpdateEvent)).void).void }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), changed: T.nilable(T::Array[T.any(String, Symbol)]), block: T.proc.bind(T.attached_class).params(event: T.any(Wal::InsertEvent, Wal::UpdateEvent)).void).void }
     def self.on_save(table, changed: nil, &block); end
 
-    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: DeleteEvent).void).void }
+    sig { params(table: T.any(String, T.class_of(::ActiveRecord::Base)), block: T.proc.bind(T.attached_class).params(event: Wal::DeleteEvent).void).void }
     def self.on_destroy(table, &block); end
 
     sig { params(event: RecordEvent).void }
@@ -136,10 +136,10 @@ module Wal
     sig { params(table: String).returns(T::Boolean) }
     def should_watch_table?(table); end
 
-    sig { params(event: BeginTransactionEvent).returns(Symbol) }
+    sig { params(event: Wal::BeginTransactionEvent).returns(Symbol) }
     def aggregation_strategy(event); end
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::Event).void }
     def on_event(event); end
   end
 
@@ -150,10 +150,10 @@ module Wal
     sig { params(replication_slot: String, use_temporary_slot: T::Boolean, db_config: T::Hash[Symbol, T.untyped]).void }
     def initialize(replication_slot:, use_temporary_slot: false, db_config: ActiveRecord::Base.configurations.configs_for(name: "primary").configuration_hash); end
 
-    sig { params(watcher: Watcher, publications: T::Array[String]).void }
+    sig { params(watcher: Wal::Watcher, publications: T::Array[String]).void }
     def replicate_forever(watcher, publications:); end
 
-    sig { params(watcher: Watcher, publications: T::Array[String]).returns(T::Enumerator::Lazy[Event]) }
+    sig { params(watcher: Wal::Watcher, publications: T::Array[String]).returns(T::Enumerator::Lazy[Wal::Event]) }
     def replicate(watcher, publications:); end
   end
 
@@ -164,24 +164,23 @@ module Wal
     extend T::Sig
     extend T::Helpers
 
-    sig { abstract.params(events: T::Enumerator[Event]).void }
+    sig { abstract.params(events: T::Enumerator[Wal::Event]).void }
     def on_transaction_events(events); end
 
-    sig { params(event: BeginTransactionEvent).returns(Integer) }
+    sig { params(event: Wal::BeginTransactionEvent).returns(Integer) }
     def queue_size(event); end
 
-    sig { override.params(event: Event).void }
+    sig { override.params(event: Wal::Event).void }
     def on_event(event); end
   end
 
   module Watcher
     abstract!
 
-    include Wal
     extend T::Sig
     extend T::Helpers
 
-    sig { abstract.params(event: Event).void }
+    sig { abstract.params(event: Wal::Event).void }
     def on_event(event); end
 
     sig { params(table: String).returns(T::Boolean) }
@@ -193,22 +192,22 @@ module Wal
     module SeparatedEvents
       extend T::Sig
 
-      sig { params(event: Event).void }
+      sig { params(event: Wal::Event).void }
       def on_event(event); end
 
-      sig { params(event: BeginTransactionEvent).void }
+      sig { params(event: Wal::BeginTransactionEvent).void }
       def on_begin(event); end
 
-      sig { params(event: InsertEvent).void }
+      sig { params(event: Wal::InsertEvent).void }
       def on_insert(event); end
 
-      sig { params(event: UpdateEvent).void }
+      sig { params(event: Wal::UpdateEvent).void }
       def on_update(event); end
 
-      sig { params(event: DeleteEvent).void }
+      sig { params(event: Wal::DeleteEvent).void }
       def on_delete(event); end
 
-      sig { params(event: CommitTransactionEvent).void }
+      sig { params(event: Wal::CommitTransactionEvent).void }
       def on_commit(event); end
     end
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wal
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Rodrigo Navarro
 bindir: exe
 cert_chain: []
-date: 2025-08-02 00:00:00.000000000 Z
+date: 2025-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg