pg_eventstore 1.13.4 → 3.0.0

data/sig/pg_eventstore/chunks/subscription_events_index_chunk.rbs

@@ -0,0 +1,37 @@
+module PgEventstore
+  module Chunks
+    class SubscriptionEventsIndexChunk
+      class RawEventWithSubscriptionPosition
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        attr_accessor attributes: Hash[String, untyped]
+        attr_accessor subscription_position: Integer
+      end
+
+      include Chunk[EventGlobalIndex::SubscriptionRepr, RawEventWithSubscriptionPosition]
+
+      MAX_PARTITIONS_TO_RESOLVE_PER_CALL: Integer
+
+      @connection: Connection
+      @raw_events: Array[RawEventWithSubscriptionPosition]
+      @indexes: Array[EventGlobalIndex::SubscriptionRepr]
+      @query_strategy: QueryStrategy
+      @resolve_link_tos: bool
+      @resolved: bool
+
+      def initialize: (Array[EventGlobalIndex::SubscriptionRepr] indexes, Connection connection,
+          QueryStrategy query_strategy, bool resolve_link_tos) -> void
+
+      private
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def resolve_indexes: -> void
+
+      def resolved?: -> bool
+
+      def sort: (Array[RawEventWithSubscriptionPosition] raw_events) -> Array[RawEventWithSubscriptionPosition]
+    end
+  end
+end

data/sig/pg_eventstore/client.rbs

@@ -1,65 +1,63 @@
 module PgEventstore
   class Client
     # _@param_ `config`
-    def initialize: (PgEventstore::Config config) -> void
-
-    # _@param_ `stream`
-    #
-    # _@param_ `events_or_event`
-    #
-    # _@param_ `options`
-    #
-    # _@param_ `middlewares` — provide a list of middleware names to override a config's middlewares
+    def initialize: (Config config) -> void
+
     def append_to_stream: (
-        PgEventstore::Stream stream,
-        (PgEventstore::Event | ::Array[PgEventstore::Event]) events_or_event,
+        Stream stream,
+        (Event | ::Array[Event]) events_or_event,
         ?options: ::Hash[untyped, untyped],
-        ?middlewares: ::Array[untyped]?
-      ) -> (PgEventstore::Event | ::Array[PgEventstore::Event])
+        ?middlewares: ::Array[Symbol]?
+      ) -> (Event | ::Array[Event])
 
-    def multiple: () { () -> untyped } -> untyped
+    def multiple: (?read_only: bool) { () -> untyped } -> untyped
 
-    # _@param_ `stream`
-    #
-    # _@param_ `options` — request options
-    #
-    # _@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: (Stream stream, ?options: ::Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?) -> ::Array[Event]
 
-    def read_grouped: (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[Event]
 
     # Temporary skip RBS checks of this method. It doesn't play well with Enumerator under certain circumstances
     %a{rbs:test:skip} def read_paginated: (
-        PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?
-      ) -> ::Enumerator[Array[PgEventstore::Event], void]
-
-    # _@param_ `stream`
-    #
-    # _@param_ `events_or_event`
-    #
-    # _@param_ `options`
-    #
-    # _@param_ `middlewares` — provide a list of middleware names to use. Defaults to empty array, meaning no middlewares will be applied to the "link" event
+        Stream stream, ?options: ::Hash[untyped, untyped], ?middlewares: ::Array[::Symbol]?
+      ) -> ::Enumerator[Array[Event], void]
+
     def link_to: (
-        PgEventstore::Stream stream,
-        (PgEventstore::Event | ::Array[PgEventstore::Event]) events_or_event,
+        Stream stream,
+        (Event | ::Array[Event]) events_or_event,
         ?options: ::Hash[untyped, untyped],
         ?middlewares: ::Array[::Symbol]
-      ) -> (PgEventstore::Event | ::Array[PgEventstore::Event])
+      ) -> (Event | ::Array[Event])
+
+    attr_accessor config: Config
+
+    def read_streams: (?options: ::Hash[untyped, untyped]) -> Array[Stream]
+
+    def read_streams_paginated: (?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[Stream], void]
+
+    def stream_revision: (Stream stream) -> Integer
+
+    private
+
+    def event_deserializer: (Array[Middleware] middlewares) -> EventDeserializer
+
+    def event_marker_queries: -> EventMarkerQueries
+
+    def event_subscription_position_queries: -> EventSubscriptionPositionQueries
+
+    def events_global_index_queries: -> EventsGlobalIndexQueries
+
+    def event_queries: -> EventQueries
 
