pg_eventstore 1.13.3 → 2.0.0

data/lib/pg_eventstore/event.rb

@@ -6,6 +6,8 @@ module PgEventstore
 
     # @return [String] a type of link event
     LINK_TYPE = '$>'
+    # @return [String]
+    PRIMARY_TABLE_NAME = 'events'
 
     # @!attribute id
     #   @return [String] UUIDv4 string
@@ -28,10 +30,10 @@ module PgEventstore
     # @!attribute metadata
     #   @return [Hash] event's metadata
     attribute(:metadata) { {} }
-    # @!attribute link_id
-    #   @return [String, nil] UUIDv4 of an event the current event points to. If it is not nil, then the current
-    #     event is a link
-    attribute(:link_id)
+    # @!attribute link_global_position
+    #   @return [Integer, nil] global_position of an event the current event points to. If it is not nil, then the
+    #     current event is a link
+    attribute(:link_global_position)
     # @!attribute link_partition_id
     #   @return [Integer, nil] a partition id of an event the link event points to. It is used to load original event
     #     when resolve_link_tos: true option is provided when reading events.
@@ -56,7 +58,7 @@ module PgEventstore
     # Detect whether an event is a link event
     # @return [Boolean]
     def link?
-      !link_id.nil?
+      !link_global_position.nil?
     end
 
     # Detect whether an event is a system event

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module PgEventstore
   module Extensions
     # A very simple extension that implements a DSL for adding attr_accessors with default values,
@@ -72,16 +70,47 @@ module PgEventstore
         end
       end
 
-      class Options < Set
-        def add(option)
-          @hash[option] = option
-          self
+      class Options
+        include Enumerable
+
+        attr_reader :options
+        protected :options
+
+        # @param options [Array<PgEventstore::Extensions::OptionsExtension::Option>]
+        def initialize(options = [])
+          @options = options.to_h { [_1, true] }
         end
 
-        # @param option [Symbol]
+        # @param option_name [Symbol]
         # @return [PgEventstore::Extensions::OptionsExtension::Option, nil]
-        def [](option)
-          @hash[Option.new(option)]
+        def [](option_name)
+          option = Option.new(option_name)
+          options.find { |key, _| key == option }&.dig(0)
+        end
+
+        # @param other [PgEventstore::Extensions::OptionsExtension::Options]
+        # @return [PgEventstore::Extensions::OptionsExtension::Options]
+        def +(other)
+          self.class.new(options.keys + other.options.keys)
+        end
+
+        # @param option [PgEventstore::Extensions::OptionsExtension::Option]
+        # @return [Boolean]
+        def include?(option)
+          options.key?(option)
+        end
+
+        # @return [Boolean]
+        def dup
+          self.class.new(options.keys)
+        end
+
+        def each(...)
+          options.keys.each(...)
+        end
+
+        def ==(other)
+          options.keys == other.options.keys
         end
       end
 
@@ -92,7 +121,7 @@ module PgEventstore
         #   context of your object to determine the default value of the option
         # @return [Symbol]
         def option(opt_name, metadata: nil, &blk)
-          self.options = (options + Options.new([Option.new(opt_name, metadata: metadata)])).freeze
+          self.options = (options + Options.new([Option.new(opt_name, metadata:)])).freeze
           warn_already_defined(opt_name)
           warn_already_defined(:"#{opt_name}=")
           define_method "#{opt_name}=" do |value|
@@ -112,7 +141,7 @@ module PgEventstore
 
         def inherited(klass)
           super
-          klass.options = Options.new(options).freeze
+          klass.options = options.dup.freeze
         end
 
         private

data/lib/pg_eventstore/maintenance.rb

@@ -25,7 +25,7 @@ module PgEventstore
     def delete_event(event, force: false)
       Commands::DeleteEvent.new(
         Queries.new(transactions: transaction_queries, maintenance: maintenance_queries)
-      ).call(event, force: force)
+      ).call(event, force:)
     end
 
     private

data/lib/pg_eventstore/queries/event_queries.rb

@@ -28,7 +28,8 @@ module PgEventstore
     def event_exists?(event)
       return false if event.id.nil? || event.stream.nil?
 
