pg_eventstore 2.0.0 → 3.0.0

data/sig/pg_eventstore/queries/events_global_index_queries.rbs

@@ -0,0 +1,37 @@
+module PgEventstore
+  class EventsGlobalIndexQueries
+    @query_strategy: QueryStrategy
+
+    attr_reader connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+    def fetch_indexes_for_subscriptions: (Hash[Integer, Hash[Symbol, untyped]] grouped_opts) ->
+      Hash[Integer, Array[EventGlobalIndex::SubscriptionRepr]]
+
+    def global_positions_from_db: (Array[Event] events) -> Array[Integer]
+
+    def index_events: (Array[Hash[String, untyped]] raw_events, Array[Partition] affected_partitions,
+        Integer stream_index_id) -> Array[EventGlobalIndex::WriteApiRepr]
+
+    def max_global_position: -> Integer?
+
+    def resolve_indexes: (Array[EventGlobalIndex::ReadApiRepr] | Array[EventGlobalIndex::SubscriptionRepr] indexes,
+        ?direction: (String | Symbol)?, resolve_link_tos: bool) -> Array[Hash[String, untyped]]
+
+    private
+
+    def deserialize: (PG::Result pg_result, ?repr: Symbol?) ->
+      (
+        Array[EventGlobalIndex] |
+        Array[EventGlobalIndex::ReadApiRepr] |
+        Array[EventGlobalIndex::SubscriptionRepr] |
+          Array[EventGlobalIndex::WriteApiRepr] |
+          Array[EventGlobalIndex::RevisionCheckRepr]
+      )
+
+    def links_resolver: -> LinksResolver
+
+    def partition_queries: -> PartitionQueries
+  end
+end

data/sig/pg_eventstore/queries/index_filtering_queries.rbs

@@ -0,0 +1,50 @@
+module PgEventstore
+  class IndexFilteringQueries
+    @query_strategy: QueryStrategy
+
+    attr_reader connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+    def compute_read_api_chunks_repo: (
+        Array[EventGlobalIndex::ReadApiRepr] indexes,
+        bool resolve_link_tos
+      ) -> Chunks::Repository
+
+    def fetch_grouped_indexes_for_read_api: (
+        QueryBuilders::Filters::Collection filters_collection,
+        QueryBuilders::ReadCursor::StreamCursor cursor
+      ) -> Array[EventGlobalIndex::ReadApiRepr]
+
+    def fetch_indexes_for_read_api: (
+        QueryBuilders::Filters::Collection filters_collection,
+        QueryBuilders::ReadCursor::StreamCursor cursor
+      ) -> Array[EventGlobalIndex::ReadApiRepr]
+
+    def fetch_indexes_for_revision_validation: (
+        Stream stream,
+        Array[
+          Commands::RevisionCheck::ExpectedRevision::EventTypeRevision |
+          Commands::RevisionCheck::ExpectedRevision::EventTypeRevisionWithMarkers |
+          Commands::RevisionCheck::ExpectedRevision::MarkersRevision
+        ] expected_revisions
+      ) -> Array[EventGlobalIndex::RevisionCheckRepr]
+
+    private
+
+    def deserialize: (PG::Result pg_result, ?repr: Symbol?) ->
+      (
+        Array[EventGlobalIndex] |
+        Array[EventGlobalIndex::ReadApiRepr] |
+        Array[EventGlobalIndex::SubscriptionRepr] |
+        Array[EventGlobalIndex::WriteApiRepr] |
+        Array[EventGlobalIndex::RevisionCheckRepr]
+      )
+
+    def expand_event_types: (
+        QueryBuilders::Filters::Collection filters_collection
+      ) -> Array[QueryBuilders::Filters::FilterRow | QueryBuilders::Filters::MarkerFilterRow]
+
+    def partition_queries: -> PartitionQueries
+  end
+end

data/sig/pg_eventstore/queries/links_resolver.rbs

@@ -1,19 +1,15 @@
 module PgEventstore
   class LinksResolver
