pg_eventstore 1.13.1 → 1.13.2

data/lib/pg_eventstore/queries/transaction_queries.rb

@@ -7,7 +7,7 @@ module PgEventstore
     ISOLATION_LEVELS = {
       read_committed: 'READ COMMITTED',
       repeatable_read: 'REPEATABLE READ',
-      serializable: 'SERIALIZABLE'
+      serializable: 'SERIALIZABLE',
     }.tap do |h|
       h.default = h[:serializable]
     end.freeze
@@ -24,16 +24,12 @@ module PgEventstore
 
     # @param level [Symbol] transaction isolation level
     # @return [void]
-    def transaction(level = :serializable)
+    def transaction(level = :serializable, &blk)
       connection.with do |conn|
         # We are inside a transaction already - no need to start another one
-        if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
-          next yield
-        end
+        next yield if [PG::PQTRANS_ACTIVE, PG::PQTRANS_INTRANS].include?(conn.transaction_status)
 
-        pg_transaction(ISOLATION_LEVELS[level], conn) do
-          yield
-        end
+        pg_transaction(ISOLATION_LEVELS[level], conn, &blk)
       end
     end
 
@@ -42,7 +38,7 @@ module PgEventstore
     # @param level [String] PostgreSQL transaction isolation level
     # @param pg_connection [PG::Connection]
     # @return [void]
-    def pg_transaction(level, pg_connection)
+    def pg_transaction(level, pg_connection, &_blk)
       pg_connection.transaction do
         pg_connection.exec("SET TRANSACTION ISOLATION LEVEL #{level}")
         yield

data/lib/pg_eventstore/query_builders/events_filtering.rb

@@ -17,7 +17,7 @@ module PgEventstore
         :asc => 'ASC',
         :desc => 'DESC',
         'Forwards' => 'ASC',
-        'Backwards' => 'DESC'
+        'Backwards' => 'DESC',
       }.tap do |directions|
         directions.default = 'ASC'
       end.freeze
@@ -82,9 +82,7 @@ module PgEventstore
         # @return [Array<String>]
         def extract_event_types_filter(options)
           options in { filter: { event_types: Array => event_types } }
-          event_types = event_types&.select do
-            _1.is_a?(String)
-          end
+          event_types = event_types&.select { _1.is_a?(String) }
           event_types || []
         end
 
@@ -92,10 +90,10 @@ module PgEventstore
         # @return [Array<Hash[Symbol, String]>]
         def extract_streams_filter(options)
           options in { filter: { streams: Array => streams } }
-          streams = streams&.map do
-            _1 in { context: String | NilClass => context }
-            _1 in { stream_name: String | NilClass => stream_name }
-            _1 in { stream_id: String | NilClass => stream_id }
+          streams = streams&.map do |stream_attrs|
+            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 }
           end
           streams || []
@@ -123,7 +121,7 @@ module PgEventstore
         stream_attrs.compact!
         sql = stream_attrs.map do |attr, _|
           "#{to_table_name}.#{attr} = ?"
-        end.join(" AND ")
+        end.join(' AND ')
         @sql_builder.where_or(sql, *stream_attrs.values)
       end
 
@@ -133,8 +131,8 @@ module PgEventstore
         return if event_types.empty?
 
         sql = event_types.size.times.map do
-          "?"
-        end.join(", ")
+          '?'
+        end.join(', ')
         @sql_builder.where("#{to_table_name}.type IN (#{sql})", *event_types)
       end
 
@@ -178,9 +176,11 @@ module PgEventstore
 
       # @param table_name [String] system stream view name
       # @return [void]
+      # rubocop:disable Naming/AccessorMethodName
       def set_source(table_name)