-      sql_builder = SQLBuilder.new.select('1 as exists').from('events').where('id = ?', event.id).limit(1)
+      sql_builder = SQLBuilder.new.select('1 as exists').from(Event::PRIMARY_TABLE_NAME).where('id = ?', event.id)
+      sql_builder.limit(1)
       sql_builder.where(
         'context = ? and stream_name = ? and type = ?', event.stream.context, event.stream.stream_name, event.type
       )
@@ -40,24 +41,24 @@ module PgEventstore
     # Takes an array of potentially persisted events and loads their ids from db. Those ids can be later used to check
     # whether events are actually existing events.
     # @param events [Array<PgEventstore::Event>]
-    # @return [Array<String>]
-    def ids_from_db(events)
-      sql_builder = SQLBuilder.new.from('events').select('id')
+    # @return [Array<Integer>]
+    def global_positions_from_db(events)
+      sql_builder = SQLBuilder.new.from(Event::PRIMARY_TABLE_NAME).select('global_position')
       partition_attrs = events.map { |event| [event.stream&.context, event.stream&.stream_name, event.type] }.uniq
       partition_attrs.each do |context, stream_name, event_type|
         sql_builder.where_or('context = ? and stream_name = ? and type = ?', context, stream_name, event_type)
       end
-      sql_builder.where('id = ANY(?::uuid[])', events.map(&:id))
+      sql_builder.where('global_position = ANY(?::bigint[])', events.map(&:global_position))
       raw_events = PgEventstore.connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end.to_a
-      raw_events.map { |attrs| attrs['id'] }
+      raw_events.map { |attrs| attrs['global_position'] }
     end
 
     # @param stream [PgEventstore::Stream]
     # @return [Integer, nil]
     def stream_revision(stream)
-      sql_builder = SQLBuilder.new.from('events').select('stream_revision')
+      sql_builder = SQLBuilder.new.from(Event::PRIMARY_TABLE_NAME).select('stream_revision')
       sql_builder.where('context = ? and stream_name = ? and stream_id = ?', *stream.to_a)
       sql_builder.order('stream_revision DESC').limit(1)
       connection.with do |conn|
@@ -83,7 +84,7 @@ module PgEventstore
     # @return [Array<PgEventstore::Event>]
     def insert(stream, events)
       sql_rows_for_insert, values = prepared_statements(stream, events)