-    # _@param_ `connection`
-    def initialize: (Connection connection) -> void
+    @query_strategy: QueryStrategy
+
+    attr_accessor connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
 
-    # _@param_ `raw_events`
     def resolve: (::Array[::Hash[String, untyped]] raw_events) -> ::Array[::Hash[String, untyped]]
 
-    # _@param_ `link_events` — partition id to link events association
-    #
-    # _@return_ — original events
     def load_original_events: (::Hash[Integer, ::Array[::Hash[String, untyped]]] link_events) -> ::Array[::Hash[String, untyped]]
 
     def partition_queries: () -> PartitionQueries
-
-    # Returns the value of attribute connection.
-    attr_accessor connection: Connection
   end
 end

data/sig/pg_eventstore/queries/maintenance_queries.rbs

@@ -1,21 +1,24 @@
 module PgEventstore
   class MaintenanceQueries
-    attr_reader connection: PgEventstore::Connection
+    EVENT_INDEXES_TO_REMOVE_PER_QUERY: Integer
+    EVENT_INDEXES_TO_UPDATE_PER_QUERY: Integer
 
-    def initialize: (PgEventstore::Connection connection)-> untyped
+    attr_reader connection: Connection
 
-    def adjust_stream_revisions: (PgEventstore::Stream stream, Integer after_revision)-> void
+    def initialize: (Connection connection) -> untyped
 
-    def delete_event: (PgEventstore::Event event)-> Integer
+    def delete_event: (Event event) -> void
 
-    def delete_stream: (PgEventstore::Stream stream)-> Integer
+    def delete_stream: (Stream stream) -> Integer
 
-    def events_to_lock_count: (PgEventstore::Stream stream, Integer after_revision)-> Integer
-
-    def reload_event: (PgEventstore::Event event)-> PgEventstore::Event?
+    def events_to_lock_count: (Stream stream, Integer after_revision) -> Integer
 
     private
 
-    def basic_deserializer: -> PgEventstore::EventDeserializer
+    def partition_queries: -> PartitionQueries
+
+    def streams_global_index_queries: -> StreamsGlobalIndexQueries
+
+    def transaction_queries: -> TransactionQueries
   end
 end

data/sig/pg_eventstore/queries/partition_queries.rbs

@@ -1,78 +1,43 @@
 module PgEventstore
   class PartitionQueries
-    # _@param_ `connection`
-    def initialize: (PgEventstore::Connection connection) -> void
-
-    # _@param_ `stream`
-    #
-    # _@return_ — partition attributes
-    def create_context_partition: (PgEventstore::Stream stream) -> ::Hash[untyped, untyped]
-
-    # _@param_ `stream`
-    #
-    # _@param_ `context_partition_name`
-    #
-    # _@return_ — partition attributes
-    def create_stream_name_partition: (PgEventstore::Stream stream, String context_partition_name) -> ::Hash[untyped, untyped]
-
-    # _@param_ `stream`
-    #
-    # _@param_ `event_type`
-    #
-    # _@param_ `stream_name_partition_name`
-    #
-    # _@return_ — partition attributes
-    def create_event_type_partition: (PgEventstore::Stream stream, String event_type, String stream_name_partition_name) -> ::Hash[untyped, untyped]
-
-    # _@param_ `stream`
-    #
-    # _@param_ `event_type`
-    def partition_required?: (PgEventstore::Stream stream, String event_type) -> bool
-
-    # _@param_ `stream`
-    #
-    # _@param_ `event_type`
-    def create_partitions: (PgEventstore::Stream stream, String event_type) -> void
-
-    # _@param_ `stream`
-    #
-    # _@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,
-        ?scope: Symbol) -> Array[Partition]
-
-    # _@param_ `stream`
-    #
-    # _@return_ — partition attributes
-    def stream_name_partition: (PgEventstore::Stream stream) -> ::Hash[untyped, untyped]?
-
-    # _@param_ `stream`
-    #
-    # _@param_ `event_type`
-    #
-    # _@return_ — partition attributes
-    def event_type_partition: (PgEventstore::Stream stream, String event_type) -> ::Hash[untyped, untyped]?
-
-    # _@param_ `table_name`
+    @query_strategy: QueryStrategy
+
+    attr_accessor connection: Connection
+
+    def initialize: (Connection connection, ?QueryStrategy query_strategy) -> void
+
+    def attach_event_type_partition: (Partition partition) -> void
+
+    def create_context_partition: (Stream stream) -> ::Hash[untyped, untyped]
+
+    def create_stream_name_partition: (Stream stream, Integer context_partition_id) -> ::Hash[untyped, untyped]
+
+    def create_event_type_partition: (Stream stream, String event_type,
+        Integer context_partition_id, Integer stream_name_partition_id) -> ::Hash[untyped, untyped]
+
+    def detach_event_type_partition: (Partition partition) -> void
+
+    def partition_required?: (Stream stream, String event_type) -> bool
+
+    def create_partitions: (Stream stream, String event_type) -> void
+
+    def context_partition: (Stream stream) -> ::Hash[untyped, untyped]?
+
+    def partitions: (QueryBuilders::Filters::Collection filters_collection, ?scope: Symbol) -> Array[Partition]
+
+    def stream_name_partition: (Stream stream) -> ::Hash[untyped, untyped]?
+
+    def event_type_partition: (Stream stream, String event_type) -> ::Hash[untyped, untyped]?
+
     def partition_name_taken?: (String table_name) -> bool
 
