pg_eventstore 1.13.3 → 2.0.0

data/lib/pg_eventstore/subscriptions/queries/subscription_queries.rb

@@ -60,7 +60,7 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new('subscriptions', id))
+      find_by(id:) || raise(RecordNotFound.new('subscriptions', id))
     end
 
     # @param attrs [Hash]
@@ -105,7 +105,7 @@ module PgEventstore
         updated_attrs
       end
 
-      deserialize(updated_attrs)
+      deserialize(updated_attrs).slice(*attrs.keys)
     end
 
     # @param subscriptions_set_id [Integer] SubscriptionsSet#id
@@ -177,6 +177,7 @@ module PgEventstore
     # @return [PgEventstore::SQLBuilder]
     def query_builder(id, options)
       builder = PgEventstore::QueryBuilders::EventsFiltering.subscriptions_events_filtering(options).to_sql_builder
+      builder.where('global_position <= ?', options[:to_position]) if options[:to_position]
       builder.select("#{id} as runner_id")
     end
 

data/lib/pg_eventstore/subscriptions/queries/subscription_service_queries.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class SubscriptionServiceQueries
+    # @return [Integer]
+    DEFAULT_SAFE_POSITION = 0
+    private_constant :DEFAULT_SAFE_POSITION
+
+    # @!attribute connection
+    #   @return [PgEventstore::Connection]
+    attr_reader :connection
+    private :connection
+
+    # @param connection [PgEventstore::Connection]
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # @return [Integer]
+    def safe_global_position
+      result = transaction_queries.transaction(read_only: true) do
+        connection.with do |conn|
+          conn.exec(<<~SQL)
+            SELECT MAX(global_position) as global_position
+              FROM events_horizon
+              WHERE xact_id < pg_snapshot_xmin(pg_current_snapshot())
+          SQL
+        end
+      end
+
+      global_position = result.to_a.first&.dig('global_position')
+      return global_position if global_position
+
+      if global_position.nil? && !events_horizon_present?
+        init_events_horizon
+        return safe_global_position
+      end
+      # events_horizon table is not empty, but there is no safe position yet. Thus, we wait for the safe position by
+      # returning default value which will prevent from fetching events with gaps
+      DEFAULT_SAFE_POSITION
+    end
+
+    # @return [Boolean]
+    def events_horizon_present?
+      result = connection.with do |conn|
+        conn.exec(<<~SQL)
+          SELECT true as presence FROM events_horizon LIMIT 1
+        SQL
+      end
+      result.to_a.first&.dig('presence') || false
+    end
+
+    # @return [void]
+    def init_events_horizon
+      transaction_queries.transaction do
+        return if events_horizon_present?
+
+        max_pos = connection.with do |conn|
+          conn.exec('SELECT MAX(global_position) FROM events')
+        end
+        max_pos = max_pos.to_a.first&.dig('global_position') || DEFAULT_SAFE_POSITION
+        connection.with do |conn|
+          conn.exec_params(<<~SQL, [max_pos])
+            INSERT INTO events_horizon (global_position, xact_id) VALUES ($1, DEFAULT)
+          SQL
+        end
+      end
+    end
+
+    private
+
+    # @return [PgEventstore::TransactionQueries]
+    def transaction_queries
+      TransactionQueries.new(connection)
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_command_queries.rb

@@ -19,8 +19,8 @@ module PgEventstore
     # @return [PgEventstore::SubscriptionFeederCommands::Base]
     def find_or_create_by(subscriptions_set_id:, command_name:, data:)
       transaction_queries.transaction do
-        find_by(subscriptions_set_id: subscriptions_set_id, command_name: command_name) ||
-          create(subscriptions_set_id: subscriptions_set_id, command_name: command_name, data: data)
+        find_by(subscriptions_set_id:, command_name:) ||
+          create(subscriptions_set_id:, command_name:, data:)
       end
     end
 

data/lib/pg_eventstore/subscriptions/queries/subscriptions_set_queries.rb

@@ -62,7 +62,7 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new('subscriptions_set', id))
+      find_by(id:) || raise(RecordNotFound.new('subscriptions_set', id))
     end
 
     # @param attrs [Hash]

data/lib/pg_eventstore/subscriptions/subscription.rb

@@ -6,6 +6,16 @@ module PgEventstore
     include Extensions::UsingConnectionExtension
     include Extensions::OptionsExtension
 