-    # _@param_ `middlewares`
-    def middlewares: (?::Array[::Symbol]? middlewares) -> ::Array[PgEventstore::Middleware]
+    def index_filtering_queries: -> IndexFilteringQueries
 
-    def connection: () -> PgEventstore::Connection
+    def partition_queries: () -> PartitionQueries
 
-    def partition_queries: () -> PgEventstore::PartitionQueries
+    def streams_global_index_queries: -> StreamsGlobalIndexQueries
 
-    def transaction_queries: () -> PgEventstore::TransactionQueries
+    def transaction_queries: () -> TransactionQueries
 
-    # _@param_ `middlewares`
-    def event_queries: (::Array[PgEventstore::Middleware] middlewares) -> PgEventstore::EventQueries
+    def middlewares: (?::Array[::Symbol]? middlewares) -> ::Array[Middleware]
 
-    # Returns the value of attribute config.
-    attr_accessor config: PgEventstore::Config
+    def connection: () -> Connection
   end
 end

data/sig/pg_eventstore/commands/append.rbs

@@ -1,33 +1,19 @@
 module PgEventstore
   module Commands
-    class Append < PgEventstore::AbstractCommand
-      # _@param_ `stream`
-      #
-      # _@param_ `events`
-      #
-      # _@param_ `options`
-      #
-      # _@param_ `event_modifier`
-      #
-      # _@return_ — persisted events
+    class Append < AbstractCommand
       def call: (
-          PgEventstore::Stream stream,
-          *PgEventstore::Event events,
-          ?options: ::Hash[untyped, untyped],
-          ?event_modifier: _EventModifier
-        ) -> ::Array[PgEventstore::Event]
+          Stream stream,
+          *Event events,
+          event_modifier: _EventModifier,
+          deserializer: EventDeserializer,
+          ?options: ::Hash[untyped, untyped]
+        ) -> ::Array[Event]
 
-      # _@param_ `stream`
-      #
-      # _@param_ `events`
-      def create_partitions: (PgEventstore::Stream stream, ::Array[PgEventstore::Event] events) -> void
+      private
 
-      # _@param_ `revision`
-      #
-      # _@param_ `expected_revision`
-      #
-      # _@param_ `stream`
-      def assert_expected_revision!: (Integer revision, (Symbol | Integer) expected_revision, PgEventstore::Stream stream) -> void
+      def feature_markers: (Event event) -> Array[String]
+
+      def prepare_partitions: (Stream stream, ::Array[Event] events) -> Array[Partition]
     end
   end
 end

data/sig/pg_eventstore/commands/event_modifiers/prepare_link_event.rbs

@@ -2,22 +2,19 @@ module PgEventstore
   module Commands
     module EventModifiers
       class PrepareLinkEvent
-        # _@param_ `partition_queries`
-        def initialize: (PgEventstore::PartitionQueries partition_queries) -> void
+        @serializer: EventSerializer
 
-        # _@param_ `event`
-        #
-        # _@param_ `revision`
-        def call: (PgEventstore::Event event, Integer revision) -> PgEventstore::Event
+        attr_reader partition_queries: PartitionQueries
 
-        # _@param_ `event` — persisted event
-        #
-        # _@return_ — partition id
-        def partition_id: (PgEventstore::Event event) -> Integer
+        attr_reader partitions: Hash[untyped, untyped]
 
-        attr_reader partition_queries: PgEventstore::PartitionQueries
+        def initialize: (PartitionQueries partition_queries, EventSerializer serializer) -> void
 
-        attr_reader partitions: Hash[untyped, untyped]
+        def call: (Event event) -> Event
+
+        private
+
+        def partition_id: (Event event) -> Integer
       end
     end
   end

data/sig/pg_eventstore/commands/event_modifiers/prepare_regular_event.rbs

@@ -2,10 +2,11 @@ module PgEventstore
   module Commands
     module EventModifiers
       class PrepareRegularEvent
-        # _@param_ `event`
-        #
-        # _@param_ `revision`
-        def call: (PgEventstore::Event event, Integer revision) -> PgEventstore::Event
+        @serializer: EventSerializer
+
+        def initialize: (EventSerializer serializer) -> void
+
+        def call: (Event event) -> Event
       end
     end
   end

