pg_eventstore 1.1.5 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fce9f1f61310bfc9c12afdb89b0a6589e9116133255eeb62ac406b24e351b72
-  data.tar.gz: 0a03a441f9e26a040f026fc7fac5d034c81b91d6f0e0bee98646b39a2f809147
+  metadata.gz: 8691b2cf8e831e31da17b71fc06078a25d73ae1e7e1a0b9da629a481a4947842
+  data.tar.gz: 9022a6bdac6ef9aadc7338b54fe5a9fea76cdcb5ea7f2a7dc78fdcd98b2f469b
 SHA512:
-  metadata.gz: 26a0a9b9cf70e32fd73d5f729d5d9654ec23cd90aa57a3bfdf4cae5603f58d56d62a1406df477200390497141e5c4bb89f157c749bd1df680c1b404898428094
-  data.tar.gz: 85aeeffcfc9ddfba2733e7362958a9d1528eb043ae5025c2d8bd055aa708e5c20eb2fef555be711174f3c058235c0f5b97c780b9f68b3a52e92592fe58d8f8c3
+  metadata.gz: 0efd8f80acbee784665bfc455239ea02b336335e2d6f36341ea65d86f973b126794f306373b66b6383cd74ba12b8566b2544bda9ebf5efc9d7d1d3611c6276e3
+  data.tar.gz: 31c54e37a0fae15add5af3c03ff8c4a6db41812feb8012bca2f242d245da863c4c99b78465eb39684bdf4259d8eff675493cc690c54a31e49fc15b06e941c42c

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 ## [Unreleased]
 
+## [1.3.0]
+- Add ability to filter subscriptions by state in admin UI
+- Reset error-related subscription's attributes on subscription restore
+- Reset total processed events number when user changes subscription's position
+- Allow to search event type, stream context and stream name by substring in web UI
+- Relax sinatra version requirement to v3+
+
+## [1.2.0]
+- Implement `failed_subscription_notifier` subscription hook.
+
+Now you are able to define a function that is called when subscription fails and no longer can be automatically restarted because it hit max number of retries. You can define the hook globally in the config and per subscription. Examples:
+
+```ruby
+PgEventstore.configure do |config|
+  config.failed_subscription_notifier = proc { |sub, error| puts "Subscription: #{sub.inspect}, error: #{error.inspect}" }
+end
+
+subscriptions_manager = PgEventstore.subscriptions_manager(subscription_set: 'MyApp')
+# Overrides config.failed_subscription_notifier function
+subscriptions_manager.subscribe(
+  'My Subscription 1',
+  handler: Handler.new('My Subscription 1'),
+  options: { filter: { event_types: ['Foo'] } },
+  failed_subscription_notifier: proc { |_subscription, err| p err }
+)
+# Uses config.failed_subscription_notifier function
+subscriptions_manager.subscribe(
+  'My Subscription 2',
+  handler: Handler.new('My Subscription 2'),
+  options: { filter: { event_types: ['Bar'] } }
+)
+```
+
 ## [1.1.5]
 - Review the way to handle SubscriptionAlreadyLockedError error. This removes noise when attempting to lock an already locked subscription. 
 

data/docs/configuration.md

@@ -16,6 +16,7 @@ Configuration options:
 | subscriptions_set_max_retries      | Integer | `10`                                                         | Max number of retries for failed subscription sets.                                                                                                                                                                                                                                                                    |
 | subscriptions_set_retries_interval | Integer | `1`                                                          | Interval in seconds between retries of failed subscription sets.                                                                                                                                                                                                                                                       |
 | subscription_restart_terminator    | `#call` | `nil`                                                        | A callable object that accepts `PgEventstore::Subscription` object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts).                                                                                                                                                 |
+| failed_subscription_notifier       | `#call` | `nil`                                                        | A callable object which is invoked with `PgEventstore::Subscription` instance and error instance after the related subscription died due to error and no longer can be automatically restarted due to max retries number reached. You can use this hook to send a notification about failed subscription.              |
 
 ## Multiple configurations
 

data/docs/subscriptions.md

@@ -151,7 +151,7 @@ You will then see the output of your subscription handlers. To gracefully stop t
 
 ## Overriding Subscription config values
 