+    # Determines the minimal allowed value of events pull frequency of the particular subscription. You can find similar
+    # constant - SubscriptionFeeder::EVENTS_PULL_INTERVAL. Unlike it - this one is responsible to detect whether the
+    # subscription should be included in the subscriptions list to query next chunk of events. Thus, this setting only
+    # determines whether it is time to make a request, but how frequent would be the actual request - determines
+    # SubscriptionFeeder::EVENTS_PULL_INTERVAL.
+    # @see PgEventstore::SubscriptionFeeder::EVENTS_PULL_INTERVAL
+    # @return [Float]
+    MIN_EVENTS_PULL_INTERVAL = 0.2
+    private_constant :MIN_EVENTS_PULL_INTERVAL
+
     # @return [Time]
     DEFAULT_TIMESTAMP = Time.at(0).utc.freeze
 
@@ -103,7 +113,7 @@ module PgEventstore
     # @param attrs [Hash]
     # @return [Hash]
     def update(attrs)
-      assign_attributes(subscription_queries.update(id, attrs: attrs, locked_by: locked_by))
+      assign_attributes(subscription_queries.update(id, attrs:, locked_by:))
     end
 
     # @param attrs [Hash]
@@ -119,8 +129,8 @@ module PgEventstore
     # @param force [Boolean]
     # @return [PgEventstore::Subscription]
     def lock!(lock_id, force: false)
-      self.id = subscription_queries.find_or_create_by(set: set, name: name)[:id]
-      self.locked_by = subscription_queries.lock!(id, lock_id, force: force)
+      self.id = subscription_queries.find_or_create_by(set:, name:)[:id]
+      self.locked_by = subscription_queries.lock!(id, lock_id, force:)
       reset_runtime_attributes
       self
     end
@@ -163,18 +173,19 @@ module PgEventstore
     # @return [void]
     def reset_runtime_attributes
       update(
-        options: options,
+        options:,
         restart_count: 0,
         last_restarted_at: nil,
-        max_restarts_number: max_restarts_number,
-        chunk_query_interval: chunk_query_interval,
+        max_restarts_number:,
+        chunk_query_interval: [chunk_query_interval, MIN_EVENTS_PULL_INTERVAL].max,
         last_chunk_fed_at: DEFAULT_TIMESTAMP,
         last_chunk_greatest_position: nil,
         last_error: nil,
         last_error_occurred_at: nil,
-        time_between_restarts: time_between_restarts,
+        time_between_restarts:,
         state: RunnerState::STATES[:initial]
       )
+      reload
     end
 
     # @return [PgEventstore::SubscriptionQueries]

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -7,6 +7,12 @@ module PgEventstore
   class SubscriptionFeeder
     extend Forwardable
 
+    # Determines how often to fetch events from the event store.
+    # @see PgEventstore::Subscription::MIN_EVENTS_PULL_INTERVAL
+    # @return [Float]
+    EVENTS_PULL_INTERVAL = 0.2 # seconds
+    private_constant :EVENTS_PULL_INTERVAL
+
     attr_reader :config_name
 
     def_delegators :@basic_runner, :start, :stop, :restore, :state, :wait_for_finish, :stop_async, :running?
@@ -17,7 +23,7 @@ module PgEventstore
     def initialize(config_name:, subscriptions_set_lifecycle:, subscriptions_lifecycle:)
       @config_name = config_name
       @basic_runner = BasicRunner.new(
-        run_interval: 0.2,
+        run_interval: EVENTS_PULL_INTERVAL,
         async_shutdown_time: 0,
         recovery_strategies: recovery_strategies(config_name, subscriptions_set_lifecycle)
       )
@@ -116,7 +122,7 @@ module PgEventstore
       [
         RunnerRecoveryStrategies::RestoreConnection.new(config_name),
         RunnerRecoveryStrategies::RestoreSubscriptionFeeder.new(
-          subscriptions_set_lifecycle: subscriptions_set_lifecycle
+          subscriptions_set_lifecycle:
         ),
       ]
     end

data/lib/pg_eventstore/subscriptions/subscription_handler_performance.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'benchmark'
-
 module PgEventstore
   # This class measures the performance of Subscription's handler and returns the average time required to process an
   # event.