-        @sql_builder.from(%{ "#{PG::Connection.escape(table_name)}" #{to_table_name} })
+        @sql_builder.from(%( "#{PG::Connection.escape(table_name)}" #{to_table_name} ))
       end
+      # rubocop:enable Naming/AccessorMethodName
 
       private
 
@@ -192,7 +192,7 @@ module PgEventstore
           { context: String, stream_name: nil, stream_id: nil })
         return true if result
 
-        PgEventstore&.logger&.debug(<<~TEXT)
+        PgEventstore.logger&.debug(<<~TEXT)
           Ignoring unsupported stream filter format for searching #{stream_attrs.compact.inspect}. \
           See docs/reading_events.md docs for supported formats.
         TEXT

data/lib/pg_eventstore/query_builders/partitions_filtering.rb

@@ -13,9 +13,7 @@ module PgEventstore
         # @return [Array<String>]
         def extract_event_types_filter(options)
           options in { filter: { event_types: Array => event_types } }
-          event_types = event_types&.select do
-            _1.is_a?(String)
-          end
+          event_types = event_types&.select { _1.is_a?(String) }
           event_types || []
         end
 
@@ -23,9 +21,9 @@ module PgEventstore
         # @return [Array<Hash[Symbol, String]>]
         def extract_streams_filter(options)
           options in { filter: { streams: Array => streams } }
-          streams = streams&.map do
-            _1 in { context: String | NilClass => context }
-            _1 in { stream_name: String | NilClass => stream_name }
+          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 }
           end
           streams || []
@@ -47,7 +45,7 @@ module PgEventstore
         stream_attrs.compact!
         sql = stream_attrs.map do |attr, _|
           "#{to_table_name}.#{attr} = ?"
-        end.join(" AND ")
+        end.join(' AND ')
         @sql_builder.where_or(sql, *stream_attrs.values)
       end
 
@@ -72,7 +70,7 @@ module PgEventstore
         result = (stream_attrs in { context: String, stream_name: String } | { context: String, stream_name: nil })
         return true if result
 
-        PgEventstore&.logger&.debug(<<~TEXT)
+        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

data/lib/pg_eventstore/rspec/has_option_matcher.rb

@@ -27,9 +27,7 @@ RSpec::Matchers.define :has_option do |option_name|
       is_correct &&=
         RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(obj.class.allocate.public_send(option_name))
     end
-    if defined?(@metadata)
-      is_correct &&= RSpec::Matchers::BuiltIn::Match.new(@metadata).matches?(option.metadata)
-    end
+    is_correct &&= RSpec::Matchers::BuiltIn::Match.new(@metadata).matches?(option.metadata) if defined?(@metadata)
     is_correct
   end
 
@@ -42,23 +40,24 @@ RSpec::Matchers.define :has_option do |option_name|
     message = "Expected #{obj.class} to have `#{option_name.inspect}' option"
     message += " #{default_value_message}," if defined?(@default_value)
     message += " #{metadata_message}," if defined?(@metadata)
-    message += "," unless defined?(@metadata) || defined?(@default_value)
+    message += ',' unless defined?(@metadata) || defined?(@default_value)
     if option_presence
       actual_default_value = obj.class.allocate.public_send(option_name)
       actual_metadata = option.metadata
       default_value_matches = RSpec::Matchers::BuiltIn::Match.new(@default_value).matches?(actual_default_value)
       metadata_matches = RSpec::Matchers::BuiltIn::Match.new(@metadata).matches?(actual_metadata)
 
-      case [default_value_matches, metadata_matches]
-      when [false, true]
-        message += " but default value is #{actual_default_value.inspect}"
-      when [true, false]
-        message += " but metadata is #{actual_metadata.inspect}"
-      else
-        message += " but default value is #{actual_default_value.inspect} and metadata is #{actual_metadata.inspect}"
-      end
+      message +=
+        case [default_value_matches, metadata_matches]
+        when [false, true]
+          " but default value is #{actual_default_value.inspect}"
+        when [true, false]
+          " but metadata is #{actual_metadata.inspect}"
+        else
+          " but default value is #{actual_default_value.inspect} and metadata is #{actual_metadata.inspect}"
+        end
     else
-      message += " but there is no option found with the given name"
+      message += ' but there is no option found with the given name'
     end
     message
   end

data/lib/pg_eventstore/rspec/test_helpers.rb

@@ -20,11 +20,12 @@ module PgEventstore
       def clean_up_data
         tables_to_purge = PgEventstore.connection.with do |conn|
           conn.exec(<<~SQL)
-            SELECT tablename 
-            FROM pg_catalog.pg_tables 
+            SELECT tablename
+            FROM pg_catalog.pg_tables
             WHERE schemaname NOT IN ('pg_catalog', 'information_schema') AND tablename != 'migrations'
           SQL
-        end.map { |attrs| attrs['tablename'] }
+        end
+        tables_to_purge = tables_to_purge.map { |attrs| attrs['tablename'] }
         tables_to_purge.each do |table_name|
           PgEventstore.connection.with { |c| c.exec("DELETE FROM #{table_name}") }
         end

data/lib/pg_eventstore/sql_builder.rb

@@ -14,6 +14,13 @@ module PgEventstore
       end
     end
 
+    # @return [Array<Object>] sql positional values
+    attr_reader :positional_values
+    # @return [Integer]
+    attr_writer :positional_values_size
+
+    protected :positional_values, :positional_values_size=
+
     def initialize
       @select_values = []
       @from_value = nil
@@ -134,17 +141,6 @@ module PgEventstore
 
     protected
 
-    # @return [Array<Object>] sql positional values
-    def positional_values
-      @positional_values
-    end
-
-    # @param val [Integer]
-    # @return [Integer]
-    def positional_values_size=(val)
-      @positional_values_size = val
-    end
-
     # @return [Array<String, Array<Object>>]
     def _to_exec_params
       return [single_query_sql, @positional_values] if @union_values.empty?
@@ -196,7 +192,7 @@ module PgEventstore
 
     # @return [String]
     def join_sql
-      @join_values.map { |sql, args| extract_positional_args(sql, *args) }.join(" ")
+      @join_values.map { |sql, args| extract_positional_args(sql, *args) }.join(' ')
     end
 
     # @return [String]
@@ -208,7 +204,7 @@ module PgEventstore
     # @param sql [String]
     # @return [String]
     def extract_positional_args(sql, *arguments)
-      sql.gsub("?").each_with_index do |_, index|
+      sql.gsub('?').each_with_index do |_, index|
         @positional_values.push(arguments[index])
         @positional_values_size += 1
         "$#{@positional_values_size}"

data/lib/pg_eventstore/stream.rb

@@ -83,20 +83,20 @@ module PgEventstore
       to_hash.hash
     end
 
-    # @param another [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def eql?(another)
-      return false unless another.is_a?(Stream)
+    def eql?(other)
+      return false unless other.is_a?(Stream)
 
-      hash == another.hash
+      hash == other.hash
     end
 
-    # @param other_stream [Object]
+    # @param other [Object]
     # @return [Boolean]
-    def ==(other_stream)
-      return false unless other_stream.is_a?(Stream)
+    def ==(other)
+      return false unless other.is_a?(Stream)
 
-      to_hash == other_stream.to_hash
+      to_hash == other.to_hash
     end
   end
 end

data/lib/pg_eventstore/subscriptions/basic_runner.rb

@@ -184,6 +184,7 @@ module PgEventstore
                 halt = true
               end
               break if halt
+
               sleep 0.1
             end
           end
@@ -223,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, &_blk)
       synchronize do
         return unless @state.public_send("#{RunnerState::STATES.fetch(state)}?")
 
@@ -247,8 +248,8 @@ module PgEventstore
 
     private
 
-    def synchronize
-      @mutex.synchronize { yield }
+    def synchronize(&blk)
+      @mutex.synchronize(&blk)
     end
 
     # @return [void]

data/lib/pg_eventstore/subscriptions/commands_handler.rb

@@ -35,7 +35,7 @@ module PgEventstore
     def attach_runner_callbacks
       @basic_runner.define_callback(
         :process_async, :before,
-      CommandsHandlerHandlers.setup_handler(:process_feeder_commands, @config_name, @subscription_feeder)
+        CommandsHandlerHandlers.setup_handler(:process_feeder_commands, @config_name, @subscription_feeder)
       )
       @basic_runner.define_callback(
         :process_async, :before,

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -28,7 +28,7 @@ module PgEventstore
     # @param raw_events [Array<Hash>]
     # @return [void]
     def feed(raw_events)
-      raise EmptyChunkFedError.new("Empty chunk was fed!") if raw_events.empty?
+      raise EmptyChunkFedError.new('Empty chunk was fed!') if raw_events.empty?
 
       within_state(:running) do
         callbacks.run_callbacks(:feed, Utils.original_global_position(raw_events.last))

data/lib/pg_eventstore/subscriptions/extensions/base_command_extension.rb

@@ -18,9 +18,11 @@ module PgEventstore
       module ClassMethods
         # @param data [Hash]
         # @return [Hash]
+        # rubocop:disable Lint/UnusedMethodArgument
         def parse_data(data)
           {}
         end
+        # rubocop:enable Lint/UnusedMethodArgument
       end
 
       # @return [Integer]
@@ -28,20 +30,20 @@ module PgEventstore
         options_hash.hash
       end
 
-      # @param another [Object]
+      # @param other [Object]
       # @return [Boolean]
-      def eql?(another)
-        return false unless another.is_a?(self.class)
+      def eql?(other)
+        return false unless other.is_a?(self.class)
 
-        hash == another.hash
+        hash == other.hash
       end
 
-      # @param another [Object]
+      # @param other [Object]
       # @return [Boolean]
-      def ==(another)
-        return false unless another.is_a?(self.class)
+      def ==(other)
+        return false unless other.is_a?(self.class)
 
-        options_hash == another.options_hash
+        options_hash == other.options_hash
       end
     end
   end

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

@@ -20,8 +20,17 @@ module PgEventstore
     # @return [PgEventstore::SubscriptionRunnerCommands::Base]
     def find_or_create_by(subscription_id:, subscriptions_set_id:, command_name:, data:)
       transaction_queries.transaction do
-        find_by(subscription_id: subscription_id, subscriptions_set_id: subscriptions_set_id, command_name: command_name) ||
-          create(subscription_id: subscription_id, subscriptions_set_id: subscriptions_set_id, command_name: command_name, data: data)
+        existing = find_by(
+          subscription_id: subscription_id, subscriptions_set_id: subscriptions_set_id, command_name: command_name
+        )
+        next existing if existing
+
+        create(
+          subscription_id: subscription_id,
+          subscriptions_set_id: subscriptions_set_id,
+          command_name: command_name,
+          data: data
+        )
       end
     end
 
@@ -30,18 +39,15 @@ module PgEventstore
     # @param command_name [String]
     # @return [PgEventstore::SubscriptionRunnerCommands::Base, nil]
     def find_by(subscription_id:, subscriptions_set_id:, command_name:)
-      sql_builder =
-        SQLBuilder.new.
-          select('*').
-          from('subscription_commands').
-          where(
-            'subscription_id = ? AND subscriptions_set_id = ? AND name = ?',
-            subscription_id, subscriptions_set_id, command_name
-          )
+      sql_builder = SQLBuilder.new.select('*').from('subscription_commands')
+      sql_builder.where(
+        'subscription_id = ? AND subscriptions_set_id = ? AND name = ?',
+        subscription_id, subscriptions_set_id, command_name
+      )
       pg_result = connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end
-      return if pg_result.ntuples.zero?
+      return if pg_result.ntuples == 0
 
       deserialize(pg_result.to_a.first)
     end
@@ -53,7 +59,7 @@ module PgEventstore
     # @return [PgEventstore::SubscriptionRunnerCommands::Base]
     def create(subscription_id:, subscriptions_set_id:, command_name:, data:)
       sql = <<~SQL
-        INSERT INTO subscription_commands (name, subscription_id, subscriptions_set_id, data) 
+        INSERT INTO subscription_commands (name, subscription_id, subscriptions_set_id, data)
           VALUES ($1, $2, $3, $4)
           RETURNING *
       SQL
@@ -69,15 +75,11 @@ module PgEventstore
     def find_commands(subscription_ids, subscriptions_set_id:)
       return [] if subscription_ids.empty?
 
-      sql = subscription_ids.size.times.map do
-        "?"
-      end.join(", ")
-      sql_builder =
-        SQLBuilder.new.select('*').
-          from('subscription_commands').
-          where("subscription_id IN (#{sql})", *subscription_ids).
-          where("subscriptions_set_id = ?", subscriptions_set_id).
-          order('id ASC')
+      sql = subscription_ids.size.times.map { '?' }.join(', ')
+      sql_builder = SQLBuilder.new.select('*').from('subscription_commands')
+      sql_builder.where("subscription_id IN (#{sql})", *subscription_ids)
+      sql_builder.where('subscriptions_set_id = ?', subscriptions_set_id)
+      sql_builder.order('id ASC')
       pg_result = connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end

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

@@ -28,7 +28,7 @@ module PgEventstore
       pg_result = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
       end
-      return if pg_result.ntuples.zero?
+      return if pg_result.ntuples == 0
 
       deserialize(pg_result.to_a.first)
     end
@@ -40,7 +40,7 @@ module PgEventstore
       pg_result = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
       end
-      return [] if pg_result.ntuples.zero?
+      return [] if pg_result.ntuples == 0
 
       pg_result.map(&method(:deserialize))
     end
@@ -50,24 +50,25 @@ module PgEventstore
     def set_collection(state = nil)
       builder = SQLBuilder.new.from('subscriptions').select('set').group('set').order('set ASC')
       builder.where('state = ?', state) if state
-      connection.with do |conn|
+      raw_subscriptions = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
-      end.map { |attrs| attrs['set'] }
+      end
+      raw_subscriptions.map { |attrs| attrs['set'] }
     end
 
     # @param id [Integer]
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new("subscriptions", id))
+      find_by(id: id) || raise(RecordNotFound.new('subscriptions', id))
     end
 
     # @param attrs [Hash]
     # @return [Hash]
     def create(attrs)
       sql = <<~SQL
-        INSERT INTO subscriptions (#{attrs.keys.join(', ')}) 
-          VALUES (#{Utils.positional_vars(attrs.values)}) 
+        INSERT INTO subscriptions (#{attrs.keys.join(', ')})
+          VALUES (#{Utils.positional_vars(attrs.values)})
           RETURNING *
       SQL
       pg_result = connection.with do |conn|
@@ -93,13 +94,14 @@ module PgEventstore
         pg_result = connection.with do |conn|
           conn.exec_params(sql, [*attrs.values, id])
         end
-        raise(RecordNotFound.new("subscriptions", id)) if pg_result.ntuples.zero?
+        raise(RecordNotFound.new('subscriptions', id)) if pg_result.ntuples == 0
 
         updated_attrs = pg_result.to_a.first
         unless updated_attrs['locked_by'] == locked_by
           # Subscription is force-locked by someone else. We have to roll back such transaction
           raise(WrongLockIdError.new(updated_attrs['set'], updated_attrs['name'], updated_attrs['locked_by']))
         end
+
         updated_attrs
       end
 
@@ -152,6 +154,7 @@ module PgEventstore
         if attrs[:locked_by] && !force
           raise SubscriptionAlreadyLockedError.new(attrs[:set], attrs[:name], attrs[:locked_by])
         end
+
         connection.with do |conn|
           conn.exec_params('UPDATE subscriptions SET locked_by = $1 WHERE id = $2', [lock_id, id])
         end

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

@@ -28,15 +28,12 @@ module PgEventstore
     # @param command_name [String]
     # @return [PgEventstore::SubscriptionFeederCommands::Base, nil]
     def find_by(subscriptions_set_id:, command_name:)
-      sql_builder =
-        SQLBuilder.new.
-          select('*').
-          from('subscriptions_set_commands').
-          where('subscriptions_set_id = ? AND name = ?', subscriptions_set_id, command_name)
+      sql_builder = SQLBuilder.new.select('*').from('subscriptions_set_commands')
+      sql_builder.where('subscriptions_set_id = ? AND name = ?', subscriptions_set_id, command_name)
       pg_result = connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end
-      return if pg_result.ntuples.zero?
+      return if pg_result.ntuples == 0
 
       deserialize(pg_result.to_a.first)
     end
@@ -47,7 +44,7 @@ module PgEventstore
     # @return [PgEventstore::SubscriptionFeederCommands::Base]
     def create(subscriptions_set_id:, command_name:, data:)
       sql = <<~SQL
-        INSERT INTO subscriptions_set_commands (name, subscriptions_set_id, data) 
+        INSERT INTO subscriptions_set_commands (name, subscriptions_set_id, data)
           VALUES ($1, $2, $3)
           RETURNING *
       SQL
@@ -56,17 +53,15 @@ module PgEventstore
       end
       deserialize(pg_result.to_a.first)
     rescue PG::ForeignKeyViolation
-      raise RecordNotFound.new("subscriptions_set", subscriptions_set_id)
+      raise RecordNotFound.new('subscriptions_set', subscriptions_set_id)
     end
 
     # @param subscriptions_set_id [Integer, nil]
     # @return [Array<PgEventstore::SubscriptionFeederCommands::Base>]
     def find_commands(subscriptions_set_id)
-      sql_builder =
-        SQLBuilder.new.select('*').
-          from('subscriptions_set_commands').
-          where("subscriptions_set_id = ?", subscriptions_set_id).
-          order('id ASC')
+      sql_builder = SQLBuilder.new.select('*').from('subscriptions_set_commands')
+      sql_builder.where('subscriptions_set_id = ?', subscriptions_set_id)
+      sql_builder.order('id ASC')
       pg_result = connection.with do |conn|
         conn.exec_params(*sql_builder.to_exec_params)
       end

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

@@ -46,9 +46,10 @@ module PgEventstore
     def set_names
       builder = SQLBuilder.new.select('name').from('subscriptions_set').group('name').order('name ASC')
 
-      connection.with do |conn|
+      raw_set = connection.with do |conn|
         conn.exec_params(*builder.to_exec_params)
-      end.map { |attrs| attrs['name'] }
+      end
+      raw_set.map { |attrs| attrs['name'] }
     end
 
     # The same as #find_all, but returns first result
@@ -61,15 +62,15 @@ module PgEventstore
     # @return [Hash]
     # @raise [PgEventstore::RecordNotFound]
     def find!(id)
-      find_by(id: id) || raise(RecordNotFound.new("subscriptions_set", id))
+      find_by(id: id) || raise(RecordNotFound.new('subscriptions_set', id))
     end
 
     # @param attrs [Hash]
     # @return [Hash]
     def create(attrs)
       sql = <<~SQL
-        INSERT INTO subscriptions_set (#{attrs.keys.join(', ')}) 
-          VALUES (#{Utils.positional_vars(attrs.values)}) 
+        INSERT INTO subscriptions_set (#{attrs.keys.join(', ')})
+          VALUES (#{Utils.positional_vars(attrs.values)})
           RETURNING *
       SQL
       pg_result = connection.with do |conn|
@@ -92,7 +93,7 @@ module PgEventstore
       pg_result = connection.with do |conn|
         conn.exec_params(sql, [*attrs.values, id])
       end
-      raise(RecordNotFound.new("subscriptions_set", id)) if pg_result.ntuples.zero?
+      raise(RecordNotFound.new('subscriptions_set', id)) if pg_result.ntuples == 0
 
       deserialize(pg_result.to_a.first)
     end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_connection.rb

@@ -17,9 +17,10 @@ module PgEventstore
       end
 
       def recovers?(error)
-        EXCEPTIONS_TO_HANDLE.any? {error.is_a?(_1) }
+        EXCEPTIONS_TO_HANDLE.any? { error.is_a?(_1) }
       end
 
+      # rubocop:disable Lint/SuppressedException
       def recover(_error)
         loop do
           sleep TIME_BETWEEN_RETRIES
@@ -32,6 +33,7 @@ module PgEventstore
         rescue *EXCEPTIONS_TO_HANDLE
         end
       end
+      # rubocop:enable Lint/SuppressedException
 
       private
 

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies/restore_subscription_runner.rb

@@ -21,6 +21,7 @@ module PgEventstore
 
       def recover(error)
         return false if @restart_terminator&.call(@subscription.dup)
+
         if @subscription.restart_count >= @subscription.max_restarts_number
           @failed_subscription_notifier&.call(@subscription.dup, Utils.unwrap_exception(error))
           return false