-You can override `subscription_pull_interval`, `subscription_max_retries`, `subscription_retries_interval` and `subscription_restart_terminator` config values (see [**Configuration**](configuration.md) chapter for details) for the specific subscription by providing the corresponding arguments. Example:
+You can override `subscription_pull_interval`, `subscription_max_retries`, `subscription_retries_interval`, `subscription_restart_terminator` and `failed_subscription_notifier` config values (see [**Configuration**](configuration.md) chapter for details) for the specific subscription by providing the corresponding arguments. Example:
 
 ```ruby
 subscriptions_manager.subscribe(
@@ -164,7 +164,9 @@ subscriptions_manager.subscribe(
   # overrides config.subscription_retries_interval
   retries_interval: 2,
   # overrides config.subscription_restart_terminator
-  restart_terminator: proc { |subscription| subscription.last_error['class'] == 'NoMethodError' }, 
+  restart_terminator: proc { |subscription| subscription.last_error['class'] == 'NoMethodError' },
+  # overrides config.failed_subscription_notifier
+  failed_subscription_notifier: proc { |_subscription, err| p err }
 )
 ```
 

data/lib/pg_eventstore/config.rb

@@ -48,6 +48,10 @@ module PgEventstore
     # @!attribute subscriptions_set_retries_interval
     #   @return [Integer] interval in seconds between retries of failed SubscriptionsSet
     option(:subscriptions_set_retries_interval) { 1 }
+    # @!attribute failed_subscription_notifier
+    #   @return [#call, nil] provide callable object that accepts Subscription instance and error. It is useful when you
+    #     want to be get notified when your Subscription fails and no longer can be restarted
+    option(:failed_subscription_notifier)
 
     # @param name [Symbol] config's name. Its value matches the appropriate key in PgEventstore.config hash
     def initialize(name:, **options)

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

@@ -45,10 +45,13 @@ module PgEventstore
       pg_result.map(&method(:deserialize))
     end
 
+    # @param state [String, nil]
     # @return [Array<String>]
-    def set_collection
+    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|
-        conn.exec('SELECT set FROM subscriptions GROUP BY set ORDER BY set ASC')
+        conn.exec_params(*builder.to_exec_params)
       end.map { |attrs| attrs['set'] }
     end
 

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

@@ -27,6 +27,21 @@ module PgEventstore
       pg_result.to_a.map(&method(:deserialize))
     end
 
+    # @param name [String, nil]
+    # @param state [String]
+    # @return [Array<Hash>]
+    def find_all_by_subscription_state(name:, state:)
+      builder = SQLBuilder.new.select('subscriptions_set.*').from('subscriptions_set')
+      builder.join('JOIN subscriptions ON subscriptions.locked_by = subscriptions_set.id')
+      builder.order('subscriptions_set.name ASC, subscriptions_set.id ASC')
+      builder.where('subscriptions_set.name = ? and subscriptions.state = ?', name, state)
+      builder.group('subscriptions_set.id')
+      pg_result = connection.with do |conn|
+        conn.exec_params(*builder.to_exec_params)
+      end
+      pg_result.to_a.map(&method(:deserialize))
+    end
+
     # @return [Array<String>]
     def set_names
       builder = SQLBuilder.new.select('name').from('subscriptions_set').group('name').order('name ASC')

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -29,11 +29,14 @@ module PgEventstore
     # @param events_processor [PgEventstore::EventsProcessor]
     # @param subscription [PgEventstore::Subscription]
     # @param restart_terminator [#call, nil]
-    def initialize(stats:, events_processor:, subscription:, restart_terminator: nil)
+    # @param failed_subscription_notifier [#call, nil]
+    def initialize(stats:, events_processor:, subscription:, restart_terminator: nil,
+                   failed_subscription_notifier: nil)
       @stats = stats
       @events_processor = events_processor
       @subscription = subscription
       @restart_terminator = restart_terminator
+      @failed_subscription_notifier = failed_subscription_notifier
 
       attach_callbacks
     end
@@ -119,11 +122,13 @@ module PgEventstore
       @subscription.update(last_chunk_fed_at: Time.now.utc, last_chunk_greatest_position: global_position)
     end
 
-    # @param _error [StandardError]
+    # @param error [StandardError]
     # @return [void]
-    def restart_subscription(_error)
+    def restart_subscription(error)
       return if @restart_terminator&.call(@subscription.dup)