@@ -23,7 +21,7 @@ module PgEventstore
     # @return [Object] the result of yielded block
     def track_exec_time
       result = nil
-      time = Benchmark.realtime { result = yield }
+      time = Utils.benchmark { result = yield }
       synchronize do
         @timings.shift if @timings.size == TIMINGS_TO_KEEP
         @timings.push(time)

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -38,12 +38,15 @@ module PgEventstore
 
     # @return [Hash]
     def next_chunk_query_opts
-      @subscription.options.merge(from_position: next_chunk_global_position, max_count: estimate_events_number)
+      @subscription.options.merge(
+        from_position: next_chunk_global_position,
+        max_count: estimate_events_number
+      )
     end
 
     # @return [Boolean]
     def time_to_feed?
-      @subscription.last_chunk_fed_at + @subscription.chunk_query_interval <= Time.now.utc
+      estimate_events_number > 0 && @subscription.last_chunk_fed_at + @subscription.chunk_query_interval <= Time.now.utc
     end
 
     private

data/lib/pg_eventstore/subscriptions/subscription_runners_feeder.rb

@@ -15,7 +15,10 @@ module PgEventstore
       runners = runners.select(&:running?).select(&:time_to_feed?)
       return if runners.empty?
 
-      runners_query_options = runners.to_h { |runner| [runner.id, runner.next_chunk_query_opts] }
+      safe_pos = subscription_service_queries.safe_global_position
+      runners_query_options = runners.to_h do |runner|
+        [runner.id, runner.next_chunk_query_opts.merge(to_position: safe_pos)]
+      end
       grouped_events = subscription_queries.subscriptions_events(runners_query_options)
 
       runners.each do |runner|
@@ -34,5 +37,10 @@ module PgEventstore
     def subscription_queries
       SubscriptionQueries.new(connection)
     end
+
+    # @return [PgEventstore::SubscriptionServiceQueries]
+    def subscription_service_queries
+      SubscriptionServiceQueries.new(connection)
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -25,6 +25,7 @@ require_relative 'subscription_feeder_commands'
 require_relative 'subscription_runner_commands'
 require_relative 'queries/subscription_command_queries'
 require_relative 'queries/subscription_queries'
+require_relative 'queries/subscription_service_queries'
 require_relative 'queries/subscriptions_set_command_queries'
 require_relative 'queries/subscriptions_set_queries'
 require_relative 'commands_handler'
@@ -59,10 +60,10 @@ module PgEventstore
         }
       )
       @subscriptions_lifecycle = SubscriptionsLifecycle.new(
-        config_name, @subscriptions_set_lifecycle, force_lock: force_lock
+        config_name, @subscriptions_set_lifecycle, force_lock:
       )
       @subscription_feeder = SubscriptionFeeder.new(
-        config_name: config_name,
+        config_name:,
         subscriptions_set_lifecycle: @subscriptions_set_lifecycle,
         subscriptions_lifecycle: @subscriptions_lifecycle
       )
@@ -99,17 +100,17 @@ module PgEventstore
                   failed_subscription_notifier: config.failed_subscription_notifier,
                   graceful_shutdown_timeout: config.subscription_graceful_shutdown_timeout)
       subscription = Subscription.using_connection(config.name).new(
-        set: @set_name, name: subscription_name, options: options, chunk_query_interval: pull_interval,
+        set: @set_name, name: subscription_name, options:, chunk_query_interval: pull_interval,
         max_restarts_number: max_retries, time_between_restarts: retries_interval
       )
       runner = SubscriptionRunner.new(
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(
           create_raw_event_handler(middlewares, handler),
-          graceful_shutdown_timeout: graceful_shutdown_timeout,
+          graceful_shutdown_timeout:,
           recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
         ),
-        subscription: subscription
+        subscription:
       )
 
       @subscriptions_lifecycle.runners.push(runner)
@@ -150,10 +151,10 @@ module PgEventstore
     private
 
     # @return [Object] the result of the passed block
-    def run_cli_callbacks(&blk)
+    def run_cli_callbacks(&)
       return yield unless defined?(::PgEventstore::CLI)
 
-      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self, &blk)
+      PgEventstore::CLI.callbacks.run_callbacks(:start_manager, self, &)
     end
 
     # @param middlewares [Array<Symbol>, nil]