-      columns = %w[id data metadata stream_revision link_id link_partition_id type context stream_name stream_id]
+      columns = %w[id data metadata stream_revision link_global_position link_partition_id type context stream_name stream_id]
 
       sql = <<~SQL
         INSERT INTO events (#{columns.join(', ')})
@@ -128,7 +129,7 @@ module PgEventstore
       sql_rows_for_insert = events.map do |event|
         event = serializer.serialize(event)
         attributes = event.options_hash.slice(
-          :id, :data, :metadata, :stream_revision, :link_id, :link_partition_id, :type
+          :id, :data, :metadata, :stream_revision, :link_global_position, :link_partition_id, :type
         )
 
         attributes = attributes.merge(stream.to_hash)

data/lib/pg_eventstore/queries/links_resolver.rb

@@ -20,9 +20,9 @@ module PgEventstore
       link_events = raw_events.select { _1['link_partition_id'] }.group_by { _1['link_partition_id'] }
       return raw_events if link_events.empty?
 
-      original_events = load_original_events(link_events).to_h { |attrs| [attrs['id'], attrs] }
+      original_events = load_original_events(link_events).to_h { |attrs| [attrs['global_position'], attrs] }
       raw_events.map do |attrs|
-        original_event = original_events[attrs['link_id']]
+        original_event = original_events[attrs['link_global_position']]
         next attrs unless original_event
 
         original_event.merge('link' => attrs).merge(attrs.except(*original_event.keys))
@@ -37,7 +37,10 @@ module PgEventstore
       partitions = partition_queries.find_by_ids(link_events.keys)
       sql_builders = partitions.map do |partition|
         sql_builder = SQLBuilder.new.select('*').from(partition['table_name'])
-        sql_builder.where('id  = ANY(?::uuid[])', link_events[partition['id']].map { _1['link_id'] })
+        sql_builder.where(
+          'global_position = ANY(?::bigint[])',
+          link_events[partition['id']].map { _1['link_global_position'] }
+        )
       end
       sql_builder = sql_builders[1..].each_with_object(sql_builders.first) do |builder, top_builder|
         top_builder.union(builder)

data/lib/pg_eventstore/queries/partition_queries.rb

@@ -76,7 +76,7 @@ module PgEventstore
     # @return [Hash] partition attributes
     def create_event_type_partition(stream, event_type, stream_name_partition_name)
       attributes = {
-        context: stream.context, stream_name: stream.stream_name, event_type: event_type,
+        context: stream.context, stream_name: stream.stream_name, event_type:,
         table_name: event_type_partition_name(stream, event_type)
       }
 
@@ -178,14 +178,42 @@ module PgEventstore
 
     # @param stream_filters [Array<Hash[Symbol, String]>]
     # @param event_filters [Array<String>]
+    # @param scope [Symbol] what kind of partition we want to receive. Available options are :event_type, :context,
+    #   :stream_name and :auto. In :auto mode the scope will be calculated based on stream_filters and event_filters.
     # @return [Array<PgEventstore::Partition>]
-    def partitions(stream_filters, event_filters)
-      partitions_filter = QueryBuilders::PartitionsFiltering.new
-      stream_filters.each { |attrs| partitions_filter.add_stream_attrs(**attrs) }
-      partitions_filter.add_event_types(event_filters)
-      partitions_filter.with_event_types
+    def partitions(stream_filters, event_filters, scope: :event_type)
+      stream_filters = stream_filters.select { QueryBuilders::PartitionsFiltering.correct_stream_filter?(_1) }
+      sql_builder =
+        if event_filters.any?
+          # When event type filters are present - they apply constraints to any stream filter. Thus, we can't look up
+          # partitions by stream attributes separately.
+          filter = QueryBuilders::PartitionsFiltering.new
+          stream_filters.each { |attrs| filter.add_stream_attrs(**attrs) }
+          filter.add_event_types(event_filters)
+          set_partitions_scope(filter, stream_filters, event_filters, scope)
+        else
+          # When event type filters are absent - we can look up partitions by context and context/stream_name
+          # separately, thus potentially producing one-to-one mapping of filter-to-partition with :auto scope. For
+          # example, let's say we have stream attributes filter like
+          # [{ context: 'FooCtx', stream_name: 'Bar'}, { context: 'BarCtx' }], then we would be able to look up
+          # partitions by the exact match, returning only two of them according to the provided filters - stream
+          # partition for first filter and context partition for second filter.
+          builders = stream_filters.map do |attrs|
+            filter = QueryBuilders::PartitionsFiltering.new
+            filter.add_stream_attrs(**attrs)
+            set_partitions_scope(filter, [attrs], event_filters, scope)
+          end
+
+          sql_builder = SQLBuilder.union_builders(builders) if builders.any?
+          sql_builder ||
+            begin
+              builder = QueryBuilders::PartitionsFiltering.new
+              set_partitions_scope(builder, stream_filters, event_filters, scope)
+            end
+        end
+
       connection.with do |conn|
-        conn.exec_params(*partitions_filter.to_exec_params)
+        conn.exec_params(*sql_builder.to_exec_params)
       end.map(&method(:deserialize))
     end
 
@@ -210,6 +238,43 @@ module PgEventstore
 
     private
 
+    # @param partitions_filter [PgEventstore::QueryBuilders::PartitionsFiltering]
+    # @param stream_filters [Array<Hash[Symbol, String]>]
+    # @param event_filters [Array<String>]
+    # @param scope [Symbol]
+    # @return [PgEventstore::SQLBuilder]
+    def set_partitions_scope(partitions_filter, stream_filters, event_filters, scope)
+      case scope
+      when :event_type
+        partitions_filter.with_event_types
+      when :stream_name
+        filter = QueryBuilders::PartitionsFiltering.new
+        filter.without_event_types
+        filter.with_stream_names
+        builder = filter.to_sql_builder
+        builder.where(
+          '(context, stream_name) in ?',
+          partitions_filter.to_sql_builder.unselect.select('context, stream_name').group('context, stream_name')
+        )
+      when :context
+        filter = QueryBuilders::PartitionsFiltering.new
+        filter.without_event_types
+        filter.without_stream_names
+        builder = filter.to_sql_builder
+        builder.where('context in ?', partitions_filter.to_sql_builder.unselect.select('context').group('context'))
+      when :auto
+        if event_filters.any?
+          set_partitions_scope(partitions_filter, stream_filters, event_filters, :event_type)
+        elsif stream_filters.any? { _1[:stream_name] }
+          set_partitions_scope(partitions_filter, stream_filters, event_filters, :stream_name)
+        else
+          set_partitions_scope(partitions_filter, stream_filters, event_filters, :context)
+        end
+      else
+        raise NotImplementedError, "Don't know how to handle #{scope.inspect} scope!"
+      end
+    end
+
     # @param attrs [Hash]
     # @return [PgEventstore::Partition]
     def deserialize(attrs)

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -23,24 +23,30 @@ module PgEventstore
     end
 
     # @param level [Symbol] transaction isolation level
+    # @param read_only [Boolean] whether transaction is read-only
     # @return [void]
-    def transaction(level = :serializable, &blk)
+    def transaction(level = :serializable, read_only: false, &blk)
       connection.with do |conn|
         # We are inside a transaction already - no need to start another one
         next yield if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
 
-        pg_transaction(ISOLATION_LEVELS[level], conn, &blk)
+        pg_transaction(ISOLATION_LEVELS[level], read_only, conn, &blk)
       end
     end
 
     private
 
     # @param level [String] PostgreSQL transaction isolation level
+    # @param read_only [Boolean]
     # @param pg_connection [PG::Connection]
     # @return [void]
-    def pg_transaction(level, pg_connection, &_blk)
+    def pg_transaction(level, read_only, pg_connection, &)
       pg_connection.transaction do
-        pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
+        if read_only
+          pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level} READ ONLY")
+        else
+          pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
+        end
         yield
       end
     rescue PG::TRSerializationFailure, PG::TRDeadlockDetected

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -4,10 +4,6 @@ module PgEventstore
   module QueryBuilders
     # @!visibility private
     class EventsFiltering < BasicFiltering