-      return if @subscription.restart_count >= @subscription.max_restarts_number
+      if @subscription.restart_count >= @subscription.max_restarts_number
+        return @failed_subscription_notifier&.call(@subscription.dup, error)
+      end
 
       Thread.new do
         sleep @subscription.time_between_restarts

data/lib/pg_eventstore/subscriptions/subscription_runner_commands/reset_position.rb

@@ -17,7 +17,9 @@ module PgEventstore
       def exec_cmd(subscription_runner)
         subscription_runner.within_state(:stopped) do
           subscription_runner.clear_chunk
-          subscription_runner.subscription.update(last_chunk_greatest_position: nil, current_position: data['position'])
+          subscription_runner.subscription.update(
+            last_chunk_greatest_position: nil, current_position: data['position'], total_processed_events: 0
+          )
         end
       end
     end

data/lib/pg_eventstore/subscriptions/subscription_runner_commands/restore.rb

@@ -7,6 +7,14 @@ module PgEventstore
       # @param subscription_runner [PgEventstore::SubscriptionRunner]
       # @return [void]
       def exec_cmd(subscription_runner)
+        subscription_runner.within_state(:dead) do
+          subscription_runner.subscription.update(
+            restart_count: 0,
+            last_restarted_at: nil,
+            last_error: nil,
+            last_error_occurred_at: nil
+          )
+        end
         subscription_runner.restore
       end
     end

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -61,14 +61,19 @@ module PgEventstore
     #   given subscription.
     # @param max_retries [Integer] max number of retries of failed Subscription
     # @param retries_interval [Integer, Float] a delay between retries of failed Subscription
-    # @param restart_terminator [#call, nil] a callable object which, when called - accepts PgEventstore::Subscription
-    #   object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    # @param restart_terminator [#call, nil] a callable object which is invoked with PgEventstore::Subscription instance
+    #   to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    # @param failed_subscription_notifier [#call, nil] a callable object which is invoked with
+    #   PgEventstore::Subscription instance and error instance after the related subscription died due to error and no
+    #   longer can be automatically restarted due to max retries number reached. You can use this hook to send a
+    #   notification about failed subscription.
     # @return [void]
     def subscribe(subscription_name, handler:, options: {}, middlewares: nil,
                   pull_interval: config.subscription_pull_interval,
                   max_retries: config.subscription_max_retries,
                   retries_interval: config.subscription_retries_interval,
-                  restart_terminator: config.subscription_restart_terminator)
+                  restart_terminator: config.subscription_restart_terminator,
+                  failed_subscription_notifier: config.failed_subscription_notifier)
       subscription = Subscription.using_connection(config.name).new(
         set: @set_name, name: subscription_name, options: options, chunk_query_interval: pull_interval,
         max_restarts_number: max_retries, time_between_restarts: retries_interval
@@ -77,7 +82,8 @@ module PgEventstore
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(create_event_handler(middlewares, handler)),
         subscription: subscription,
-        restart_terminator: restart_terminator
+        restart_terminator: restart_terminator,
+        failed_subscription_notifier: failed_subscription_notifier
       )
 
       @subscription_feeder.add(runner)

data/lib/pg_eventstore/version.rb

@@ -2,5 +2,5 @@
 
 module PgEventstore
   # @return [String]
-  VERSION = "1.1.5"
+  VERSION = "1.3.0"
 end

data/lib/pg_eventstore/web/application.rb

@@ -102,6 +102,22 @@ module PgEventstore
         erb :'subscriptions/index'
       end
 
+      get '/subscriptions/:state' do
+        @set_collection = Subscriptions::WithState::SetCollection.new(connection, state: params[:state])
+        @current_set = params[:set_name] || @set_collection.names.first
+        subscriptions_set = Subscriptions::WithState::SubscriptionsSet.new(
+          connection, @current_set, state: params[:state]
+        ).subscriptions_set
+        subscriptions = Subscriptions::WithState::Subscriptions.new(
+          connection, @current_set, state: params[:state]
+        ).subscriptions
+        @association = Subscriptions::SubscriptionsToSetAssociation.new(
+          subscriptions_set: subscriptions_set,
+          subscriptions: subscriptions
+        )
+        erb :'subscriptions/index'
+      end
+
       post '/change_config' do
         config = params[:config]&.to_sym
         config = :default unless PgEventstore.available_configs.include?(config)

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