@@ -180,11 +181,16 @@ module PgEventstore
       [
         RunnerRecoveryStrategies::RestoreConnection.new(config_name),
         RunnerRecoveryStrategies::RestoreSubscriptionRunner.new(
-          subscription: subscription,
-          restart_terminator: restart_terminator,
-          failed_subscription_notifier: failed_subscription_notifier
+          subscription:,
+          restart_terminator:,
+          failed_subscription_notifier:
         ),
       ]
     end
+
+    # @return [PgEventstore::Connection]
+    def connection
+      PgEventstore.connection(config_name)
+    end
   end
 end

data/lib/pg_eventstore/tasks/setup.rake

@@ -2,50 +2,53 @@
 
 require 'uri'
 
-helpers = Class.new do
-  class << self
-    def postgres_uri
-      @postgres_uri ||=
-        begin
-          uri = URI.parse(ENV.fetch('PG_EVENTSTORE_URI'))
-          uri.path = '/postgres'
-          uri.to_s
-        end
-    end
+module PgEventstore
+  class MigrationHelpers
+    class << self
+      def postgres_uri
+        @postgres_uri ||=
+          begin
+            uri = URI.parse(ENV.fetch('PG_EVENTSTORE_URI'))
+            uri.path = '/postgres'
+            uri.to_s
+          end
+      end
 
-    def db_name
-      @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete('/')
+      def db_name
+        @db_name ||= URI.parse(ENV.fetch('PG_EVENTSTORE_URI')).path&.delete('/')
+      end
     end
   end
 end
 
+PgEventstore.configure(name: :_postgres_db_connection) do |config|
+  config.pg_uri = PgEventstore::MigrationHelpers.postgres_uri
+end
+
+PgEventstore.configure(name: :_eventstore_db_connection) do |config|
+  config.pg_uri = ENV['PG_EVENTSTORE_URI']
+end
+
 namespace :pg_eventstore do
   desc 'Creates events table, indexes, etc.'
   task :create do
-    PgEventstore.configure do |config|
-      config.pg_uri = helpers.postgres_uri
-    end
-
-    PgEventstore.connection.with do |conn|
+    PgEventstore.connection(:_postgres_db_connection).with do |conn|
       exists =
-        conn.exec_params('SELECT 1 as exists FROM pg_database where datname = $1', [helpers.db_name]).
+        conn.exec_params('SELECT 1 as exists FROM pg_database where datname = $1', [PgEventstore::MigrationHelpers.db_name]).
         first&.dig('exists')
       if exists
-        puts "#{helpers.db_name} already exists. Skipping."
+        puts "#{PgEventstore::MigrationHelpers.db_name} already exists. Skipping."
       else
-        conn.exec("CREATE DATABASE #{conn.escape_string(helpers.db_name)} WITH OWNER #{conn.escape_string(conn.user)}")
+        escaped_db_name = conn.escape_string(PgEventstore::MigrationHelpers.db_name)
+        conn.exec("CREATE DATABASE #{escaped_db_name} WITH OWNER #{conn.escape_string(conn.user)}")
       end
     end
   end
 
   task :migrate do
-    PgEventstore.configure do |config|
-      config.pg_uri = ENV['PG_EVENTSTORE_URI']
-    end
-
     migration_files_root = "#{Gem::Specification.find_by_name('pg_eventstore').gem_dir}/db/migrations"
 
-    PgEventstore.connection.with do |conn|
+    PgEventstore.connection(:_eventstore_db_connection).with do |conn|
       conn.exec('CREATE TABLE IF NOT EXISTS migrations (number int NOT NULL)')
       latest_migration =
         conn.exec('SELECT number FROM migrations ORDER BY number DESC LIMIT 1').to_a.dig(0, 'number') || -1
@@ -68,12 +71,8 @@ namespace :pg_eventstore do
 
   desc 'Drops events table and related pg_eventstore objects.'
   task :drop do
-    PgEventstore.configure do |config|
-      config.pg_uri = helpers.postgres_uri
-    end
-
-    PgEventstore.connection.with do |conn|
-      conn.exec("DROP DATABASE IF EXISTS #{conn.escape_string(helpers.db_name)}")
+    PgEventstore.connection(:_postgres_db_connection).with do |conn|
+      conn.exec("DROP DATABASE IF EXISTS #{conn.escape_string(PgEventstore::MigrationHelpers.db_name)}")
     end
   end
 end