-    # _@param_ `ids`
     def find_by_ids: (::Array[Integer] ids) -> ::Array[::Hash[untyped, untyped]]
 
-    # _@param_ `stream`
-    def context_partition_name: (PgEventstore::Stream stream) -> String
-
-    # _@param_ `stream`
-    def stream_name_partition_name: (PgEventstore::Stream stream) -> String
+    def context_partition_name: (Stream stream) -> String
 
-    # _@param_ `stream`
-    #
-    # _@param_ `event_type`
-    def event_type_partition_name: (PgEventstore::Stream stream, String event_type) -> String
+    def stream_name_partition_name: (Stream stream) -> String
 
-    # Returns the value of attribute connection.
-    attr_accessor connection: PgEventstore::Connection
+    def event_type_partition_name: (Stream stream, String event_type) -> String
 
     private
 

data/sig/pg_eventstore/queries/replica_queries.rbs

@@ -0,0 +1,31 @@
+module PgEventstore
+  class ReplicaQueries
+    MAX_PARTITIONS_TO_RESOLVE_PER_CALL: Integer
+
+    @query_strategy: QueryStrategy
+
+    attr_reader connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+    def load_event_markers_index: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> Array[EventMarkerIndex]
+
+    def load_events: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> Array[RawEvent]
+
+    def load_events_global_index: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> Array[EventGlobalIndex]
+
+    def load_markers: (Array[EventMarkerIndex] indexes) -> Array[EventMarker]
+
+    def load_partitions: (Array[EventGlobalIndex] indexes) -> Array[Partition]
+
+    def load_streams_global_index: (Array[EventGlobalIndex] indexes) -> Array[StreamGlobalIndex]
+
+    def load_subscription_positions: (Array[EventGlobalIndex::SubscriptionRepr] indexes) -> Array[Integer]
+
+    private
+
+    def events_global_index_queries: -> EventsGlobalIndexQueries
+
+    def partition_queries: -> PartitionQueries
+  end
+end

data/sig/pg_eventstore/queries/streams_global_index_queries.rbs