@@ -16,7 +16,7 @@ module PgEventstore
                   where('context is not null and stream_name is not null').
                   group('event_type').order("event_type #{order}").limit(per_page)
               sql_builder.where("event_type #{direction_operator} ?", starting_id) if starting_id
-              sql_builder.where('event_type ilike ?', "#{options[:query]}%")
+              sql_builder.where('event_type ilike ?', "%#{options[:query]}%")
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
               end.to_a
@@ -32,7 +32,7 @@ module PgEventstore
             SQLBuilder.new.select('event_type').from('partitions').
               where('context is not null and stream_name is not null').
               where("event_type #{direction_operator} ?", starting_id).
-              where('event_type ilike ?', "#{options[:query]}%").
+              where('event_type ilike ?', "%#{options[:query]}%").
               group('event_type').order("event_type #{order}").limit(1).offset(per_page)
 
           connection.with do |conn|

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

@@ -12,10 +12,11 @@ module PgEventstore
           @_collection ||=
             begin
               sql_builder =
-                SQLBuilder.new.select('context').from('partitions').where('stream_name is null and event_type is null')
-                          .limit(per_page).order("context #{order}")
+                SQLBuilder.new.select('context').from('partitions').
+                  where('stream_name is null and event_type is null').
+                  limit(per_page).order("context #{order}")
               sql_builder.where("context #{direction_operator} ?", starting_id) if starting_id
-              sql_builder.where('context ilike ?', "#{options[:query]}%")
+              sql_builder.where('context ilike ?', "%#{options[:query]}%")
               connection.with do |conn|
                 conn.exec_params(*sql_builder.to_exec_params)
               end.to_a
@@ -29,7 +30,7 @@ module PgEventstore
           starting_id = collection.first['context']
           sql_builder =
             SQLBuilder.new.select('context').from('partitions').where('stream_name is null and event_type is null').
-              where("context #{direction_operator} ?", starting_id).where('context ilike ?', "#{options[:query]}%").
+              where("context #{direction_operator} ?", starting_id).where('context ilike ?', "%#{options[:query]}%").
               limit(1).offset(per_page).order("context #{order}")
 
           connection.with do |conn|

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

@@ -14,7 +14,7 @@ module PgEventstore
               sql_builder =
                 SQLBuilder.new.select('stream_name').from('partitions').
                   where('event_type is null and context = ?', options[:context]).
-                  where('stream_name ilike ?', "#{options[:query]}%")
+                  where('stream_name ilike ?', "%#{options[:query]}%")
               sql_builder.where("stream_name #{direction_operator} ?", starting_id) if starting_id
               sql_builder.limit(per_page).order("stream_name #{order}")
               connection.with do |conn|
@@ -31,7 +31,7 @@ module PgEventstore
           sql_builder =
             SQLBuilder.new.select('stream_name').from('partitions').
               where("stream_name #{direction_operator} ?", starting_id).
-              where('stream_name ilike ?', "#{options[:query]}%").
+              where('stream_name ilike ?', "%#{options[:query]}%").
               where('event_type is null and context = ?', options[:context]).
               limit(1).offset(per_page).order("stream_name #{order}")
 

data/lib/pg_eventstore/web/public/javascripts/pg_eventstore.js

@@ -215,3 +215,14 @@ $(function(){
         $(this).find('form').attr('action', $clickedLink.data('url'));
     });
 });
+
+// Display subscriptions of the selected state
+$(function(){
+    "use strict";
+
+    let $subscriptionsState = $('#subscriptions-state');
+    $subscriptionsState.change(function(){
+       let $selected = $(this).find('option:selected');
+       window.location.href = $selected.data('url');
+    });
+});

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

@@ -13,6 +13,21 @@ module PgEventstore
           url("/subscriptions?#{encoded_params}")
         end
 
+        # @param state [String]
+        # @return [String]
+        def subscriptions_state_url(state:, **params)
+          params = params.compact
+          return url("/subscriptions/#{state}") if params.empty?
+
+          encoded_params = Rack::Utils.build_nested_query(params)
+          url("/subscriptions/#{state}?#{encoded_params}")
+        end
+
+        # @return [String, nil]
+        def subscriptions_state
+          params[:state] if PgEventstore::RunnerState::STATES.include?(params[:state])
+        end
+
         # @param set_id [Integer]
         # @param id [Integer]
         # @param cmd [String]