data/lib/pg_eventstore/utils.rb

@@ -124,6 +124,14 @@ module PgEventstore
 
         wrapped_exception
       end
+
+      # Yields the given block and measures its execution time
+      # @return [Float] number of seconds the block took to execute
+      def benchmark
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        yield
+        Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      end
     end
   end
 end

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = '1.13.3'
+  VERSION = '2.0.0'
 end

data/lib/pg_eventstore/web/application.rb

@@ -87,7 +87,7 @@ module PgEventstore
             attrs.transform_values { escape_empty_string(_1) }
           end
           halt 200, {
-            results: results,
+            results:,
             pagination: { more: !collection.next_page_starting_id.nil?, starting_id: collection.next_page_starting_id },
           }.to_json
         end
@@ -153,7 +153,7 @@ module PgEventstore
             filter: { event_types: events_filter, streams: streams_filter },
             resolve_link_tos: resolve_link_tos?,
           },
-          system_stream: system_stream
+          system_stream:
         )
 
         if request.xhr?
@@ -188,8 +188,8 @@ module PgEventstore
           connection, @current_set, state: params[:state]
         ).subscriptions
         @association = Subscriptions::SubscriptionsToSetAssociation.new(
-          subscriptions_set: subscriptions_set,
-          subscriptions: subscriptions
+          subscriptions_set:,
+          subscriptions:
         )
         erb :'subscriptions/index'
       end
@@ -301,7 +301,7 @@ module PgEventstore
         ).first
         if event&.global_position == global_position
           begin