@@ -0,0 +1,39 @@
+module PgEventstore
+  class StreamsGlobalIndexQueries
+    @query_strategy: QueryStrategy
+
+    attr_reader connection: Connection
+
+    def initialize: (Connection connection, QueryStrategy query_strategy) -> void
+
+    def create: (Stream stream) -> StreamGlobalIndex
+
+    def delete: (Integer id) -> bool
+
+    def find_by: (Stream stream) -> StreamGlobalIndex?
+
+    def find_by!: (Stream stream) -> StreamGlobalIndex
+
+    def find_or_create_by: (Stream stream) -> StreamGlobalIndex
+
+    def resolve_indexes: (Array[StreamGlobalIndex] indexes) -> Array[Stream]
+
+    def stream_exists?: (Stream stream) -> bool
+
+    def stream_revision: (Stream stream) -> Integer?
+
+    def streams_global_index: (Hash[Symbol, untyped]) -> Array[StreamGlobalIndex]
+
+    def update: (Integer id, **untyped attrs) -> void
+
+    private
+
+    def deserialize_many: (PG::Result pg_result) -> Array[StreamGlobalIndex]
+
+    def deserialize_one: (PG::Result pg_result) -> StreamGlobalIndex?
+
+    def partition_queries: -> PartitionQueries
+
+    def transaction_queries: -> TransactionQueries
+  end
+end

data/sig/pg_eventstore/queries/transaction_queries.rbs

@@ -2,6 +2,8 @@ module PgEventstore
   class TransactionQueries
     ISOLATION_LEVELS: ::Hash[Symbol, String]
 
+    MAX_NUMBER_OF_UNIQUE_CONSTRAINTS_ERROR_RETRIES: Integer
+
     # _@param_ `connection`
     def initialize: (PgEventstore::Connection connection) -> void
 

data/sig/pg_eventstore/queries.rbs

@@ -1,25 +1,15 @@
 module PgEventstore
   class Queries
-    include PgEventstore::Extensions::OptionsExtension
-
-    attr_accessor events: PgEventstore::EventQueries?
-
-    attr_accessor partitions: PgEventstore::PartitionQueries?
-
-    attr_accessor transactions: PgEventstore::TransactionQueries?
-
-    attr_accessor maintenance: PgEventstore::MaintenanceQueries?
-
-    def initialize: (**untyped options) -> void
-
-    def options_hash: () -> ::Hash[untyped, untyped]
-
-    def readonly!: (Symbol opt_name) -> bool
-
-    def readonly?: (Symbol opt_name) -> bool
-
-    def readonly_error: (Symbol opt_name) -> void
-
-    def init_default_values: (::Hash[untyped, untyped] options) -> void
+    include Extensions::OptionsExtension
+
+    attr_accessor events: EventQueries?
+    attr_accessor partitions: PartitionQueries?
+    attr_accessor transactions: TransactionQueries?
+    attr_accessor maintenance: MaintenanceQueries?
+    attr_accessor events_global_index: EventsGlobalIndexQueries?
+    attr_accessor streams_global_index: StreamsGlobalIndexQueries?
+    attr_accessor event_subscription_positions: EventSubscriptionPositionQueries?
+    attr_accessor event_markers: EventMarkerQueries?
+    attr_accessor index_filtering: IndexFilteringQueries?
   end
 end

data/sig/pg_eventstore/query_builders/basic_filtering.rbs

@@ -1,9 +1,16 @@
 module PgEventstore
   module QueryBuilders
-    class BasicFiltering
-      @sql_builder: SQLBuilder
+    module BasicFiltering
+      module ClassMethods
 
-      def initialize: -> void
+        def ascending?: ((String | Symbol)? order) -> bool
+
+        def descending?: ((String | Symbol)? order) -> bool
+
+        def reverse_order: ((String | Symbol)? order) -> Symbol
+      end
+
+      SQL_DIRECTIONS: Hash[String | Symbol, String]
 
       def to_exec_params: -> [String, Array[untyped]]
 

data/sig/pg_eventstore/query_builders/event_markers_filtering.rbs

@@ -0,0 +1,17 @@
+module PgEventstore
+  module QueryBuilders
+    class EventMarkersFiltering
+      PRIMARY_TABLE_NAME: String
+
+      include BasicFiltering
+
+      @sql_builder: SQLBuilder
+
+      def self.sql_builder_by_names: (Array[String] names) -> SQLBuilder
+
+      def add_name: (String name) -> void
+
+      def add_names: (Array[String] names) -> void
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/event_markers_index_filtering.rbs

