pg_eventstore 1.11.0 → 1.13.0

data/lib/pg_eventstore/subscriptions/events_processor.rb

@@ -13,10 +13,15 @@ module PgEventstore
     # @param handler [#call]
     # @param graceful_shutdown_timeout [Integer, Float] seconds. Determines how long to wait before force-shutdown
     #   the runner when stopping it using #stop_async
-    def initialize(handler, graceful_shutdown_timeout:)
+    # @param recovery_strategies [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def initialize(handler, graceful_shutdown_timeout:, recovery_strategies: [])
       @handler = handler
       @raw_events = []
-      @basic_runner = BasicRunner.new(0, graceful_shutdown_timeout)
+      @basic_runner = BasicRunner.new(
+        run_interval: 0,
+        async_shutdown_time: graceful_shutdown_timeout,
+        recovery_strategies: recovery_strategies
+      )
       attach_runner_callbacks
     end
 

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

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module Extensions
+    # @!visibility private
     module BaseCommandExtension
       def self.included(klass)
         super

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

@@ -2,6 +2,7 @@
 
 module PgEventstore
   module Extensions
+    # @!visibility private
     module CommandClassLookupExtension
       # @param cmd_name [String, Symbol]
       # @return [Class]

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

@@ -127,7 +127,7 @@ module PgEventstore
     def subscriptions_events(query_options)
       return {} if query_options.empty?
 
-      final_builder = union_builders(query_options.map { |id, opts| query_builder(id, opts) })
+      final_builder = SQLBuilder.union_builders(query_options.map { |id, opts| query_builder(id, opts) })
       raw_events = connection.with do |conn|
         conn.exec_params(*final_builder.to_exec_params)
       end.to_a
@@ -177,14 +177,6 @@ module PgEventstore
       builder.select("#{id} as runner_id")
     end
 
-    # @param builders [Array<PgEventstore::SQLBuilder>]
-    # @return [PgEventstore::SQLBuilder]
-    def union_builders(builders)
-      builders[1..].each_with_object(builders[0]) do |builder, first_builder|
-        first_builder.union(builder)
-      end
-    end
-
     # @return [PgEventstore::TransactionQueries]
     def transaction_queries
       TransactionQueries.new(connection)

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreConnection
+      # @return [Integer] seconds
+      TIME_BETWEEN_RETRIES = 5
+      # @return [Array<StandardError>]
+      EXCEPTIONS_TO_HANDLE = [PG::ConnectionBad, PG::UnableToSend, ConnectionPool::TimeoutError].freeze
+
+      include RunnerRecoveryStrategy
+
+      # @param config_name [Symbol]
+      def initialize(config_name)
+        @config_name = config_name
+      end
+
+      def recovers?(error)
+        EXCEPTIONS_TO_HANDLE.any? {error.is_a?(_1) }
+      end
+
+      def recover(_error)
+        loop do
+          sleep TIME_BETWEEN_RETRIES
+
+          connection.with do |conn|
+            conn.exec('select version()')
+            # No error was raised during the request. We are good to recover!
+            return true
+          end
+        rescue *EXCEPTIONS_TO_HANDLE
+        end
+      end
+
+      private
+
+      # @return [PgEventstore::Connection]
+      def connection
+        PgEventstore.connection(@config_name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreSubscriptionFeeder
+      include RunnerRecoveryStrategy
+
+      # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+      def initialize(subscriptions_set_lifecycle:)
+        @subscriptions_set_lifecycle = subscriptions_set_lifecycle
+      end
+
+      def recovers?(_error)
+        true
+      end
+
+      def recover(_error)
+        subscriptions_set = @subscriptions_set_lifecycle.persisted_subscriptions_set
+        return false if subscriptions_set.restart_count >= subscriptions_set.max_restarts_number
+
+        sleep subscriptions_set.time_between_restarts
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module RunnerRecoveryStrategies
+    # @!visibility private
+    class RestoreSubscriptionRunner
+      include RunnerRecoveryStrategy
+
+      # @param subscription [PgEventstore::Subscription]
+      # @param restart_terminator [#call, nil]
+      # @param failed_subscription_notifier [#call, nil]
+      def initialize(subscription:, restart_terminator:, failed_subscription_notifier:)
+        @subscription = subscription
+        @restart_terminator = restart_terminator
+        @failed_subscription_notifier = failed_subscription_notifier
+      end
+
+      def recovers?(error)
+        error.is_a?(WrappedException)
+      end
+
+      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
+        end
+
+        sleep @subscription.time_between_restarts
+        true
+      end
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/runner_recovery_strategies.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'runner_recovery_strategies/restore_connection'
+require_relative 'runner_recovery_strategies/restore_subscription_runner'
+require_relative 'runner_recovery_strategies/restore_subscription_feeder'

data/lib/pg_eventstore/subscriptions/runner_recovery_strategy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # Defines an interface of a recovery strategy of the BasicRunner.
+  # See {PgEventstore::BasicRunner} for an example of usage.
+  module RunnerRecoveryStrategy
+    # Determines whether this strategy can recover from the error. If multiple strategies can recover from the error,
+    # the first one from the :recovery_strategies array is selected.
+    # @param error [StandardError]
+    # @return [Boolean]
+    def recovers?(error)
+    end
+
+    # Actual implementation of recovery strategy. Usually you want to implement here a logic that restores from the
+    # error. The returned boolean value will be used to determine whether the runner should be restarted.
+    # @param error [StandardError]
+    # @return [Boolean]
+    def recover(error)
+    end
+  end
+end

data/lib/pg_eventstore/subscriptions/subscription_feeder.rb

@@ -3,6 +3,7 @@
 module PgEventstore
   # This class is responsible for starting/stopping all SubscriptionRunners. The background runner of it is responsible
   # for events pulling and feeding those SubscriptionRunners.
+  # @!visibility private
   class SubscriptionFeeder
     extend Forwardable
 
@@ -15,7 +16,11 @@ module PgEventstore
     # @param subscriptions_lifecycle [PgEventstore::SubscriptionsLifecycle]
     def initialize(config_name:, subscriptions_set_lifecycle:, subscriptions_lifecycle:)
       @config_name = config_name
-      @basic_runner = BasicRunner.new(0.2, 0)
+      @basic_runner = BasicRunner.new(
+        run_interval: 0.2,
+        async_shutdown_time: 0,
+        recovery_strategies: recovery_strategies(config_name, subscriptions_set_lifecycle)
+      )
       @subscriptions_set_lifecycle = subscriptions_set_lifecycle
       @subscriptions_lifecycle = subscriptions_lifecycle
       @commands_handler = CommandsHandler.new(@config_name, self, @subscriptions_lifecycle.runners)
@@ -71,10 +76,6 @@ module PgEventstore
         :after_runner_died, :before,
         SubscriptionFeederHandlers.setup_handler(:persist_error_info, @subscriptions_set_lifecycle)
       )