data/sig/pg_eventstore/commands/link_to.rbs

@@ -1,17 +1,12 @@
 module PgEventstore
   module Commands
-    class LinkTo < PgEventstore::AbstractCommand
-      # _@param_ `stream`
-      #
-      # _@param_ `events`
-      #
-      # _@param_ `options`
-      #
-      # _@return_ — persisted events
-      def call: (PgEventstore::Stream stream, *PgEventstore::Event events, ?options: ::Hash[untyped, untyped]) -> ::Array[PgEventstore::Event]
+    class LinkTo < AbstractCommand
+      def call: (Stream stream, *Event events, event_modifier: _EventModifier, deserializer: EventDeserializer,
+          ?options: ::Hash[untyped, untyped]) -> ::Array[Event]
 
-      # _@param_ `events`
-      def check_events_presence: (::Array[PgEventstore::Event] events) -> void
+      private
+
+      def check_events_presence: (::Array[Event] events) -> void
     end
   end
 end

data/sig/pg_eventstore/commands/multiple.rbs

@@ -1,7 +1,7 @@
 module PgEventstore
   module Commands
     class Multiple < PgEventstore::AbstractCommand
-      def call: () { () -> untyped } -> untyped
+      def call: (read_only: bool) { () -> untyped } -> untyped
     end
   end
 end

data/sig/pg_eventstore/commands/read.rbs

@@ -1,10 +1,7 @@
 module PgEventstore
   module Commands
-    class Read < PgEventstore::AbstractCommand
-      # _@param_ `stream`
-      #
-      # _@param_ `options` — request options
-      def call: (PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped]) -> ::Array[PgEventstore::Event]
+    class Read < AbstractCommand
+      def call: (Stream stream, deserializer: EventDeserializer, ?options: ::Hash[untyped, untyped]) -> ::Array[Event]
     end
   end
 end

data/sig/pg_eventstore/commands/read_grouped.rbs

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

data/sig/pg_eventstore/commands/read_streams.rbs

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

data/sig/pg_eventstore/commands/read_streams_paginated.rbs

@@ -0,0 +1,16 @@
+module PgEventstore
+  module Commands
+    class ReadStreamsPaginated < AbstractCommand
+      # Skip this type check because rbs duplicates calls to Enumerator#next
+      %a{rbs:test:skip} def call: (?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[Stream], void]
+
+      private
+
+      def calc_next_position: (Array[StreamGlobalIndex] indexes, String? | Symbol? direction) -> Integer
+
+      def end_reached?: (Array[Stream] streams, Integer max_count) -> bool
+
+      def forwards?: (String? | Symbol? direction) -> bool
+    end
+  end
+end

data/sig/pg_eventstore/commands/regular_stream_read_paginated.rbs

@@ -1,27 +1,19 @@
 module PgEventstore
   module Commands
-    class RegularStreamReadPaginated < PgEventstore::AbstractCommand
-      # _@param_ `stream`
-      #
-      # _@param_ `options`
-      %a{rbs:test:skip} def call: (PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[PgEventstore::Event], void]
+    class RegularStreamReadPaginated < AbstractCommand
+      # Skip this type check because rbs duplicates calls to Enumerator#next
+      %a{rbs:test:skip} def call: (Stream stream, deserializer: EventDeserializer,
+          ?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[Event], void]
 
-      # _@param_ `events`
-      #
-      # _@param_ `max_count`
-      def end_reached?: (::Array[PgEventstore::Event] events, Integer max_count) -> bool
+      private
 
-      # _@param_ `events`
-      #
-      # _@param_ `revision`
-      #
-      # _@param_ `direction`
-      def calc_next_revision: (::Array[PgEventstore::Event] events, (String | Symbol)? direction) -> Integer
+      def end_reached?: (::Array[Event] events, Integer max_count) -> bool
+
+      def calc_next_revision: (::Array[Event] events, (String | Symbol)? direction) -> Integer
 
-      # _@param_ `direction`
       def forwards?: ((String | Symbol)? direction) -> bool
 
-      def read_cmd: () -> PgEventstore::Commands::Read
+      def read_cmd: () -> Commands::Read
     end
   end
 end

data/sig/pg_eventstore/commands/revision_check/current_revision.rbs