-      # @return [String]
-      TABLE_NAME = 'events'
-      private_constant :TABLE_NAME
-
       # @return [Integer]
       DEFAULT_LIMIT = 1_000
       # @return [Hash<String => String, Symbol => String>]
@@ -94,7 +90,7 @@ module PgEventstore
             stream_attrs in { context: String | NilClass => context }
             stream_attrs in { stream_name: String | NilClass => stream_name }
             stream_attrs in { stream_id: String | NilClass => stream_id }
-            { context: context, stream_name: stream_name, stream_id: stream_id }
+            { context:, stream_name:, stream_id: }
           end
           streams || []
         end
@@ -107,7 +103,7 @@ module PgEventstore
 
       # @return [String]
       def to_table_name
-        TABLE_NAME
+        Event::PRIMARY_TABLE_NAME
       end
 
       # @param context [String, nil]
@@ -115,7 +111,7 @@ module PgEventstore
       # @param stream_id [String, nil]
       # @return [void]
       def add_stream_attrs(context: nil, stream_name: nil, stream_id: nil)
-        stream_attrs = { context: context, stream_name: stream_name, stream_id: stream_id }
+        stream_attrs = { context:, stream_name:, stream_id: }
         return unless correct_stream_filter?(stream_attrs)
 
         stream_attrs.compact!

data/lib/pg_eventstore/query_builders/partitions_filtering.rb

@@ -24,10 +24,23 @@ module PgEventstore
           streams = streams&.map do |stream_attrs|
             stream_attrs in { context: String | NilClass => context }
             stream_attrs in { stream_name: String | NilClass => stream_name }
-            { context: context, stream_name: stream_name }
+            { context:, stream_name: }
           end
           streams || []
         end
+
+        # @param stream_attrs [Hash]
+        # @return [Boolean]
+        def correct_stream_filter?(stream_attrs)
+          result = (stream_attrs in { context: String, stream_name: String } | { context: String })
+          return true if result
+
+          PgEventstore.logger&.debug(<<~TEXT)
+            Ignoring unsupported stream filter format for grouped read #{stream_attrs.compact.inspect}. \
+            See docs/reading_events.md docs for supported formats.
+          TEXT
+          false
+        end
       end
 
       # @return [String]
