pg_eventstore 2.0.0 → 3.0.0

data/sig/pg_eventstore/subscriptions/callback_handlers/subscription_feeder_handlers.rbs

@@ -2,28 +2,33 @@ module PgEventstore
   class SubscriptionFeederHandlers
     include Extensions::CallbackHandlersExtension
 
-    def self.update_subscriptions_set_state: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, String state) -> void
+    def self.start_events_subscription_position_worker: (EventsSubscriptionPositionWorker worker) -> void
 
-    def self.lock_subscriptions: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle) -> void
+    def self.stop_events_subscription_position_worker: (EventsSubscriptionPositionWorker worker) -> void
 
-    def self.start_runners: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle) -> void
+    def self.update_subscriptions_set_state: (SubscriptionsSetLifecycle subscriptions_set_lifecycle,
+        String state) -> void
 
-    def self.start_cmds_handler: (PgEventstore::CommandsHandler cmds_handler) -> void
+    def self.lock_subscriptions: (SubscriptionsLifecycle subscriptions_lifecycle) -> void
 
-    def self.persist_error_info: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, StandardError error) -> void
+    def self.start_runners: (SubscriptionsLifecycle subscriptions_lifecycle) -> void
 
-    def self.ping_subscriptions_set: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
+    def self.start_cmds_handler: (CommandsHandler cmds_handler) -> void
 
-    def self.feed_runners: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle, Symbol config_name) -> void
+    def self.persist_error_info: (SubscriptionsSetLifecycle subscriptions_set_lifecycle, StandardError error) -> void
 