@@ -0,0 +1,25 @@
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      class CurrentRevision
+        class StreamRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor revision: Integer
+        end
+
+        class EventTypeRevisions
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor revisions: Array[EventGlobalIndex::RevisionCheckRepr]
+        end
+
+        def self.build: (Stream stream, Integer stream_revision,
+            ExpectedRevision::StreamRevision? | ExpectedRevision::EventTypeRevisions? expected_revision,
+            IndexFilteringQueries index_filtering_queries) -> (StreamRevision | EventTypeRevisions)?
+      end
+    end
+  end
+end

data/sig/pg_eventstore/commands/revision_check/event_type_revisions_comparison.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      class EventTypeRevisionsComparison
+        def self.verdict: (
+            Integer current_revision,
+            Symbol | Integer expected_revision,
+            ?expected_markers: Array[String]?,
+            ?event_type: String | Symbol
+          ) -> WrongExpectedTypesRevisionError::Verdict?
+      end
+    end
+  end
+end

data/sig/pg_eventstore/commands/revision_check/expected_revision.rbs

@@ -0,0 +1,67 @@
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      class ExpectedRevision
+        class StreamRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor revision: Symbol | Integer
+        end
+
+        class EventTypeRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor expected_revision: Symbol | Integer
+          attr_accessor event_type: String?
+          attr_accessor sequence_number: Integer
+        end
+
+        class EventTypeRevisionWithMarkers
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor expected_revision: Symbol | Integer
+          attr_accessor event_type: String?
+          attr_accessor markers: Array[String]
+          attr_accessor sequence_number: Integer
+        end
+
+        class MarkersRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor expected_revision: Symbol | Integer
+          attr_accessor markers: Array[String]
+          attr_accessor sequence_number: Integer
+        end
+
+        class EventTypeRevisions
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          attr_accessor revisions: Array[EventTypeRevision | EventTypeRevisionWithMarkers | MarkersRevision]
+        end
+
+        def self.build: (
+              # stream revision
+              (Symbol | Integer)? |
+              Hash[
+                String,
+                # <event type>-to-<stream revision of the event>
+                Symbol | Integer |
+                  # <event type>-to-<stream revision of the event with markers>
+                  { expected_revision: Symbol | Integer, ?markers: Array[String] }] |
+              # <any event type>-to-<stream revision of the event with markers>
+              { any: { expected_revision: Symbol | Integer, ?markers: Array[String] } } expected_revision) -> (StreamRevision | EventTypeRevisions)?
+
+        private
+
+        def self.extract_markers: (Hash[untyped, untyped] hash) -> Array[String]
+
+        def self.extract_expected_revision: (Hash[untyped, untyped] hash) -> (Symbol | Integer)
+      end
+    end
+  end
+end

data/sig/pg_eventstore/commands/revision_check/stream_revision_check.rbs

@@ -0,0 +1,20 @@
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      class StreamRevisionCheck
+        def self.assert_eq!: ((CurrentRevision::StreamRevision | CurrentRevision::EventTypeRevisions)?,
+            (ExpectedRevision::StreamRevision | ExpectedRevision::EventTypeRevisions)?, Stream stream) -> void
+
+        private
+
+        def self.find_index: (
+              Commands::RevisionCheck::ExpectedRevision::EventTypeRevision |
+              Commands::RevisionCheck::ExpectedRevision::EventTypeRevisionWithMarkers |
+              Commands::RevisionCheck::ExpectedRevision::MarkersRevision
+            expected_revision,
+            Hash[Integer, EventGlobalIndex::RevisionCheckRepr] rev_check_indexes
+          ) -> EventGlobalIndex::RevisionCheckRepr
+      end
+    end
+  end
+end

data/sig/pg_eventstore/commands/revision_check/stream_revision_comparison.rbs

@@ -0,0 +1,9 @@
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      class StreamRevisionComparison
+        def self.verdict: (Integer current_revision, Symbol | Integer expected_revision) -> Symbol?
+      end
+    end
+  end
+end

data/sig/pg_eventstore/commands/stream_revision.rbs

@@ -0,0 +1,7 @@
+module PgEventstore
+  module Commands
+    class StreamRevision < AbstractCommand
+      def call: (Stream stream) -> Integer
+    end
+  end
+end

data/sig/pg_eventstore/commands/system_stream_read_paginated.rbs

@@ -1,25 +1,20 @@
 module PgEventstore
   module Commands
