pg_eventstore 1.1.3 → 1.1.4

data/sig/pg_eventstore/event_deserializer.rbs

@@ -0,0 +1,20 @@
+module PgEventstore
+  class EventDeserializer
+    # _@param_ `middlewares`
+    #
+    # _@param_ `event_class_resolver`
+    def initialize: (::Array[PgEventstore::Middleware] middlewares, _EventClassResolver event_class_resolver) -> void
+
+    # _@param_ `raw_events`
+    def deserialize_many: (::Array[::Hash[untyped, untyped]] raw_events) -> ::Array[PgEventstore::Event]
+
+    # _@param_ `attrs`
+    def deserialize: (::Hash[untyped, untyped] attrs) -> PgEventstore::Event
+
+    def without_middlewares: () -> PgEventstore::EventDeserializer
+
+    attr_accessor middlewares: ::Array[PgEventstore::Middleware]
+
+    attr_accessor event_class_resolver: _EventClassResolver
+  end
+end

data/sig/pg_eventstore/event_serializer.rbs

@@ -0,0 +1,13 @@
+module PgEventstore
+  class EventSerializer
+    # _@param_ `middlewares`
+    def initialize: (::Array[PgEventstore::Middleware] middlewares) -> void
+
+    # _@param_ `event`
+    def serialize: (PgEventstore::Event event) -> PgEventstore::Event
+
+    def without_middlewares: () -> PgEventstore::EventSerializer
+
+    attr_accessor middlewares: ::Array[PgEventstore::Middleware]
+  end
+end

data/sig/pg_eventstore/extensions/callbacks_extension.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  module Extensions
+    module CallbacksExtension
+      def self.included: (untyped klass) -> untyped
+
+      def define_callback: (*untyped) -> void
+
+      module InitCallbacks
+        def initialize: (*untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> void
+      end
+
+      module ClassMethods
+        # _@param_ `action`
+        #
+        # _@param_ `method_name`
+        def has_callbacks: ((String | Symbol) action, Symbol method_name) -> void
+
+        # _@param_ `method_name`
+        def visibility_method: (Symbol method_name) -> Symbol
+      end
+    end
+  end
+end

data/sig/pg_eventstore/extensions/options_extension.rbs

@@ -0,0 +1,37 @@
+module PgEventstore
+  module Extensions
+    module OptionsExtension
+      def self.included: (untyped klass) -> untyped
+
+      def initialize: (**untyped options) -> void
+
+      # Construct a hash from options, where key is the option's name and the value is option's
+      # value
+      def options_hash: () -> ::Hash[untyped, untyped]
+
+      # _@param_ `opt_name`
+      def readonly!: (Symbol opt_name) -> bool
+
+      # _@param_ `opt_name`
+      def readonly?: (Symbol opt_name) -> bool
+
+      # _@param_ `opt_name`
+      def readonly_error: (Symbol opt_name) -> void
+
+      # _@param_ `options`
+      def init_default_values: (::Hash[untyped, untyped] options) -> void
+
+      module ClassMethods
+        # _@param_ `opt_name` — option name
+        #
+        # _@param_ `blk` — provide define value using block. It will be later evaluated in the context of your object to determine the default value of the option
+        def option: (Symbol opt_name) ?{ () -> untyped } -> Symbol
+
+        def inherited: (untyped klass) -> untyped
+
+        # _@param_ `method_name`
+        def warn_already_defined: (Symbol method_name) -> void
+      end
+    end
+  end
+end

data/sig/pg_eventstore/extensions/using_connection_extension.rbs

@@ -0,0 +1,14 @@
+module PgEventstore
+  module Extensions
+    module UsingConnectionExtension
+      def self.included: (untyped klass) -> untyped
+
+      module ClassMethods
+        def connection: () -> PgEventstore::Connection
+
+        # _@param_ `config_name`
+        def using_connection: (Symbol config_name) -> Class
+      end
+    end
+  end
+end

data/sig/pg_eventstore/middleware.rbs

@@ -0,0 +1,9 @@
+module PgEventstore
+  module Middleware
+    # _@param_ `event`
+    def serialize: (PgEventstore::Event event) -> void
+
+    # _@param_ `event`
+    def deserialize: (PgEventstore::Event event) -> void
+  end
+end

data/sig/pg_eventstore/pg_connection.rbs

@@ -0,0 +1,13 @@
+module PgEventstore
+  class PgConnection < PG::Connection
+    def exec: (untyped sql) -> untyped
+
+    def exec_params: (untyped sql, untyped params) -> untyped
+
+    def log: (untyped sql, untyped params) -> untyped
+
+    def encode_value: (untyped value) -> untyped
+
+    def normalize_value: (untyped value) -> untyped
+  end
+end

data/sig/pg_eventstore/queries/event_queries.rbs

@@ -0,0 +1,50 @@
+module PgEventstore
+  class EventQueries
+    # _@param_ `connection`
+    #
+    # _@param_ `serializer`
+    #
+    # _@param_ `deserializer`
+    def initialize: (PgEventstore::Connection connection, PgEventstore::EventSerializer serializer, PgEventstore::EventDeserializer deserializer) -> void
+
+    # _@param_ `event`
+    def event_exists?: (PgEventstore::Event event) -> bool
+
+    # _@param_ `events`
+    def ids_from_db: (::Array[PgEventstore::Event] events) -> ::Array[String]
+
+    # _@param_ `stream`
+    def stream_revision: (PgEventstore::Stream stream) -> Integer?
+
+    # _@param_ `stream`
+    #
+    # _@param_ `options`
+    def stream_events: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> ::Array[PgEventstore::Event]
+
+    # _@param_ `stream`
+    #
+    # _@param_ `events`
+    def insert: (PgEventstore::Stream stream, ::Array[PgEventstore::Event] events) -> ::Array[PgEventstore::Event]
+
+    # _@param_ `stream`
+    #
+    # _@param_ `events`
+    def prepared_statements: (PgEventstore::Stream stream, ::Array[PgEventstore::Event] events) -> ::Array[(::Array[String] | ::Array[Object])]
+
+    # _@param_ `stream`
+    #
+    # _@param_ `options`
+    def events_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+
+    def links_resolver: () -> PgEventstore::LinksResolver
+
+    # Returns the value of attribute connection.
+    attr_accessor connection: PgEventstore::Connection
+
+    # Returns the value of attribute serializer.
+    attr_accessor serializer: PgEventstore::EventSerializer
+
+    # Returns the value of attribute deserializer.
+    attr_accessor deserializer: PgEventstore::EventDeserializer
+  end
+end

data/sig/pg_eventstore/queries/links_resolver.rbs

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

data/sig/pg_eventstore/queries/partition_queries.rbs

@@ -0,0 +1,74 @@
+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]?
+
+    # _@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`
+    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
+
+    # _@param_ `stream`
+    #
+    # _@param_ `event_type`
+    def event_type_partition_name: (PgEventstore::Stream stream, String event_type) -> String
+
+    # Returns the value of attribute connection.
+    attr_accessor connection: PgEventstore::Connection
+  end
+end