@@ -0,0 +1,69 @@
+module PgEventstore
+  module QueryBuilders
+    class EventMarkersIndexFiltering
+      DEFAULT_LIMIT: Integer
+      PRIMARY_TABLE_NAME: String
+
+      include BasicFiltering
+
+      @sql_builder: SQLBuilder
+
+      def self.for_read_common: (
+          Filters::MarkerFilterRow marker_filter_row,
+          ReadCursor::StreamCursor cursor
+        ) -> SQLBuilder
+
+      def self.for_read_grouped: (
+          Filters::MarkerFilterRow marker_filter_row,
+          ReadCursor::StreamCursor cursor
+        ) -> SQLBuilder
+
+      def self.for_revision_validation_per_type: (
+          Filters::MarkerFilterRow marker_filter_row,
+          ReadCursor::StreamCursor cursor,
+          Integer seq_num
+        ) -> SQLBuilder
+
+      def add_global_position_direction: ((String | Symbol)? direction) -> void
+
+      def add_limit: (Integer? limit) -> void
+
+      def add_marker_filter_row: (Filters::MarkerFilterRow marker_filter_row) -> void
+
+      def add_stream_revision_direction: ((String | Symbol)? direction) -> void
+
+      def for_subscription: -> void
+
+      def from_position: (Integer? position, (String | Symbol)? direction) -> void
+
+      def from_revision: ((Integer | SQLBuilder)? revision, (String | Symbol)? direction) -> void
+
+      def to_position: (Integer? position, (String | Symbol)? direction) -> void
+
+      def to_revision: ((Integer | SQLBuilder)? revision, (String | Symbol)? direction) -> void
+
+      private
+
+      def self.add_direction_and_limit: (
+          EventMarkersIndexFiltering index_filtering,
+          ReadCursor::StreamCursor cursor
+        )-> void
+
+      def self.default_filtering: (ReadCursor::StreamCursor cursor) -> EventMarkersIndexFiltering
+
+      def self.filtering_from_filter_row: (
+          Filters::MarkerFilterRow marker_filter_row,
+          ReadCursor::StreamCursor cursor
+        ) -> EventMarkersIndexFiltering
+
+      def self.stream_revision_based_filtering: (
+          ReadCursor::StreamCursor cursor, 
+          Filters::MarkerFilterRow marker_filter_row
+        ) -> EventMarkersIndexFiltering
+
+      def direction_operator_from: ((String | Symbol)? direction) -> String
+
+      def direction_operator_to: ((String | Symbol)? direction) -> String
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/event_subscription_positions_filtering.rbs

@@ -0,0 +1,15 @@
+module PgEventstore
+  module QueryBuilders
+    class EventSubscriptionPositionsFiltering
+      include BasicFiltering
+
+      PRIMARY_TABLE_NAME: String
+
+      @sql_builder: SQLBuilder
+
+      def by_global_positions: (Array[Integer] positions)-> void
+
+      def max_subscription_position: -> void
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/events_filtering_query.rbs

@@ -1,68 +1,26 @@
 module PgEventstore
   module QueryBuilders
     # @!visibility private
-    class EventsFiltering < BasicFiltering
-      DEFAULT_LIMIT: Integer
-      SQL_DIRECTIONS: Hash[String | Symbol, String]
-      SUBSCRIPTIONS_OPTIONS: ::Array[Symbol]
-
-      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]
+    class EventsFiltering
+      include BasicFiltering
 
-      def self.extract_streams_filter: (Hash[untyped, untyped] options) -> Array[Hash[untyped, untyped]]
-
-      # _@param_ `options`
-      def self.subscriptions_events_filtering: (::Hash[untyped, untyped] options) -> EventsFiltering
-
-      # _@param_ `options`
-      def self.all_stream_filtering: (::Hash[untyped, untyped] options) -> EventsFiltering
-
-      # _@param_ `stream`
-      #
-      # _@param_ `options`
-      def self.specific_stream_filtering: (Stream stream, ::Hash[untyped, untyped] options) -> EventsFiltering
+      DEFAULT_LIMIT: Integer
 