-    class SystemStreamReadPaginated < PgEventstore::AbstractCommand
-      # _@param_ `stream`
-      #
-      # _@param_ `options`
-      %a{rbs:test:skip} def call: (PgEventstore::Stream stream, ?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[PgEventstore::Event], void]
+    class SystemStreamReadPaginated < AbstractCommand
+      # Skip this type check because rbs duplicates calls to Enumerator#next
+      %a{rbs:test:skip} def call: (Stream stream, deserializer: EventDeserializer,
+          ?options: ::Hash[untyped, untyped]) -> ::Enumerator[Array[Event], void]
 
-      # _@param_ `events`
-      #
-      # _@param_ `max_count`
-      def end_reached?: (::Array[PgEventstore::Event] events, Integer max_count) -> bool
+      private
 
-      # _@param_ `events`
-      #
-      # _@param_ `direction`
-      def calc_next_position: (::Array[PgEventstore::Event] events, (String | Symbol)? direction) -> Integer
+      def end_reached?: (::Array[Event] events, Integer max_count) -> bool
+
+      def calc_next_position: (::Array[Event] events, (String | Symbol)? direction) -> Integer
 
       # _@param_ `direction`
       def forwards?: ((String | Symbol)? direction) -> bool
 
-      def read_cmd: () -> PgEventstore::Commands::Read
+      def read_cmd: () -> Commands::Read
     end
   end
 end

data/sig/pg_eventstore/config.rbs

@@ -1,9 +1,14 @@
 module PgEventstore
-  class Config
-    include PgEventstore::Extensions::OptionsExtension
+  class Config < BasicConfig
+    module NodeRole
+      PRIMARY: Symbol
+      REPLICA: Symbol
+      STANDALONE: Symbol
 
-    # _@param_ `name` — config's name. Its value matches the appropriate key in PgEventstore.config hash
-    def initialize: (name: Symbol, **untyped options) -> void
+      def self.maintainable: -> Array[Symbol]
+
+      def self.writable: -> Array[Symbol]
+    end
 
     def connection_options: () -> ::Hash[untyped, untyped]
 
@@ -21,8 +26,6 @@ module PgEventstore
     # _@param_ `options`
     def init_default_values: (::Hash[untyped, untyped] options) -> void
 
-    attr_reader name: untyped
-
     attr_accessor pg_uri: String
 
     # _@return_ — Number of events to return in one response when reading from a stream
@@ -51,5 +54,11 @@ module PgEventstore
     attr_accessor subscriptions_set_retries_interval: Integer
 
     attr_accessor subscription_graceful_shutdown_timeout: Integer | Float
+
+    attr_accessor events_subscription_position_update_interval: Integer | Float
+
+    attr_accessor eventstore_role: Symbol
+
+    attr_accessor max_events_to_replicate: Integer
   end
 end

data/sig/pg_eventstore/connection.rbs

@@ -1,32 +1,25 @@
 module PgEventstore
   class Connection
-    module Ruby30Patch
-    end
+    @pool: ConnectionPool[PgConnection]?
 
-    include PgEventstore::Connection::Ruby30Patch
+    attr_accessor uri: String
+    attr_accessor pool_size: Integer
+    attr_accessor pool_timeout: Integer
 
-    # _@param_ `uri` — PostgreSQL connection URI. Example: "postgresql://postgres:postgres@localhost:5432/eventstore"
-    #
-    # _@param_ `pool_size` — Connection pool size
-    #
-    # _@param_ `pool_timeout` — Connection pool timeout in seconds
     def initialize: (uri: String, ?pool_size: Integer, ?pool_timeout: Integer) -> void
 
-    def shutdown: -> untyped
+    def discard_current_connection: -> void
 
-    def with: () { (PG::Connection connection) -> untyped } -> untyped
+    def establish_connection: -> void
 
-    def init_pool: () -> ConnectionPool[untyped]
+    def shutdown: -> void
 
-    def pg_type_registry: () -> PG::BasicTypeRegistry
+    def with: () { (PgConnection connection) -> untyped } -> untyped
 
-    # Returns the value of attribute uri.
-    attr_accessor uri: String
+    private
 
-    # Returns the value of attribute pool_size.
-    attr_accessor pool_size: Integer
+    def init_pool: () -> ConnectionPool[PgConnection]
 
-    # Returns the value of attribute pool_timeout.
-    attr_accessor pool_timeout: Integer
+    def pg_type_registry: () -> PG::BasicTypeRegistry
   end
 end