-      @basic_runner.define_callback(
-        :after_runner_died, :before,
-        SubscriptionFeederHandlers.setup_handler(:restart_runner, @subscriptions_set_lifecycle, @basic_runner)
-      )
 
       @basic_runner.define_callback(
         :process_async, :before,
@@ -107,5 +108,17 @@ module PgEventstore
         SubscriptionFeederHandlers.setup_handler(:update_subscriptions_set_restarts, @subscriptions_set_lifecycle)
       )
     end
+
+    # @param config_name [Symbol]
+    # @param subscriptions_set_lifecycle [PgEventstore::SubscriptionsSetLifecycle]
+    # @return [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def recovery_strategies(config_name, subscriptions_set_lifecycle)
+      [
+        RunnerRecoveryStrategies::RestoreConnection.new(config_name),
+        RunnerRecoveryStrategies::RestoreSubscriptionFeeder.new(
+          subscriptions_set_lifecycle: subscriptions_set_lifecycle
+        ),
+      ]
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscription_runner.rb

@@ -28,15 +28,10 @@ module PgEventstore
     # @param stats [PgEventstore::SubscriptionHandlerPerformance]
     # @param events_processor [PgEventstore::EventsProcessor]
     # @param subscription [PgEventstore::Subscription]
-    # @param restart_terminator [#call, nil]
-    # @param failed_subscription_notifier [#call, nil]
-    def initialize(stats:, events_processor:, subscription:, restart_terminator: nil,
-                   failed_subscription_notifier: nil)
+    def initialize(stats:, events_processor:, subscription:)
       @stats = stats
       @events_processor = events_processor
       @subscription = subscription
-      @restart_terminator = restart_terminator
-      @failed_subscription_notifier = failed_subscription_notifier
 
       attach_callbacks
     end
@@ -87,13 +82,6 @@ module PgEventstore
         :error, :after,
         SubscriptionRunnerHandlers.setup_handler(:update_subscription_error, @subscription)
       )
