pg_eventstore 2.0.0 → 3.0.0

data/sig/interfaces/subscription_handler.rbs

@@ -1,3 +1,3 @@
 interface _SubscriptionHandler
-  def call: (PgEventstore::Event event) -> void
+  def call: (PgEventstore::Event | Array[PgEventstore::Event] event) -> void
 end

data/sig/pg/result.rbs

@@ -0,0 +1,9 @@
+module PG
+  class Result
+    def map_types!: (untyped type_map) -> self
+
+    def field_names_as: (Symbol type_map) -> self
+
+    def inspect: -> String
+  end
+end

data/sig/pg_eventstore/async_runner.rbs

@@ -0,0 +1,13 @@
+module PgEventstore
+  class AsyncRunner
+    @jobs: Hash[Fiber, bool]
+
+    def async: () { -> void } -> void
+
+    def jobs_size: -> Integer
+
+    def run: -> void
+
+    def run_once: -> void
+  end
+end

data/sig/pg_eventstore/basic_config.rbs

@@ -0,0 +1,9 @@
+module PgEventstore
+  class BasicConfig
+    include Extensions::OptionsExtension
+
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, **untyped options) -> void
+  end
+end

data/sig/pg_eventstore/chunks/chunk.rbs

@@ -0,0 +1,13 @@
+module PgEventstore
+  module Chunks
+    module Chunk[unchecked ElemIn, unchecked ElemOut]
+      def drained?: -> bool
+
+      def last: -> ElemIn?
+
+      def size: -> Integer
+
+      def take: (Integer? size) -> Array[ElemOut]
+    end
+  end
+end

data/sig/pg_eventstore/chunks/read_api_events_index_chunk.rbs

@@ -0,0 +1,30 @@
+module PgEventstore
+  module Chunks
+    class ReadApiEventsIndexChunk
+      include Chunk[EventGlobalIndex::ReadApiRepr, Hash[String, untyped]]
+
+      MAX_PARTITIONS_TO_RESOLVE_PER_CALL: Integer
+
+      @connection: Connection
+      @raw_events: Array[Hash[String, untyped]]
+      @idx_direction: Symbol
+      @indexes: Array[EventGlobalIndex::ReadApiRepr]
+      @query_strategy: QueryStrategy
+      @resolve_link_tos: bool
+      @resolved: bool
+
+      def initialize: (Array[EventGlobalIndex::ReadApiRepr] indexes, Connection connection,
+          QueryStrategy query_strategy, bool resolve_link_tos) -> void
+
+      private
+
+      def detect_direction: (EventGlobalIndex::ReadApiRepr? idx1, EventGlobalIndex::ReadApiRepr? idx2) -> Symbol
+
+      def events_global_index_queries: -> EventsGlobalIndexQueries
+
+      def resolve_indexes: -> void
+
+      def resolved?: -> bool
+    end
+  end
+end

data/sig/pg_eventstore/chunks/replica_events_index_chunk.rbs

@@ -0,0 +1,11 @@
+module PgEventstore
+  module Chunks
+    class ReplicaEventsIndexChunk
+      include Chunk[EventGlobalIndex::SubscriptionRepr, EventGlobalIndex::SubscriptionRepr]
+
+      @indexes: Array[EventGlobalIndex::SubscriptionRepr]
+
+      def initialize: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> void
+    end
+  end
+end

data/sig/pg_eventstore/chunks/repository.rbs

@@ -0,0 +1,22 @@
+module PgEventstore
+  module Chunks
+    class Repository
+      include MonitorMixin
+
+      @chunks: SynchronizedArray[Chunk[untyped, untyped]]
+
+      def add_chunk: (Chunk[untyped, untyped] chunk, ?condition: MonitorMixin::ConditionVariable?) -> void
+
+      def clear: -> void
+
+      def consume_all: -> untyped
+
+      def empty?: -> bool
+
+      def size: -> Integer
+
+      def wait_and_consume: (entities_num: Integer?, timeout: Float | Integer,
+          condition: MonitorMixin::ConditionVariable) -> Array[untyped]
+    end
+  end
+end

data/sig/pg_eventstore/chunks/subscription_checkpoint_chunk.rbs

@@ -0,0 +1,18 @@
+module PgEventstore
+  module Chunks
+    class SubscriptionCheckpointChunk
+      class Checkpoint
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        attr_reader subscription_position: Integer
+      end
+
+      include Chunk[Checkpoint, Checkpoint]
+
+      @checkpoint_event: Checkpoint?
+
+      def initialize: (Integer position) -> void
+    end
+  end
+end

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: (?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/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