-      def self.system_stream_filtering: (Stream stream, Hash[untyped, untyped] options) -> EventsFiltering
+      @sql_builder: SQLBuilder
 
-      def initialize: () -> void
+      def initialize: -> void
 
-      def add_stream_attrs: (?context: String?, ?stream_name: String?, ?stream_id: String?) -> void
+      def add_stream_attrs: (context: String, stream_name: String) -> void
 
       def add_event_types: (::Array[String] event_types) -> void
 
-      # _@param_ `revision`
-      #
-      # _@param_ `direction`
-      def add_revision: (Integer? revision, (String | Symbol)? direction) -> void
-
-      # _@param_ `position`
-      #
-      # _@param_ `direction`
-      def add_global_position: (Integer? position, (String | Symbol)? direction) -> void
-
-      # _@param_ `direction`
-      def add_stream_direction: ((String | Symbol)? direction) -> void
-
-      # _@param_ `direction`
-      def add_all_stream_direction: ((String | Symbol)? direction) -> void
-
-      # _@param_ `limit`
       def add_limit: (Integer? limit) -> void
 
-      def set_source: (String table_name)-> void
-
-      def to_sql_builder: () -> SQLBuilder
-
-      def to_exec_params: () -> [String, Array[untyped]]
-
-      # _@param_ `stream_attrs`
       def correct_stream_filter?: (::Hash[untyped, untyped] stream_attrs) -> bool
 
-      # _@param_ `direction`
-      def direction_operator: ((String | Symbol)? direction) -> String
+      private
+
+      def comparison_operator: (Array[String] event_types) -> String
     end
   end
 end

data/sig/pg_eventstore/query_builders/events_global_index_filtering.rbs

@@ -0,0 +1,68 @@
+module PgEventstore
+  module QueryBuilders
+    class EventsGlobalIndexFiltering
+      include BasicFiltering
+
+      DEFAULT_LIMIT: Integer
+      PRIMARY_TABLE_NAME: String
+
+      @sql_builder: SQLBuilder
+
+      def self.default_filtering: (ReadCursor::StreamCursor cursor) -> EventsGlobalIndexFiltering
+
+      def self.for_read_common: (
+          Filters::FilterRow filter_row,
+          ReadCursor::StreamCursor cursor
+        )-> SQLBuilder
+
+      def self.for_read_grouped: (
+          Filters::FilterRow filter_row,
+          ReadCursor::StreamCursor cursor
+        )-> SQLBuilder
+
+      def self.for_revision_validation_per_type: (
+          Filters::FilterRow filter_row, 
+          ReadCursor::StreamCursor cursor,
+          Integer seq_num
+        )-> SQLBuilder
+
+      def initialize: -> void
+
+      def add_filter_row: (Filters::FilterRow filter_row) -> void
+
+      def add_global_position_direction: (String? | Symbol? direction) -> void
+
+      def add_limit: (Integer? limit) -> void
+
+      def add_stream_revision_direction: (String? | Symbol? direction) -> void
+
+      def for_subscription: -> void
+
+      def from_position: (Integer? position, String? | Symbol? direction) -> void
+
+      def from_revision: (Integer? revision, String? | Symbol? direction) -> void
+
+      def to_position: (Integer? position, String? | Symbol? direction) -> void
+
+      def to_revision: (Integer? revision, String? | Symbol? direction) -> void
+
+      private
+
+      def self.add_direction_and_limit: (
+          EventsGlobalIndexFiltering index_filtering,
+          ReadCursor::StreamCursor cursor
+        ) -> void
+
+      def self.filtering_from_filter_row: (
+          Filters::FilterRow filter_row,
+          ReadCursor::StreamCursor cursor
+        ) -> EventsGlobalIndexFiltering
+
+      def direction_operator_from: (String? | Symbol? direction) -> String
+
+      def direction_operator_to: (String? | Symbol? direction) -> String
+
+      def event_type_comparison: (Filters::FilterRow filter_row) -> Array[String]
+    end
+  end
+end