data/sig/pg_eventstore/queries/transaction_queries.rbs

@@ -0,0 +1,21 @@
+module PgEventstore
+  class TransactionQueries
+    ISOLATION_LEVELS: ::Hash[Symbol, String]
+
+    # _@param_ `connection`
+    def initialize: (PgEventstore::Connection connection) -> void
+
+    # _@param_ `level` — transaction isolation level
+    def transaction: (?Symbol level) { () -> untyped } -> void
+
+    # _@param_ `level` — PostgreSQL transaction isolation level
+    #
+    # _@param_ `pg_connection`
+    def pg_transaction: (String level, PG::Connection pg_connection) { () -> untyped } -> void
+
+    def partition_queries: () -> PgEventstore::PartitionQueries
+
+    # Returns the value of attribute connection.
+    attr_accessor connection: PgEventstore::Connection
+  end
+end

data/sig/pg_eventstore/queries.rbs

@@ -0,0 +1,23 @@
+module PgEventstore
+  class Queries
+    include PgEventstore::Extensions::OptionsExtension
+
+    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
+
+    attr_accessor events: PgEventstore::EventQueries?
+
+    attr_accessor partitions: PgEventstore::PartitionQueries?
+
+    attr_accessor transactions: PgEventstore::TransactionQueries?
+  end
+end

data/sig/pg_eventstore/query_builders/events_filtering_query.rbs

