pg_eventstore 1.13.4 → 3.0.0

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,16 +2,18 @@ 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
 
     # _@param_ `level` — transaction isolation level
-    def transaction: (?Symbol level) { () -> untyped } -> void
+    def transaction: (?Symbol level, ?read_only: bool) { () -> untyped } -> void
 
     # _@param_ `level` — PostgreSQL transaction isolation level
     #
     # _@param_ `pg_connection`
-    def pg_transaction: (String level, PG::Connection pg_connection) { () -> untyped } -> void
+    def pg_transaction: (String level, bool read_only, PG::Connection pg_connection) { () -> untyped } -> void
 
     def partition_queries: () -> PgEventstore::PartitionQueries
 

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

data/sig/pg_eventstore/query_builders/filters/collection.rbs

@@ -0,0 +1,84 @@
+module PgEventstore
+  module QueryBuilders
+    module Filters
+      class Collection
+        @compiled: Array[FilterRow]?
+        @event_types: Set[EventTypeFilter]
+        @incomplete_markers_filter: bool
+        @incomplete_stream_filter: bool
+        @markers: Set[MarkerFilter]
+        @streams: Index
+        @prefix_filter: bool
+
+        def self.from_options: (Hash[untyped, untyped] options) -> Collection
+
+        def self.from_stream_and_options: (Stream stream, Hash[untyped, untyped] options) -> Collection
+
+        def add_event_type: (EventTypeFilter event_type_filter) -> untyped
+
+        def add_marker: (MarkerFilter marker_filter) -> void
+
+        def add_stream: (StreamFilter stream_filter) -> void
+
+        def collection: -> Array[FilterRow | MarkerFilterRow]
+
+        def empty?: -> bool
+
+        def has_event_types?: -> bool
+
+        def has_incomplete_markers_filter?: -> bool
+
+        def has_incomplete_stream_filter?: -> bool
+
+        def has_markers?: -> bool
+
+        def has_prefix_filter?: -> bool
+
+        private
+
+        def self.extract_event_types_filter: (
+            Collection instance,
+            Array[String | Hash[untyped, untyped]] event_types
+          ) -> void
+
+        def self.extract_streams_filter: (Collection instance, Array[Hash[Symbol, untyped]]? streams) -> void
+
+        def self.unsupported_filter_warning: (untyped stream_attrs) -> void
+
+        class Index
+
+          attr_reader path: Hash[String, Index]
+
+          attr_accessor stream_filter: QueryBuilders::Filters::StreamFilter?
+
+          def empty?: -> bool
+
+          def find_non_overlapping: (?Index root) -> Array[QueryBuilders::Filters::StreamFilter]
+
+          def index: (StreamFilter stream_filter) -> void
+        end
+
+        def compile: -> void
+
+        def marker_filter_overlaps_with_event_type_filter?: (
+            MarkerFilter marker_filter,
+            Array[EventTypeFilter] prefix_filters
+          ) -> bool
+
+        def marker_filter_overlaps_with_prefix_filter?: (
+            MarkerFilter marker_filter,
+            Array[EventTypeFilter] prefix_filters
+          ) -> bool
+
+        def non_overlapping_event_types: -> Array[Array[EventTypeFilter]]
+
+        def non_overlapping_markers: (
+            Array[EventTypeFilter] event_types_with_prefixes,
+            Array[EventTypeFilter] event_types_without_prefixes
+          ) -> Array[MarkerFilter]
+
+        def reset: -> void
+      end
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/filters/event_type_filter.rbs

@@ -0,0 +1,19 @@
+module PgEventstore
+  module QueryBuilders
+    module Filters
+      class EventTypeFilter
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        attr_accessor event_type: String?
+        attr_accessor prefix: bool
+
+        def self.null_filter: -> EventTypeFilter
+
+        def prefix?: -> bool
+
+        def to_sql_value: -> String?
+      end
+    end
+  end
+end

data/sig/pg_eventstore/query_builders/filters/filter_row.rbs

@@ -0,0 +1,21 @@
+module PgEventstore
+  module QueryBuilders
+    module Filters
+      class FilterRow
+        include Extensions::OptionsExtension
+        include Extensions::OptionsDefaults
+
+        def self.null_filter_row: -> FilterRow
+
+        attr_accessor stream_filter: StreamFilter?
+        attr_accessor event_type_filters: Array[EventTypeFilter]
+
+        def ambiguous_event_type?: -> bool
+
+        def collapsable_into_event_types_only?: -> bool
+
+        def flatten: -> Array[FilterRow]
+      end
+    end
+  end
+end