-      @events_processor.define_callback(
-        :error, :after,
-        SubscriptionRunnerHandlers.setup_handler(
-          :restart_events_processor,
-          @subscription, @restart_terminator, @failed_subscription_notifier, @events_processor
-        )
-      )
 
       @events_processor.define_callback(
         :feed, :after,

data/lib/pg_eventstore/subscriptions/subscriptions_lifecycle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionsLifecycle
     extend Forwardable
 

data/lib/pg_eventstore/subscriptions/subscriptions_manager.rb

@@ -3,6 +3,8 @@
 require 'forwardable'
 require_relative 'runner_state'
 require_relative 'basic_runner'
+require_relative 'runner_recovery_strategy'
+require_relative 'runner_recovery_strategies'
 require_relative 'subscription'
 require_relative 'events_processor'
 require_relative 'subscription_handler_performance'
@@ -102,11 +104,11 @@ module PgEventstore
       runner = SubscriptionRunner.new(
         stats: SubscriptionHandlerPerformance.new,
         events_processor: EventsProcessor.new(
-          create_raw_event_handler(middlewares, handler), graceful_shutdown_timeout: graceful_shutdown_timeout
+          create_raw_event_handler(middlewares, handler),
+          graceful_shutdown_timeout: graceful_shutdown_timeout,
+          recovery_strategies: recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
         ),
         subscription: subscription,
-        restart_terminator: restart_terminator,
-        failed_subscription_notifier: failed_subscription_notifier
       )
 
       @subscriptions_lifecycle.runners.push(runner)
@@ -170,5 +172,20 @@ module PgEventstore
 
       config.middlewares.slice(*middlewares).values
     end
+
+    # @param subscription [PgEventstore::Subscription]
+    # @param restart_terminator [#call, nil]
+    # @param failed_subscription_notifier [#call, nil]
+    # @return [Array<PgEventstore::RunnerRecoveryStrategy>]
+    def recovery_strategies(subscription, restart_terminator, failed_subscription_notifier)
+      [
+        RunnerRecoveryStrategies::RestoreConnection.new(config_name),
+        RunnerRecoveryStrategies::RestoreSubscriptionRunner.new(
+          subscription: subscription,
+          restart_terminator: restart_terminator,
+          failed_subscription_notifier: failed_subscription_notifier,
+        ),
+      ]
+    end
   end
 end

data/lib/pg_eventstore/subscriptions/subscriptions_set_lifecycle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module PgEventstore
+  # @!visibility private
   class SubscriptionsSetLifecycle
     # @return [Integer] number of seconds between heartbeat updates
     HEARTBEAT_INTERVAL = 10 # seconds

data/lib/pg_eventstore/utils.rb

@@ -85,7 +85,8 @@ module PgEventstore
       def write_to_file(file_path, content)
         file = File.open(file_path, "w")
         file.write(content)
-        file.close
+      ensure
+        file&.close
       end
 
       # @param file_path [String]
@@ -99,10 +100,10 @@ module PgEventstore
       # @return [String, nil]
       def read_pid(file_path)
         file = File.open(file_path, "r")
-        file.readline.strip.tap do
-          file.close
-        end
+        file.readline.strip
       rescue Errno::ENOENT
+      ensure
+        file&.close
       end
 
       # @param exception [StandardError]

data/lib/pg_eventstore/version.rb

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

data/lib/pg_eventstore/web/application.rb

@@ -5,6 +5,7 @@ require 'base64'
 
 module PgEventstore
   module Web
+    # @!visibility private
     class Application < Sinatra::Base
       # @return [Symbol]
       DEFAULT_ADMIN_UI_CONFIG = :admin_web_ui
@@ -27,7 +28,7 @@ module PgEventstore
       helpers(Paginator::Helpers, Subscriptions::Helpers) do
         # @return [Array<Hash>, nil]
         def streams_filter
-          params in { filter: { streams: Array => streams } }
+          streams = QueryBuilders::EventsFiltering.extract_streams_filter(params)
           streams&.select { _1 in { context: String, stream_name: String, stream_id: String } }&.map do
             Hash[_1.reject { |_, value| value == '' }].transform_keys(&:to_sym)
           end&.reject { _1.empty? }
@@ -41,8 +42,9 @@ module PgEventstore
 
         # @return [Array<String>, nil]
         def events_filter
-          params in { filter: { events: Array => events } }
-          events&.select { _1.is_a?(String) && _1 != '' }
+          event_filters = { filter: { event_types: params.dig(:filter, :events) } }
+          events = QueryBuilders::EventsFiltering.extract_event_types_filter(event_filters)
+          events&.reject { _1 == '' }
         end
 
         # @return [Symbol]

data/lib/pg_eventstore.rb

@@ -9,6 +9,7 @@ require_relative 'pg_eventstore/extensions/callback_handlers_extension'
 require_relative 'pg_eventstore/extensions/using_connection_extension'
 require_relative 'pg_eventstore/event_class_resolver'
 require_relative 'pg_eventstore/config'
+require_relative 'pg_eventstore/partition'
 require_relative 'pg_eventstore/event'
 require_relative 'pg_eventstore/stream'
 require_relative 'pg_eventstore/commands'
@@ -35,10 +36,11 @@ module PgEventstore
     # @return [Object] a result of the given block
     def configure(name: DEFAULT_CONFIG)
       mutex.synchronize do
-        @config[name] ||= Config.new(name: name)
+        @config[name] = @config[name] ? Config.new(name: name, **@config[name].options_hash) : Config.new(name: name)
         connection_config_was = @config[name].connection_options
 
         yield(@config[name]).tap do
+          @config[name].freeze
           next if connection_config_was == @config[name].connection_options
 
           # Reset the connection if user decided to reconfigure connection's options

data/sig/pg_eventstore/client.rbs

@@ -26,6 +26,8 @@ module PgEventstore
     # _@param_ `middlewares` — provide a list of middleware names to override a config's middlewares
     def read: (PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?) -> ::Array[PgEventstore::Event]
 
+    def read_grouped: (Stream stream, ?options: Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?) -> ::Array[PgEventstore::Event]
+
     # _@param_ `stream`
     #
     # _@param_ `options` — request options

data/sig/pg_eventstore/commands/all_stream_read_grouped.rbs

@@ -0,0 +1,16 @@
+module PgEventstore
+  module Commands
+    class AllStreamReadGrouped < AbstractCommand
+
+      def call: (Stream stream, ?options: ::Hash[untyped, untyped]) -> Array[Event]
+
+      private
+
+      def build_filter_options_for_partitions: (Partition partition, Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+
+      def build_filter_options_for_streams: (Partition partition, Array[String] stream_ids, Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
+
+      def group_stream_ids: (Hash[untyped, untyped] options) -> Hash[untyped, untyped]
+    end
+  end
+end

data/sig/pg_eventstore/commands/regular_stream_read_grouped.rbs

@@ -0,0 +1,8 @@
+module PgEventstore
+  module Commands
+    class RegularStreamReadGrouped < AbstractCommand
+
+      def call: (Stream stream, ?options: ::Hash[untyped, untyped]) -> Array[Event]
+    end
+  end
+end

data/sig/pg_eventstore/connection.rbs

@@ -12,6 +12,8 @@ module PgEventstore
     # _@param_ `pool_timeout` — Connection pool timeout in seconds
     def initialize: (uri: String, ?pool_size: Integer, ?pool_timeout: Integer) -> void
 
+    def shutdown: -> untyped
+
     def with: () { (PG::Connection connection) -> untyped } -> untyped
 
     def init_pool: () -> ConnectionPool[untyped]

data/sig/pg_eventstore/partition.rbs

@@ -0,0 +1,15 @@
+module PgEventstore
+  class Partition
+    include Extensions::OptionsExtension
+
+    attr_accessor id: Integer
+
+    attr_accessor context: String
+
+    attr_accessor stream_name: String?
+
+    attr_accessor event_type: String?
+
+    attr_accessor table_name: String
+  end
+end

data/sig/pg_eventstore/queries/event_queries.rbs

@@ -10,6 +10,8 @@ module PgEventstore
     # _@param_ `event`
     def event_exists?: (PgEventstore::Event event) -> bool
 
+    def grouped_events: (Stream stream, Array[Hash[untyped, untyped]] options_by_event_type, **untyped options)-> Array[Event]
+
     # _@param_ `events`
     def ids_from_db: (::Array[PgEventstore::Event] events) -> ::Array[String]
 

data/sig/pg_eventstore/queries/partition_queries.rbs

@@ -39,6 +39,8 @@ module PgEventstore
     # _@return_ — partition attributes
     def context_partition: (PgEventstore::Stream stream) -> ::Hash[untyped, untyped]?
 
+    def partitions: (Array[Hash[Symbol, String | nil]] stream_filters, Array[String] event_filters)-> Array[Partition]
+
     # _@param_ `stream`
     #
     # _@return_ — partition attributes
@@ -70,5 +72,9 @@ module PgEventstore
 
     # Returns the value of attribute connection.
     attr_accessor connection: PgEventstore::Connection
+
+    private
+
+    def deserialize: (Hash[untyped, untyped] attrs)-> Partition
   end
 end

data/sig/pg_eventstore/query_builders/basic_filtering.rbs

@@ -0,0 +1,15 @@
+module PgEventstore
+  module QueryBuilders
+    class BasicFiltering
+      @sql_builder: SQLBuilder
+
+      def initialize: -> void
+
+      def to_exec_params: -> [String, Array[untyped]]
+
+      def to_sql_builder: -> SQLBuilder
+
+      def to_table_name: -> String
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/events_filtering_query.rbs

@@ -1,39 +1,37 @@
 module PgEventstore
   module QueryBuilders
     # @!visibility private
-    class EventsFiltering
+    class EventsFiltering < BasicFiltering
       DEFAULT_LIMIT: Integer
       SQL_DIRECTIONS: Hash[String | Symbol, String]
       SUBSCRIPTIONS_OPTIONS: ::Array[Symbol]
 
-      @sql_builder: PgEventstore::SQLBuilder
+      TABLE_NAME: String
+
+      def self.events_filtering: (Stream stream, ::Hash[untyped, untyped] options) -> EventsFiltering
+
+      def self.extract_event_types_filter: (Hash[untyped, untyped] options) -> Array[String]
+
+      def self.extract_streams_filter: (Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
 
-      def self.events_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
-      
       # _@param_ `options`
-      def self.subscriptions_events_filtering: (::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+      def self.subscriptions_events_filtering: (::Hash[untyped, untyped] options) -> EventsFiltering
 
       # _@param_ `options`
-      def self.all_stream_filtering: (::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+      def self.all_stream_filtering: (::Hash[untyped, untyped] options) -> EventsFiltering
 
       # _@param_ `stream`
       #
       # _@param_ `options`
-      def self.specific_stream_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+      def self.specific_stream_filtering: (Stream stream, ::Hash[untyped, untyped] options) -> EventsFiltering
 
-      def self.system_stream_filtering: (PgEventstore::Stream stream, Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+      def self.system_stream_filtering: (Stream stream, Hash[untyped, untyped] options) -> EventsFiltering
 
       def initialize: () -> void
 
-      # _@param_ `context`
-      #
-      # _@param_ `stream_name`
-      #
-      # _@param_ `stream_id`
       def add_stream_attrs: (?context: String?, ?stream_name: String?, ?stream_id: String?) -> void
 
-      # _@param_ `event_types`
-      def add_event_types: (::Array[String]? event_types) -> void
+      def add_event_types: (::Array[String] event_types) -> void
 
       # _@param_ `revision`
       #
@@ -54,9 +52,11 @@ module PgEventstore
       # _@param_ `limit`
       def add_limit: (Integer? limit) -> void
 
-      def to_sql_builder: () -> PgEventstore::SQLBuilder
+      def set_source: (String table_name)-> void
+
+      def to_sql_builder: () -> SQLBuilder
 
-      def to_exec_params: () -> ::Array[untyped]
+      def to_exec_params: () -> [String, Array[untyped]]
 
       # _@param_ `stream_attrs`
       def correct_stream_filter?: (::Hash[untyped, untyped] stream_attrs) -> bool

data/sig/pg_eventstore/query_builders/partitions_filtering.rbs

@@ -0,0 +1,21 @@
+module PgEventstore
+  module QueryBuilders
+    class PartitionsFiltering < BasicFiltering
+      TABLE_NAME: String
+
+      def self.extract_event_types_filter: (Hash[untyped, untyped] options) -> Array[String]
+
+      def self.extract_streams_filter: (Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
+
+      def add_event_types: (::Array[String] event_types) -> void
+
+      def add_stream_attrs: (?context: String?, ?stream_name: String?) -> void
+
+      def with_event_types: -> void
+
+      private
+
+      def correct_stream_filter?: (::Hash[untyped, untyped] stream_attrs) -> bool
+    end
+  end
+end

data/sig/pg_eventstore/sql_builder.rbs

@@ -46,7 +46,7 @@ module PgEventstore
 
     def remove_group: () -> self
 
-    def to_exec_params: () -> ::Array[(String | ::Array[untyped])]
+    def to_exec_params: () -> [String, ::Array[untyped]]
 
     def positional_values: () -> ::Array[Object]