data/lib/pg_eventstore/web/subscriptions/with_state/set_collection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class SetCollection
+          # @!attribute connection
+          #   @return [PgEventstore::Connection]
+          attr_reader :connection
+          private :connection
+
+          # @param connection [PgEventstore::Connection]
+          # @param state [String]
+          def initialize(connection, state:)
+            @connection = connection
+            @state = state
+          end
+
+          # @return [Array<String>]
+          def names
+            @set_collection ||= subscription_queries.set_collection(@state)
+          end
+
+          private
+
+          # @return [PgEventstore::SubscriptionQueries]
+          def subscription_queries
+            SubscriptionQueries.new(connection)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class Subscriptions
+          # @!attribute connection
+          #   @return [PgEventstore::Connection]
+          attr_reader :connection
+          private :connection
+
+          # @param connection [PgEventstore::Connection]
+          # @param current_set [String, nil]
+          # @param state [String]
+          def initialize(connection, current_set, state:)
+            @connection = connection
+            @current_set = current_set
+            @state = state
+          end
+
+          # @return [Array<PgEventstore::Subscription>]
+          def subscriptions
+            @subscriptions ||= subscription_queries.find_all(set: @current_set, state: @state).map do |attrs|
+              Subscription.new(**attrs)
+            end
+          end
+
+          private
+
+          # @return [PgEventstore::SubscriptionQueries]
+          def subscription_queries
+            SubscriptionQueries.new(connection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/subscriptions/with_state/subscriptions_set.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class SubscriptionsSet
+          # @!attribute connection
+          #   @return [PgEventstore::Connection]
+          attr_reader :connection
+          private :connection
+
+          # @param connection [PgEventstore::Connection]
+          # @param current_set [String, nil]
+          # @param state [String]
+          def initialize(connection, current_set, state:)
+            @connection = connection
+            @current_set = current_set
+            @state = state
+          end
+
+          # @return [Array<PgEventstore::SubscriptionsSet>]
+          def subscriptions_set
+            @subscriptions_set ||=
+              subscriptions_set_queries.find_all_by_subscription_state(name: @current_set, state: @state).map do |attrs|
+                PgEventstore::SubscriptionsSet.new(**attrs)
+              end
+          end
+
+          private
+
+          # @return [PgEventstore::SubscriptionsSetQueries]
+          def subscriptions_set_queries
+            SubscriptionsSetQueries.new(connection)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/web/views/subscriptions/index.erb

@@ -4,6 +4,18 @@
       <div class="title_left">
         <h3>Subscriptions</h3>
       </div>
+      <div class="title_right">
+        <div class="col-md-5 col-sm-5 form-group pull-right top_search">
+          <div class="input-group">
+            <select class="form-control" id="subscriptions-state" autocomplete="off">
+              <option value="" data-url="<%= subscriptions_url %>" <% unless subscriptions_state %> selected <% end %>>All</option>
+              <% PgEventstore::RunnerState::STATES.values.each do |state| %>
+                <option value="<%= state %>" <% if state == subscriptions_state %> selected <% end %> data-url="<%= subscriptions_state_url(state: state) %>"><%= state.capitalize %></option>
+              <% end %>
+            </select>
+          </div>
+        </div>
+      </div>
     </div>
 
     <div class="clearfix"></div>
@@ -11,7 +23,7 @@
     <ul class="nav nav-tabs bg-white">
       <% @set_collection.names.each do |set_name| %>
         <li class="nav-item">
-          <a class="nav-link <%= "active bg-dark text-white" if @current_set == set_name %>" href="<%= subscriptions_url(set_name: set_name) %>">
+          <a class="nav-link <%= "active bg-dark text-white" if @current_set == set_name %>" href="<%= subscriptions_state ? subscriptions_state_url(state: subscriptions_state, set_name: set_name) : subscriptions_url(set_name: set_name) %>">
             <%= set_name %>
           </a>
         </li>

data/lib/pg_eventstore/web.rb

@@ -13,6 +13,9 @@ require_relative 'web/subscriptions/set_collection'
 require_relative 'web/subscriptions/subscriptions'
 require_relative 'web/subscriptions/subscriptions_set'
 require_relative 'web/subscriptions/subscriptions_to_set_association'
+require_relative 'web/subscriptions/with_state/set_collection'
+require_relative 'web/subscriptions/with_state/subscriptions'
+require_relative 'web/subscriptions/with_state/subscriptions_set'
 require_relative 'web/subscriptions/helpers'
 require_relative 'web/application'
 

data/pg_eventstore.gemspec

@@ -37,5 +37,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "pg", "~> 1.5"
   spec.add_dependency "connection_pool", "~> 2.4"
-  spec.add_dependency "sinatra", "~> 4.0"
+  spec.add_dependency "sinatra", ">= 3", '< 5'
 end

data/sig/interfaces/failed_subscription_notifier.rbs

@@ -0,0 +1,3 @@
+interface _FailedSubscriptionNotifier
+  def call: (PgEventstore::Subscription subscription, StandardError error) -> void
+end

data/sig/pg_eventstore/config.rbs

@@ -44,6 +44,8 @@ module PgEventstore
 
     attr_accessor subscription_restart_terminator: _RestartTerminator?
 
+    attr_accessor failed_subscription_notifier: _FailedSubscriptionNotifier?
+
     attr_accessor subscriptions_set_max_retries: Integer
 
     attr_accessor subscriptions_set_retries_interval: Integer

data/sig/pg_eventstore/subscriptions/queries/subscription_queries.rbs

@@ -12,7 +12,7 @@ module PgEventstore
     # _@param_ `attrs`
     def find_all: (::Hash[untyped, untyped] attrs) -> ::Array[::Hash[untyped, untyped]]
 
-    def set_collection: () -> ::Array[String]
+    def set_collection: (?String? state) -> ::Array[String]
 
     # _@param_ `id`
     def find!: (Integer id) -> ::Hash[untyped, untyped]

data/sig/pg_eventstore/subscriptions/queries/subscriptions_set_queries.rbs

@@ -11,6 +11,8 @@ module PgEventstore
     # The same as #find_all, but returns first result
     def find_by: (::Hash[untyped, untyped] attrs) -> ::Hash[untyped, untyped]?
 
+    def find_all_by_subscription_state: (name: String?, state: String) -> ::Array[::Hash[untyped, untyped]]
+
     # _@param_ `id`
     def find!: (Integer id) -> ::Hash[untyped, untyped]
 

data/sig/pg_eventstore/subscriptions/subscription_runner.rbs

@@ -12,11 +12,14 @@ module PgEventstore
     # _@param_ `subscription`
     #
     # _@param_ `restart_terminator`
+    #
+    # _@param_ `failed_subscription_notifier`
     def initialize: (
         stats: PgEventstore::SubscriptionHandlerPerformance,
         events_processor: PgEventstore::EventsProcessor,
         subscription: PgEventstore::Subscription,
-        ?restart_terminator: _RestartTerminator?
+        ?restart_terminator: _RestartTerminator?,
+        ?failed_subscription_notifier: _FailedSubscriptionNotifier?
       ) -> void
 
     def next_chunk_query_opts: () -> ::Hash[untyped, untyped]
@@ -47,7 +50,7 @@ module PgEventstore
     def update_subscription_chunk_stats: (Integer global_position) -> void
 
     # _@param_ `_error`
-    def restart_subscription: (StandardError _error) -> void
+    def restart_subscription: (StandardError error) -> void
 
     # Returns the value of attribute subscription.
     attr_accessor subscription: PgEventstore::Subscription

data/sig/pg_eventstore/subscriptions/subscriptions_manager.rbs

@@ -30,7 +30,9 @@ module PgEventstore
     #
     # _@param_ `retries_interval` — a delay between retries of failed Subscription
     #
-    # _@param_ `restart_terminator` — a callable object which, when called - accepts PgEventstore::Subscription object to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    # _@param_ `restart_terminator` — a callable object which is invoked with PgEventstore::Subscription instance to determine whether restarts should be stopped(true - stops restarts, false - continues restarts)
+    #
+    # _@param_ `failed_subscription_notifier` - a callable object which is invoked with PgEventstore::Subscription instance and error instance after the related subscription died due to error and no longer can be automatically restarted due to max retries number reached. You can use this hook to send a notification about failed subscription.
     def subscribe: (
         String subscription_name,
         handler: _SubscriptionHandler,
@@ -39,7 +41,8 @@ module PgEventstore
         ?pull_interval: Integer | Float,
         ?max_retries: Integer,
         ?retries_interval: Integer | Float,
-        ?restart_terminator: _RestartTerminator?
+        ?restart_terminator: _RestartTerminator?,
+        ?failed_subscription_notifier: _FailedSubscriptionNotifier?
       ) -> void
 
     def subscriptions: () -> ::Array[PgEventstore::Subscription]

data/sig/pg_eventstore/web/subscriptions/helpers.rbs

@@ -5,6 +5,10 @@ module PgEventstore
         # _@param_ `set_name`
         def subscriptions_url: (?set_name: String?) -> String
 
+        def subscriptions_state_url: (state: String, **untyped params) -> String
+
+        def subscriptions_state: -> String?
+
         # _@param_ `set_id`
         #
         # _@param_ `id`

data/sig/pg_eventstore/web/subscriptions/with_state/set_collection.rbs

@@ -0,0 +1,21 @@
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class SetCollection
+          @state: String
+
+          attr_reader connection: PgEventstore::Connection
+
+          def initialize: (PgEventstore::Connection connection, state: String) -> void
+          
+          def names: -> Array[String]
+
+          private
+
+          def subscription_queries: -> PgEventstore::SubscriptionQueries
+        end
+      end
+    end
+  end
+end

data/sig/pg_eventstore/web/subscriptions/with_state/subscriptions.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class Subscriptions
+          @current_set: String?
+
+          @state: String
+
+          attr_reader connection: PgEventstore::Connection
+
+          def initialize: (PgEventstore::Connection connection, String? current_set, state: String) -> void
+
+          def subscriptions: -> Array[PgEventstore::Subscription]
+
+          private
+
+          def subscription_queries: -> PgEventstore::SubscriptionQueries
+        end
+      end
+    end
+  end
+end

data/sig/pg_eventstore/web/subscriptions/with_state/subscriptions_set.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module Web
+    module Subscriptions
+      module WithState
+        class SubscriptionsSet
+          @current_set: String?
+
+          @state: String
+
+          attr_reader connection: PgEventstore::Connection
+
+          def initialize: (PgEventstore::Connection connection, String? current_set, state: String) -> untyped
+
+          def subscriptions_set: -> Array[PgEventstore::SubscriptionsSet]
+
+          private
+
+          def subscriptions_set_queries: -> PgEventstore::SubscriptionsSetQueries
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_eventstore
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.3.0
 platform: ruby
 authors:
 - Ivan Dzyzenko
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-25 00:00:00.000000000 Z
+date: 2024-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -42,16 +42,22 @@ dependencies:
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5'
 description: EventStore implementation using PostgreSQL
 email:
 - ivan.dzyzenko@gmail.com
@@ -182,6 +188,9 @@ files:
 - lib/pg_eventstore/web/subscriptions/subscriptions.rb
 - lib/pg_eventstore/web/subscriptions/subscriptions_set.rb
 - lib/pg_eventstore/web/subscriptions/subscriptions_to_set_association.rb
+- lib/pg_eventstore/web/subscriptions/with_state/set_collection.rb
+- lib/pg_eventstore/web/subscriptions/with_state/subscriptions.rb
+- lib/pg_eventstore/web/subscriptions/with_state/subscriptions_set.rb
 - lib/pg_eventstore/web/views/home/dashboard.erb
 - lib/pg_eventstore/web/views/home/partials/event_filter.erb
 - lib/pg_eventstore/web/views/home/partials/events.erb
@@ -195,6 +204,7 @@ files:
 - sig/interfaces/callback.rbs
 - sig/interfaces/event_class_resolver.rbs
 - sig/interfaces/event_modifier.rbs
+- sig/interfaces/failed_subscription_notifier.rbs
 - sig/interfaces/restart_terminator.rbs
 - sig/interfaces/subscription_handler.rbs
 - sig/pg/basic_type_registry.rbs
@@ -277,6 +287,9 @@ files:
 - sig/pg_eventstore/web/subscriptions/subscriptions.rbs
 - sig/pg_eventstore/web/subscriptions/subscriptions_set.rbs
 - sig/pg_eventstore/web/subscriptions/subscriptions_to_set_association.rbs
+- sig/pg_eventstore/web/subscriptions/with_state/set_collection.rbs
+- sig/pg_eventstore/web/subscriptions/with_state/subscriptions.rbs
+- sig/pg_eventstore/web/subscriptions/with_state/subscriptions_set.rbs
 homepage: https://github.com/yousty/pg_eventstore
 licenses:
 - MIT