-    def self.ping_subscriptions: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle) -> void
+    def self.ping_subscriptions_set: (SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
 
-    def self.stop_runners: (PgEventstore::SubscriptionsLifecycle subscriptions_lifecycle) -> void
+    def self.feed_runners: (SubscriptionsLifecycle subscriptions_lifecycle, Symbol config_name) -> void
 
-    def self.reset_subscriptions_set: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
+    def self.ping_subscriptions: (SubscriptionsLifecycle subscriptions_lifecycle) -> void
 
-    def self.stop_commands_handler: (PgEventstore::CommandsHandler cmds_handler) -> void
+    def self.stop_runners: (SubscriptionsLifecycle subscriptions_lifecycle) -> void
 
-    def self.update_subscriptions_set_restarts: (PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
+    def self.reset_subscriptions_set: (SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
+
+    def self.stop_commands_handler: (CommandsHandler cmds_handler) -> void
+
+    def self.update_subscriptions_set_restarts: (SubscriptionsSetLifecycle subscriptions_set_lifecycle) -> void
   end
 end

data/sig/pg_eventstore/subscriptions/callback_handlers/subscription_runner_handlers.rbs

@@ -1,15 +1,26 @@
 module PgEventstore
   class SubscriptionRunnerHandlers
-    def self.track_exec_time: (PgEventstore::SubscriptionHandlerPerformance stats, ^() -> void, Integer _current_position) -> void
+    def self.checkpoint: (Subscription subscription, Integer global_position) -> void
 
-    def self.update_subscription_stats: (PgEventstore::Subscription subscription, PgEventstore::SubscriptionHandlerPerformance stats, Integer current_position) -> void
+    def self.track_exec_time: (
+        SubscriptionHandlerPerformance stats, ^() -> void,
+        Integer _current_position,
+        Integer events_number
+      ) -> void
 
-    def self.update_subscription_error: (PgEventstore::Subscription subscription, PgEventstore::WrappedException error) -> void
+    def self.update_subscription_stats: (
+        Subscription subscription,
+        SubscriptionHandlerPerformance stats,
+        Integer current_position,
+        Integer events_number
+      ) -> void
 
-    def self.update_subscription_chunk_stats: (PgEventstore::Subscription subscription, Integer global_position) -> void
+    def self.update_subscription_error: (Subscription subscription, WrappedException error) -> void
 
-    def self.update_subscription_restarts: (PgEventstore::Subscription subscription) -> void
+    def self.update_subscription_chunk_stats: (Subscription subscription, Integer subscription_position) -> void
 
-    def self.update_subscription_state: (PgEventstore::Subscription subscription, String state) -> void
+    def self.update_subscription_restarts: (Subscription subscription) -> void
+
+    def self.update_subscription_state: (Subscription subscription, String state) -> void
   end
 end

data/sig/pg_eventstore/subscriptions/event_subscription_position_queries.rbs

@@ -0,0 +1,30 @@
+module PgEventstore
+  class EventSubscriptionPositionQueries
+    ASSIGN_SUBSCRIPTION_POSITIONS_LOCK_ID: Integer
+    MAX_INDEX_RECORDS_TO_UPDATE_SUBSCRIPTION_POSITION: Integer
+    REINDEX_PERIOD: Integer
+    UNPROCESSED_POSITIONS_INDEX_NAME: String
+    UNPROCESSED_POSITIONS_INDEX_SIZE_THRESHOLD: Integer
+    UNPROCESSED_POSITIONS_LOCK_EXPIRES_IN: Integer
+
+    attr_reader connection: Connection
+
+    def initialize: (Connection connection) -> void
+
+    def create_unprocessed_positions: (Array[Hash[String, untyped]] raw_events) -> void
+
+    def max_subscription_position: -> Integer?
+
+    def reindex_unprocessed_positions: -> Time?
+
+    def subscription_positions_from_db: (Array[Event] events) -> Hash[Integer, Integer?]
+
+    def assign_subscription_position: -> Integer?
+
+    private
+
+    def index_size: (String index_name) -> Integer
+
+    def transaction_queries: -> TransactionQueries
+  end
+end

data/sig/pg_eventstore/subscriptions/events_processor.rbs

@@ -1,19 +1,26 @@
 module PgEventstore
   class EventsProcessor
-    include PgEventstore::Extensions::CallbacksExtension
+    include Extensions::CallbacksExtension
+
     extend Forwardable
 
+    @basic_runner: BasicRunner
+    @consumer: EventsProcessorConsumer
+    @events_repository: Chunks::Repository
+    @repository_cond: MonitorMixin::ConditionVariable
+
     %a{rbs:test:skip} def initialize: (
-        _RawEventHandler handler,
         graceful_shutdown_timeout: Float | Integer,
+        consumer: EventsProcessorConsumer,
+        ?events_repository: Chunks::Repository,
         ?recovery_strategies: Array[RunnerRecoveryStrategy]
       ) -> void
 
-    def feed: (::Array[::Hash[untyped, untyped]] raw_events) -> void
+    def feed: (Chunks::Chunk[EventGlobalIndex, Hash[String, untyped]] chunk) -> void
 
-    def events_left_in_chunk: () -> Integer
+    def events_left_in_repo: () -> Integer
 
-    def clear_chunk: () -> void
+    def clear_events_repository: () -> void
 
     def process_event: (::Hash[untyped, untyped] raw_event) -> void
 

data/sig/pg_eventstore/subscriptions/events_processor_consumer/multiple.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Multiple
+      EVENTS_WAIT_TIMEOUT: Integer | Float
+
+      include EventsProcessorConsumer
+      extend ClassMethods
+
+      @handler: _RawEventsHandler
+
+      @last_unprocessed_events: Array[Hash[String, untyped]]?
+
+      def initialize: (_RawEventsHandler handler) -> void
+    end
+  end
+end
+

data/sig/pg_eventstore/subscriptions/events_processor_consumer/replica.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Replica
+      include EventsProcessorConsumer
+
+      EVENTS_WAIT_TIMEOUT: Float | Integer
+
+      @handler: Proc
+
+      @last_unprocessed_events: Array[EventGlobalIndex::SubscriptionRepr]?
+
+      def self.create_consumer: (Symbol config_name, Symbol replica_config_name) -> Replica
+
+      def initialize: (Proc handler) -> void
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/events_processor_consumer/single.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    class Single
+      EVENT_WAIT_TIMEOUT: Float | Integer
+
+      include EventsProcessorConsumer
+      extend ClassMethods
+
+      @handler: _RawEventHandler
+
+      @last_unprocessed_event: Hash[String, untyped]?
+
+      def initialize: (_RawEventHandler handler) -> void
+    end
+  end
+end
+

data/sig/pg_eventstore/subscriptions/events_processor_consumer.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module EventsProcessorConsumer
+    module ClassMethods
+      def create_consumer: (_SubscriptionHandler handler, EventDeserializer deserializer) -> EventsProcessorConsumer
+    end
+
+    def self.consumer_class: (bool in_batches) -> Class
+
+    def call: (Callbacks callbacks, Chunks::Repository repository,
+        MonitorMixin::ConditionVariable repository_cond) -> void
+
+    def clear_unprocessed_events: -> void
+  end
+end

data/sig/pg_eventstore/subscriptions/events_subscription_position_worker.rbs

@@ -0,0 +1,28 @@
+module PgEventstore
+  class EventsSubscriptionPositionWorker
+    class ReindexTime
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      attr_accessor time: Time?
+    end
+
+    @basic_runner: BasicRunner
+
+    @next_reindex_at: ReindexTime
+
+    attr_reader config_name: Symbol
+
+    def initialize: (Symbol config_name) -> void
+
+    private
+
+    def attach_runner_callbacks: -> void
+
+    def config: -> Config
+
+    def connection: -> Connection
+
+    def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+  end
+end

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

@@ -1,73 +1,41 @@
 module PgEventstore
   class SubscriptionQueries
-    # _@param_ `connection`
-    def initialize: (PgEventstore::Connection connection) -> void
+    @query_strategy: QueryStrategy
+
+    attr_accessor connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+    def create_or_replace_table_function: (Integer id, Hash[untyped, untyped] options, Integer locked_by) -> void
 
-    # _@param_ `attrs`
     def find_or_create_by: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `attrs`
     def find_by: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]?
 
-    # _@param_ `attrs`
     def find_all: (::Hash[untyped, untyped] attrs) -> ::Array[::Hash[Symbol, untyped]]
 
     def set_collection: (?String? state) -> ::Array[String]
 
-    # _@param_ `id`
     def find!: (Integer id) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `attrs`
     def create: (::Hash[untyped, untyped] attrs) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `id`
-    #
-    # _@param_ `attrs`
-    #
-    # _@param_ `locked_by`
     def update: (Integer id, attrs: ::Hash[Symbol, untyped], locked_by: Integer?) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `subscriptions_set_id` — SubscriptionsSet#id
-    #
-    # _@param_ `subscriptions_ids` — Array of Subscription#id
     def ping_all: (Integer subscriptions_set_id, ::Array[Integer] subscriptions_ids) -> ::Hash[Integer, Time]
 
-    # _@param_ `query_options` — runner_id/query options association
-    #
-    # _@return_ — runner_id/events association
-    def subscriptions_events: (::Hash[Integer, ::Hash[untyped, untyped]] query_options) -> ::Hash[Integer, Array[::Hash[untyped, untyped]]]
-
-    # _@param_ `id` — subscription's id
-    #
-    # _@param_ `lock_id` — id of the subscriptions set which reserves the subscription
-    #
-    # _@param_ `force` — whether to lock the subscription despite on #locked_by value
-    #
-    # _@return_ — lock id
     def lock!: (Integer id, Integer lock_id, ?force: bool) -> Integer
 
-    # _@param_ `id`
     def delete: (Integer id) -> void
 
-    # _@param_ `id` — runner id
-    #
-    # _@param_ `options` — query options
-    def query_builder: (Integer id, ::Hash[untyped, untyped] options) -> SQLBuilder
-
-    # _@param_ `builders`
     def union_builders: (::Array[SQLBuilder] builders) -> SQLBuilder
 
     def transaction_queries: () -> TransactionQueries
 
     def links_resolver: () -> LinksResolver
 
-    # _@param_ `hash`
     def deserialize: (::Hash[String, untyped] hash) -> ::Hash[Symbol, untyped]
 
-    # _@param_ `attrs`
     def find_by_attrs_builder: (::Hash[untyped, untyped] attrs) -> SQLBuilder
-
-    # Returns the value of attribute connection.
-    attr_accessor connection: Connection
   end
 end

data/sig/pg_eventstore/subscriptions/replica_subscription_handler.rbs

@@ -0,0 +1,33 @@
+module PgEventstore
+  class ReplicaSubscriptionHandler
+    @replica_config_name: Symbol
+    @config_name: Symbol
+
+    def call: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> void
+
+    def initialize: (Symbol, Symbol) -> void
+
+    private
+
+    def connection: -> Connection
+
+    def destination_replica_queries: -> ReplicaQueries
+
+    def records_to_sql: (
+        String table_name, 
+        Array[Symbol] attribute_names, 
+        Array[Hash[Symbol, untyped]] attributes_collection, 
+        ?on_conflict: String?
+      ) -> String
+
+    def reject_already_processed: (
+        Array[EventGlobalIndex::SubscriptionRepr] indexes
+      ) -> Array[EventGlobalIndex::SubscriptionRepr]
+
+    def replica_connection: -> Connection
+
+    def replica_transaction_queries: -> TransactionQueries
+
+    def source_replica_queries: -> ReplicaQueries
+  end
+end

data/sig/pg_eventstore/subscriptions/replica_subscription_runner.rbs

@@ -0,0 +1,4 @@
+module PgEventstore
+  class ReplicaSubscriptionRunner < SubscriptionRunner
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/collection.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class Collection < Array[SubscriptionFeedStrategy[SubscriptionRunner] | SubscriptionFeedStrategy[ReplicaSubscriptionRunner]]
+      DEFAULT_SUBSCRIPTIONS_NUM_PER_QUERY: Integer
+
+      def self.create: (
+          Array[SubscriptionRunner | ReplicaSubscriptionRunner] runners,
+          Connection connection,
+          QueryStrategy query_strategy,
+          ?subscriptions_per_query: Integer
+        ) -> Collection
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/index_read_strategy.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class IndexReadStrategy
+      include SubscriptionFeedStrategy[SubscriptionRunner]
+
+      INDEX_LOOK_UP_DISTANCE: Integer
+
+      @connection: Connection
+      @query_strategy: QueryStrategy
+      @runners: Array[SubscriptionRunner]
+
+      def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+      private
+
+      def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def safe_position: -> Integer
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy/replication_strategy.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    class ReplicationStrategy
+      include SubscriptionFeedStrategy[ReplicaSubscriptionRunner]
+
+      INDEX_LOOK_UP_DISTANCE: Integer
+
+      @connection: Connection
+      @query_strategy: QueryStrategy
+      @runners: Array[ReplicaSubscriptionRunner]
+
+      def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+      private
+
+      def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def safe_position: -> Integer
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feed_strategy.rbs

@@ -0,0 +1,11 @@
+module PgEventstore
+  module SubscriptionFeedStrategy[unchecked Runner]
+    def add: (*Runner runners) -> Array[Runner]
+
+    def any?: -> bool
+
+    def feed: -> void
+
+    def size: -> Integer
+  end
+end

data/sig/pg_eventstore/subscriptions/subscription_feeder.rbs

@@ -4,26 +4,27 @@ module PgEventstore
 
     extend Forwardable
 
-    @basic_runner: PgEventstore::BasicRunner
-    @commands_handler: PgEventstore::CommandsHandler
-    @subscriptions_lifecycle: PgEventstore::SubscriptionsLifecycle
-    @subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle
+    @basic_runner: BasicRunner
+    @commands_handler: CommandsHandler
+    @events_subscription_position_worker: EventsSubscriptionPositionWorker?
+    @subscriptions_lifecycle: SubscriptionsLifecycle
+    @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
 
     attr_reader config_name: Symbol
 
     def initialize: (
         config_name: Symbol,
-        subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle,
-        subscriptions_lifecycle: PgEventstore::SubscriptionsLifecycle
+        subscriptions_set_lifecycle: SubscriptionsSetLifecycle,
+        subscriptions_lifecycle: SubscriptionsLifecycle
       ) -> void
 
-    def id: () -> Integer?
+    def id: -> Integer?
 
-    def start_all: () -> void
+    def start_all: -> void
 
-    def stop_all: () -> void
+    def stop_all: -> void
 
-    def attach_runner_callbacks: () -> void
+    def attach_runner_callbacks: -> void
 
     private
 
@@ -31,5 +32,7 @@ module PgEventstore
         Symbol config_name,
         SubscriptionsSetLifecycle subscriptions_set_lifecycle
       ) -> Array[RunnerRecoveryStrategy]
+
+    def requires_subscription_position_assignment?: -> bool
   end
 end

data/sig/pg_eventstore/subscriptions/subscription_handler_performance.rbs

@@ -5,7 +5,7 @@ module PgEventstore
 
     def initialize: () -> void
 
-    def track_exec_time: () { () -> untyped } -> untyped
+    def track_exec_time: (Integer events_number) { () -> untyped } -> untyped
 
     def average_event_processing_time: () -> Float
   end

data/sig/pg_eventstore/subscriptions/subscription_runner.rbs

@@ -1,9 +1,14 @@
 module PgEventstore
   class SubscriptionRunner
     extend Forwardable
-    MAX_EVENTS_PER_CHUNK: Integer
+    DEFAULT_MAX_EVENTS_PER_CHUNK: Integer
     MIN_EVENTS_PER_CHUNK: Integer
-    INITIAL_EVENTS_PER_CHUNK: Integer
+    DEFAULT_INITIAL_EVENTS_PER_CHUNK: Integer
+
+    @events_processor: EventsProcessor
+    @initial_events_per_chunk: Integer
+    @max_events_per_chunk: Integer
+    @stats: SubscriptionHandlerPerformance
 
     # Returns the value of attribute subscription.
     attr_reader subscription: Subscription
@@ -12,6 +17,8 @@ module PgEventstore
         stats: SubscriptionHandlerPerformance,
         events_processor: EventsProcessor,
         subscription: Subscription,
+        ?initial_events_per_chunk: Integer,
+        ?max_events_per_chunk: Integer,
       ) -> void
 
     def next_chunk_query_opts: () -> ::Hash[untyped, untyped]