-            PgEventstore.maintenance(current_config).delete_event(event, force: force)
+            PgEventstore.maintenance(current_config).delete_event(event, force:)
             self.flash_message = {
               message: "An event at global position #{event.global_position} has been deleted successfully.",
               kind: 'success',

data/lib/pg_eventstore/web/paginator/events_collection.rb

@@ -26,7 +26,7 @@ module PgEventstore
         # @param options [Hash] additional options to filter the collection
         # @param system_stream [String, nil] a name of system stream
         def initialize(config_name, starting_id:, per_page:, order:, options: {}, system_stream: nil)
-          super(config_name, starting_id: starting_id, per_page: per_page, order: order, options: options)
+          super(config_name, starting_id:, per_page:, order:, options:)
           @stream = system_stream ? PgEventstore::Stream.system_stream(system_stream) : PgEventstore::Stream.all_stream
         end
 
@@ -45,7 +45,7 @@ module PgEventstore
           from_position = event_global_position(collection.first)
           sql_builder = QueryBuilders::EventsFiltering.events_filtering(
             @stream,
-            options.merge(from_position: from_position, max_count: 1, direction: order)
+            options.merge(from_position:, max_count: 1, direction: order)
           ).to_sql_builder.unselect.select('global_position').offset(per_page)
           global_position(sql_builder)
         end
@@ -55,10 +55,10 @@ module PgEventstore
           from_position = event_global_position(collection.first) || starting_id
           sql_builder = QueryBuilders::EventsFiltering.events_filtering(
             @stream,
-            options.merge(from_position: from_position, max_count: per_page, direction: order == :asc ? :desc : :asc)
+            options.merge(from_position:, max_count: per_page, direction: order == :asc ? :desc : :asc)
           ).to_sql_builder.unselect.select('global_position').offset(1)
           sql, params = sql_builder.to_exec_params
-          sql = "SELECT * FROM (#{sql}) events ORDER BY global_position #{order} LIMIT 1"
+          sql = "SELECT * FROM (#{sql}) #{Event::PRIMARY_TABLE_NAME} ORDER BY global_position #{order} LIMIT 1"
           connection.with do |conn|
             conn.exec_params(sql, params)
           end.to_a.dig(0, 'global_position')

data/lib/pg_eventstore/web/paginator/helpers.rb

@@ -41,13 +41,13 @@ module PgEventstore
         # @param per_page [String] string representation of items per page. E.g. "10", "20", etc.
         # @return [String]
         def per_page_url(per_page)
-          build_path(params.merge(per_page: per_page))
+          build_path(params.merge(per_page:))
         end
 
         # @param order [String] "asc"/"desc"
         # @return [String]
         def sort_url(order)
-          build_path(params.merge(order: order))
+          build_path(params.merge(order:))
         end
 
         def resolve_link_tos_url(should_resolve)
@@ -113,7 +113,7 @@ module PgEventstore
         def build_starting_id_link(starting_id)
           return 'javascript: void(0);' unless starting_id
 
-          build_path(params.merge(starting_id: starting_id))
+          build_path(params.merge(starting_id:))
         end
 
         # @param params [Hash, Array]

data/lib/pg_eventstore/web/paginator/stream_ids_collection.rb

@@ -11,7 +11,7 @@ module PgEventstore
         def collection
           @collection ||=
             begin
-              sql_builder = SQLBuilder.new.select('stream_id').from('events')
+              sql_builder = SQLBuilder.new.select('stream_id').from(Event::PRIMARY_TABLE_NAME)
               sql_builder.where('context = ? and stream_name = ?', options[:context], options[:stream_name])
               sql_builder.where('stream_id like ?', "#{options[:query]}%")
               sql_builder.where("stream_id #{direction_operator} ?", starting_id) if starting_id
@@ -27,7 +27,7 @@ module PgEventstore
           return unless collection.size == per_page
 
           starting_id = collection.first['stream_id']
-          sql_builder = SQLBuilder.new.select('stream_id').from('events')
+          sql_builder = SQLBuilder.new.select('stream_id').from(Event::PRIMARY_TABLE_NAME)
           sql_builder.where("stream_id #{direction_operator} ?", starting_id)
           sql_builder.where('stream_id like ?', "#{options[:query]}%")
           sql_builder.where('context = ? and stream_name = ?', options[:context], options[:stream_name])

data/lib/pg_eventstore/web/subscriptions/helpers.rb

@@ -9,7 +9,7 @@ module PgEventstore
         def subscriptions_url(set_name: nil)
           return url('/subscriptions') unless set_name
 
-          encoded_params = Rack::Utils.build_nested_query(set_name: set_name)
+          encoded_params = Rack::Utils.build_nested_query(set_name:)
           url("/subscriptions?#{encoded_params}")
         end
 
@@ -117,7 +117,7 @@ module PgEventstore
         # @param ids [Array<Integer>]
         # @return [String]
         def delete_all_subscriptions_url(ids)
-          encoded_params = Rack::Utils.build_nested_query(ids: ids)
+          encoded_params = Rack::Utils.build_nested_query(ids:)
           url("/delete_all_subscriptions?#{encoded_params}")
         end
 

data/lib/pg_eventstore.rb

@@ -39,7 +39,7 @@ module PgEventstore
     # @return [Object] a result of the given block
     def configure(name: DEFAULT_CONFIG)
       mutex.synchronize do
-        @config[name] = @config[name] ? Config.new(name: name, **@config[name].options_hash) : Config.new(name: name)
+        @config[name] = @config[name] ? Config.new(name:, **@config[name].options_hash) : Config.new(name:)
         connection_config_was = @config[name].connection_options
 
         yield(@config[name]).tap do
@@ -92,9 +92,9 @@ module PgEventstore
       SubscriptionsManager.new(
         config: config(config_name),
         set_name: subscription_set,
-        max_retries: max_retries,
-        retries_interval: retries_interval,
-        force_lock: force_lock
+        max_retries:,
+        retries_interval:,
+        force_lock:
       )
     end
 

data/pg_eventstore.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.description = 'EventStore implementation using PostgreSQL'
   spec.homepage = 'https://github.com/yousty/pg_eventstore'
   spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.0'
+  spec.required_ruby_version = '>= 3.2'
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'
 

data/sig/pg_eventstore/client.rbs

@@ -17,7 +17,7 @@ module PgEventstore
         ?middlewares: ::Array[untyped]?
       ) -> (PgEventstore::Event | ::Array[PgEventstore::Event])
 
-    def multiple: () { () -> untyped } -> untyped
+    def multiple: (?read_only: bool) { () -> untyped } -> untyped
 
     # _@param_ `stream`
     #

data/sig/pg_eventstore/commands/multiple.rbs

@@ -1,7 +1,7 @@
 module PgEventstore
   module Commands
     class Multiple < PgEventstore::AbstractCommand
-      def call: () { () -> untyped } -> untyped
+      def call: (read_only: bool) { () -> untyped } -> untyped
     end
   end
 end