@@ -37,10 +50,10 @@ module PgEventstore
 
       # @param context [String, nil]
       # @param stream_name [String, nil]
-      # @return [void]
+      # @return [PgEventstore::SQLBuilder]
       def add_stream_attrs(context: nil, stream_name: nil)
-        stream_attrs = { context: context, stream_name: stream_name }
-        return unless correct_stream_filter?(stream_attrs)
+        stream_attrs = { context:, stream_name: }
+        return @sql_builder unless self.class.correct_stream_filter?(stream_attrs)
 
         stream_attrs.compact!
         sql = stream_attrs.map do |attr, _|
@@ -50,31 +63,28 @@ module PgEventstore
       end
 
       # @param event_types [Array<String>]
-      # @return [void]
+      # @return [PgEventstore::SQLBuilder]
       def add_event_types(event_types)
-        return if event_types.empty?
+        return @sql_builder if event_types.empty?
 
         @sql_builder.where("#{to_table_name}.event_type = ANY(?::varchar[])", event_types)
       end
 
-      # @return [void]
+      # @return [PgEventstore::SQLBuilder]
       def with_event_types
         @sql_builder.where('event_type IS NOT NULL')
       end
 
-      private
+      def with_stream_names
+        @sql_builder.where('stream_name IS NOT NULL')
+      end
 
-      # @param stream_attrs [Hash]
-      # @return [Boolean]
-      def correct_stream_filter?(stream_attrs)
-        result = (stream_attrs in { context: String, stream_name: String } | { context: String, stream_name: nil })
-        return true if result
+      def without_event_types
+        @sql_builder.where('event_type IS NULL')
+      end
 
-        PgEventstore.logger&.debug(<<~TEXT)
-          Ignoring unsupported stream filter format for grouped read #{stream_attrs.compact.inspect}. \
-          See docs/reading_events.md docs for supported formats.
-        TEXT
-        false
+      def without_stream_names
+        @sql_builder.where('stream_name IS NULL')
       end
     end
   end

data/lib/pg_eventstore/sql_builder.rb

@@ -64,7 +64,7 @@ module PgEventstore
       self
     end
 
-    # @param table_name [String]
+    # @param table_name [String | SQLBuilder]
     # @return [self]
     def from(table_name)
       @from_value = table_name
@@ -132,7 +132,7 @@ module PgEventstore
       self
     end
 
-    # @return [Array<String, Array<Object>>]
+    # @return [[String, Array<_>]]
     def to_exec_params
       @positional_values.clear
       @positional_values_size = 0
@@ -141,19 +141,27 @@ module PgEventstore
 
     protected
 
-    # @return [Array<String, Array<Object>>]
+    # @return [[String, Array<_>]]
     def _to_exec_params
       return [single_query_sql, @positional_values] if @union_values.empty?
 
       [union_query_sql, @positional_values]
     end
 
+    # @return [String]
+    def from_sql
+      return @from_value if @from_value.is_a?(String)
+
+      sql = merge(@from_value)
+      "(#{sql}) #{@from_value.from_sql}"
+    end
+
     private
 
     # @return [String]
     def single_query_sql
       where_sql = [where_sql('OR'), where_sql('AND')].reject(&:empty?).map { |sql| "(#{sql})" }.join(' AND ')
-      sql = "SELECT #{select_sql} FROM #{@from_value}"
+      sql = "SELECT #{select_sql} FROM #{from_sql}"
       sql += " #{join_sql}" unless @join_values.empty?
       sql += " WHERE #{where_sql}" unless where_sql.empty?
       sql += " GROUP BY #{@group_values.join(', ')}" unless @group_values.empty?
@@ -168,11 +176,7 @@ module PgEventstore
       sql = single_query_sql
       union_parts = ["(#{sql})"]
       union_parts += @union_values.map do |builder|
-        builder.positional_values_size = @positional_values_size
-        builder_sql, values = builder._to_exec_params
-        @positional_values.push(*values)
-        @positional_values_size += values.size
-        "(#{builder_sql})"
+        "(#{merge(builder)})"
       end
       union_parts.join(' UNION ALL ')
     end
@@ -200,14 +204,28 @@ module PgEventstore
       @order_values.join(', ')
     end
 