@@ -23,5 +30,9 @@ module PgEventstore
     def estimate_events_number: () -> Integer
 
     def attach_callbacks: () -> void
+
+    private
+
+    def subscription_from_position: -> Integer
   end
 end

data/sig/pg_eventstore/subscriptions/subscription_runners_feeder.rbs

@@ -1,20 +1,13 @@
 module PgEventstore
   class SubscriptionRunnersFeeder
     @config_name: Symbol
-    @current_database_id: Integer
 
-    # _@param_ `config_name`
     def initialize: (Symbol config_name) -> void
 
-    # _@param_ `runners`
     def feed: (::Array[SubscriptionRunner] runners) -> void
 
     private
 
-    def connection: () -> Connection
-
-    def subscription_queries: () -> SubscriptionQueries
-
-    def subscription_service_queries: -> SubscriptionServiceQueries
+    def connection: -> Connection
   end
 end

data/sig/pg_eventstore/subscriptions/subscriptions_lifecycle.rbs

@@ -4,15 +4,15 @@ module PgEventstore
 
     @config_name: Symbol
 
-    @subscriptions_set_lifecycle: PgEventstore::SubscriptionsSetLifecycle
+    @subscriptions_set_lifecycle: SubscriptionsSetLifecycle
 
     @subscriptions_pinged_at: Time
 
     @force_lock: bool
 
-    attr_reader runners: Array[PgEventstore::SubscriptionRunner]
+    attr_reader runners: Array[SubscriptionRunner]
 
-    def initialize: (Symbol config_name, PgEventstore::SubscriptionsSetLifecycle subscriptions_set_lifecycle, ?force_lock: bool)-> void
+    def initialize: (Symbol config_name, SubscriptionsSetLifecycle subscriptions_set_lifecycle, ?force_lock: bool)-> void
 
     def force_locked?: -> bool
 
@@ -20,8 +20,6 @@ module PgEventstore
 
     def ping_subscriptions: -> void
 
-    def subscriptions: -> Array[PgEventstore::Subscription]
-
-    def force_lock!: -> void
+    def subscriptions: -> Array[Subscription]
   end
 end