@@ -0,0 +1,62 @@
+module PgEventstore
+  module QueryBuilders
+    # @!visibility private
+    class EventsFiltering
+      DEFAULT_LIMIT: Integer
+      SQL_DIRECTIONS: Hash[String | Symbol, String]
+      SUBSCRIPTIONS_OPTIONS: ::Array[Symbol]
+
+      # _@param_ `options`
+      def self.subscriptions_events_filtering: (::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+
+      # _@param_ `options`
+      def self.all_stream_filtering: (::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+
+      # _@param_ `stream`
+      #
+      # _@param_ `options`
+      def self.specific_stream_filtering: (PgEventstore::Stream stream, ::Hash[untyped, untyped] options) -> PgEventstore::QueryBuilders::EventsFiltering
+
+      def initialize: () -> void
+
+      # _@param_ `context`
+      #
+      # _@param_ `stream_name`
+      #
+      # _@param_ `stream_id`
+      def add_stream_attrs: (?context: String?, ?stream_name: String?, ?stream_id: String?) -> void
+
+      # _@param_ `event_types`
+      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 to_sql_builder: () -> PgEventstore::SQLBuilder
+
+      def to_exec_params: () -> ::Array[untyped]
+
+      # _@param_ `stream_attrs`
+      def correct_stream_filter?: (::Hash[untyped, untyped] stream_attrs) -> bool
+
+      # _@param_ `direction`
+      def direction_operator: ((String | Symbol)? direction) -> String
+    end
+  end
+end

data/sig/pg_eventstore/sql_builder.rbs

@@ -0,0 +1,74 @@
+module PgEventstore
+  class SQLBuilder
+    def initialize: () -> void
+
+    # _@param_ `sql`
+    def select: (String sql) -> self
+
+    def unselect: () -> self
+
+    # _@param_ `sql`
+    #
+    # _@param_ `arguments` — positional values
+    def where: (String sql, *untyped arguments) -> self
+
+    # _@param_ `sql`
+    #
+    # _@param_ `arguments` — positional values
+    def where_or: (String sql, *Object arguments) -> self
+
+    # _@param_ `table_name`
+    def from: (String table_name) -> self
+
+    # _@param_ `sql`
+    #
+    # _@param_ `arguments`
+    def join: (String sql, *Object arguments) -> self
+
+    # _@param_ `sql`
+    def order: (String sql) -> self
+
+    def remove_order: () -> self
+
+    # _@param_ `limit`
+    def limit: (Integer limit) -> self
+
+    def remove_limit: () -> self
+
+    # _@param_ `offset`
+    def offset: (Integer offset) -> self
+
+    # _@param_ `another_builder`
+    def union: (PgEventstore::SQLBuilder another_builder) -> self
+
+    # _@param_ `sql`
+    def group: (String sql) -> self
+
+    def remove_group: () -> self
+
+    def to_exec_params: () -> ::Array[(String | ::Array[untyped])]
+
+    def positional_values: () -> ::Array[Object]
+
+    # _@param_ `val`
+    def positional_values_size=: (Integer val) -> Integer
+
+    def _to_exec_params: () -> ::Array[(String | ::Array[untyped])]
+
+    def single_query_sql: () -> String
+
+    def union_query_sql: () -> String
+
+    def select_sql: () -> String
+
+    # _@param_ `join_pattern` — "OR"/"AND"
+    def where_sql: (String join_pattern) -> String
+
+    def join_sql: () -> String
+
+    def order_sql: () -> String
+
+    # _@param_ `sql`
+    def extract_positional_args: (String sql, *untyped arguments) -> String
+  end
+end

data/sig/pg_eventstore/stream.rbs

@@ -0,0 +1,40 @@
+module PgEventstore
+  class Stream
+    SYSTEM_STREAM_PREFIX: String
+    NON_EXISTING_STREAM_REVISION: Integer
+
+    def self.all_stream: () -> PgEventstore::Stream
+
+    # _@param_ `context`
+    #
+    # _@param_ `stream_name`
+    #
+    # _@param_ `stream_id`
+    def initialize: (context: String, stream_name: String, stream_id: String) -> void
+
+    def all_stream?: () -> bool
+
+    def system?: () -> bool
+
+    def deconstruct: () -> ::Array[untyped]
+
+    # _@param_ `keys`
+    def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, String]
+
+    def to_hash: () -> ::Hash[untyped, untyped]
+
+    def hash: () -> Integer
+
+    # _@param_ `another`
+    def eql?: (untyped another) -> bool
+
+    # _@param_ `other_stream`
+    def ==: (untyped other_stream) -> bool
+
+    attr_accessor context: String
+
+    attr_accessor stream_name: String
+
+    attr_accessor stream_id: String
+  end
+end

data/sig/pg_eventstore/subscriptions/basic_runner.rbs

@@ -0,0 +1,37 @@
+module PgEventstore
+  class BasicRunner
+    include PgEventstore::Extensions::CallbacksExtension
+    extend Forwardable
+
+    # _@param_ `run_interval` — seconds. Determines how often to run async task. Async task is determined by :after_runner_stopped callback
+    #
+    # _@param_ `async_shutdown_time` — seconds. Determines how long to wait for the async shutdown to wait for the runner to finish.
+    %a{rbs:test:skip} def initialize: ((Integer | Float) run_interval, (Integer | Float) async_shutdown_time) -> void
+
+    def start: () -> self
+
+    def stop: () -> self
+
+    def stop_async: () -> self
+
+    def restore: () -> self
+
+    def wait_for_finish: () -> self
+
+    def state: () -> String
+
+    # _@param_ `state`
+    def within_state: (Symbol state) { () -> untyped } -> untyped
+
+    def synchronize: () { () -> untyped } -> untyped
+
+    def _start: () -> void
+
+    def delegate_change_state_cbx: () -> void
+
+    # _@param_ `state`
+    def change_state: (String state) -> void
+
+    def define_callback: () -> void
+  end
+end

data/sig/pg_eventstore/subscriptions/command_handlers/subscription_feeder_commands.rbs

@@ -0,0 +1,16 @@
+module PgEventstore
+  module CommandHandlers
+    class SubscriptionFeederCommands
+      # _@param_ `config_name`
+      #
+      # _@param_ `subscription_feeder`
+      def initialize: (Symbol config_name, PgEventstore::SubscriptionFeeder subscription_feeder) -> void
+
+      def process: () -> void
+
+      def queries: () -> PgEventstore::SubscriptionsSetCommandQueries
+
+      def connection: () -> PgEventstore::Connection
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/command_handlers/subscription_runners_commands.rbs

@@ -0,0 +1,18 @@
+module PgEventstore
+  module CommandHandlers
+    class SubscriptionRunnersCommands
+      # _@param_ `config_name`
+      #
+      # _@param_ `runners`
+      #
+      # _@param_ `subscriptions_set_id`
+      def initialize: (Symbol config_name, ::Array[PgEventstore::SubscriptionRunner] runners, Integer subscriptions_set_id) -> void
+
+      def process: () -> void
+
+      def queries: () -> PgEventstore::SubscriptionCommandQueries
+
+      def connection: () -> PgEventstore::Connection
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/commands_handler.rbs

@@ -0,0 +1,25 @@
+module PgEventstore
+  class CommandsHandler
+    extend Forwardable
+    RESTART_DELAY: Integer
+    PULL_INTERVAL: Integer
+
+    # _@param_ `config_name`
+    #
+    # _@param_ `subscription_feeder`
+    #
+    # _@param_ `runners`
+    def initialize: (Symbol config_name, PgEventstore::SubscriptionFeeder subscription_feeder, ::Array[PgEventstore::SubscriptionRunner] runners) -> void
+
+    def attach_runner_callbacks: () -> untyped
+
+    def process_async: () -> untyped
+
+    # _@param_ `error`
+    def after_runner_died: (StandardError error) -> void
+
+    def subscription_feeder_commands: () -> PgEventstore::CommandHandlers::SubscriptionFeederCommands
+
+    def subscription_runners_commands: () -> PgEventstore::CommandHandlers::SubscriptionRunnersCommands
+  end
+end

data/sig/pg_eventstore/subscriptions/events_processor.rbs

@@ -0,0 +1,34 @@
+module PgEventstore
+  class EventsProcessor
+    include PgEventstore::Extensions::CallbacksExtension
+    extend Forwardable
+
+    # _@param_ `handler`
+    %a{rbs:test:skip} def initialize: (_SubscriptionHandler handler) -> void
+
+    # _@param_ `raw_events`
+    def feed: (::Array[::Hash[untyped, untyped]] raw_events) -> void
+
+    def events_left_in_chunk: () -> Integer
+
+    def clear_chunk: () -> void
+
+    # _@param_ `raw_event`
+    def process_event: (::Hash[untyped, untyped] raw_event) -> void
+
+    def attach_runner_callbacks: () -> void
+
+    def process_async: () -> void
+
+    def after_runner_died: (StandardError error) -> void
+
+    def before_runner_restored: () -> void
+
+    def change_state: (*untyped args, **untyped kwargs) -> void
+
+    # _@param_ `raw_event`
+    def global_position: (::Hash[untyped, untyped] raw_event) -> Integer
+
+    def define_callback: () -> void
+  end
+end

data/sig/pg_eventstore/subscriptions/extensions/base_command_extension.rbs

@@ -0,0 +1,20 @@
+module PgEventstore
+  module Extensions
+    module BaseCommandExtension
+      def self.included: (untyped klass) -> untyped
+
+      def hash: () -> Integer
+
+      # _@param_ `another`
+      def eql?: (Object another) -> bool
+
+      # _@param_ `another`
+      def ==: (Object another) -> bool
+
+      module ClassMethods
+        # _@param_ `data`
+        def parse_data: (::Hash[untyped, untyped] data) -> ::Hash[untyped, untyped]
+      end
+    end
+  end
+end

data/sig/pg_eventstore/subscriptions/extensions/command_class_lookup_extension.rbs

@@ -0,0 +1,8 @@
+module PgEventstore
+  module Extensions
+    module CommandClassLookupExtension
+      # _@param_ `cmd_name`
+      def command_class: ((String | Symbol) cmd_name) -> Class
+    end
+  end
+end