+    # @param builder [PgEventstore::SQLBuilder]
+    # @return [String]
+    def merge(builder)
+      builder.positional_values_size = @positional_values_size
+      sql_query, positional_values = builder._to_exec_params
+      @positional_values.push(*positional_values)
+      @positional_values_size += positional_values.size
+      sql_query
+    end
+
     # Replaces "?" signs in the given string with positional variables and memorize positional values they refer to.
     # @param sql [String]
     # @return [String]
     def extract_positional_args(sql, *arguments)
       sql.gsub('?').each_with_index do |_, index|
-        @positional_values.push(arguments[index])
-        @positional_values_size += 1
-        "$#{@positional_values_size}"
+        if arguments[index].is_a?(SQLBuilder)
+          "(#{merge(arguments[index])})"
+        else
+          @positional_values.push(arguments[index])
+          @positional_values_size += 1
+          "$#{@positional_values_size}"
+        end
       end
     end
   end

data/lib/pg_eventstore/stream.rb

@@ -67,7 +67,7 @@ module PgEventstore
     # @param keys [Array<Symbol>, nil]
     # @return [Hash<Symbol => String>]
     def deconstruct_keys(keys)
-      hash = { context: context, stream_name: stream_name, stream_id: stream_id }
+      hash = { context:, stream_name:, stream_id: }
       return hash unless keys
 
       hash.slice(*keys)

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -46,7 +46,7 @@ module PgEventstore
   #
   #     def initialize
   #       @basic_runner = PgEventstore::BasicRunner.new(
-  #         run_interval: 1, async_shutdown_time: 2, recovery_strategies: recovery_strategies
+  #         run_interval: 1, async_shutdown_time: 2, recovery_strategies:
   #       )
   #       @jobs_performed = 0
   #       @jobs_limit = 3
@@ -224,7 +224,7 @@ module PgEventstore
 
     # @param state [Symbol]
     # @return [Object, nil] a result of evaluating of passed block
-    def within_state(state, &_blk)
+    def within_state(state, &)
       synchronize do
         return unless @state.public_send("#{RunnerState::STATES.fetch(state)}?")
 
@@ -248,8 +248,8 @@ module PgEventstore
 
     private
 
-    def synchronize(&blk)
-      @mutex.synchronize(&blk)
+    def synchronize(&)
+      @mutex.synchronize(&)
     end
 
     # @return [void]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_feeder_handlers.rb

@@ -10,7 +10,7 @@ module PgEventstore
       # @param state [String]
       # @return [void]
       def update_subscriptions_set_state(subscriptions_set_lifecycle, state)
-        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state: state)
+        subscriptions_set_lifecycle.persisted_subscriptions_set.update(state:)
       end
 
       # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]

data/lib/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rb

@@ -21,7 +21,7 @@ module PgEventstore
       def update_subscription_stats(subscription, stats, current_position)
         subscription.update(
           average_event_processing_time: stats.average_event_processing_time,
-          current_position: current_position,
+          current_position:,
           total_processed_events: subscription.total_processed_events + 1
         )
       end
@@ -50,7 +50,7 @@ module PgEventstore
       # @param state [String]
       # @return [void]
       def update_subscription_state(subscription, state)
-        subscription.update(state: state)
+        subscription.update(state:)
       end
     end
   end

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -21,7 +21,7 @@ module PgEventstore
       @basic_runner = BasicRunner.new(
         run_interval: 0,
         async_shutdown_time: graceful_shutdown_timeout,
-        recovery_strategies: recovery_strategies
+        recovery_strategies:
       )
       attach_runner_callbacks
     end

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

@@ -21,15 +21,15 @@ module PgEventstore
     def find_or_create_by(subscription_id:, subscriptions_set_id:, command_name:, data:)
       transaction_queries.transaction do
         existing = find_by(
-          subscription_id: subscription_id, subscriptions_set_id: subscriptions_set_id, command_name: command_name
+          subscription_id:, subscriptions_set_id:, command_name:
         )
         next existing if existing
 
         create(
-          subscription_id: subscription_id,
-          subscriptions_set_id: subscriptions_set_id,
-          command_name: command_name,
-          data: data
+          subscription_id:,
+          subscriptions_set_id:,
+          command_name:,
+          data:
         )
       end
     end