pg_eventstore 2.0.0 → 3.0.0

data/lib/pg_eventstore/commands/read_streams.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    # @!visibility private
+    class ReadStreams < AbstractCommand
+      # @param options [Hash] request options
+      # @option options [String] :direction
+      # @option options [Integer] :from_position
+      # @option options [Integer] :max_count
+      # @return [Array<PgEventstore::Stream>]
+      def call(options: {})
+        indexes = queries.streams_global_index.streams_global_index(options)
+        queries.streams_global_index.resolve_indexes(indexes)
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/read_streams_paginated.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    # @!visibility private
+    class ReadStreamsPaginated < AbstractCommand
+      # @param options [Hash] request options
+      # @option options [String] :direction
+      # @option options [Integer] :from_position
+      # @option options [Integer] :max_count
+      # @return [Enumerator]
+      def call(options: {})
+        Enumerator.new do |yielder|
+          next_position = nil
+          loop do
+            options = options.merge(from_position: next_position) if next_position
+            indexes = queries.streams_global_index.streams_global_index(options)
+            streams = queries.streams_global_index.resolve_indexes(indexes)
+            yielder << streams if streams.any?
+            if end_reached?(streams, options[:max_count] || QueryBuilders::StreamsGlobalIndexFiltering::DEFAULT_LIMIT)
+              raise StopIteration
+            end
+
+            next_position = calc_next_position(indexes, options[:direction])
+            raise StopIteration if next_position <= 0
+          end
+        end
+      end
+
+      private
+
+      # @param streams [Array<PgEventstore::Stream>]
+      # @param max_count [Integer]
+      # @return [Boolean]
+      def end_reached?(streams, max_count)
+        streams.size < max_count
+      end
+
+      # @param indexes [Array<PgEventstore::StreamGlobalIndex>]
+      # @param direction [String, Symbol, nil]
+      # @return [Integer]
+      def calc_next_position(indexes, direction)
+        return indexes.last.starting_position + 1 if forwards?(direction)
+
+        indexes.last.starting_position - 1
+      end
+
+      # @param direction [String, Symbol, nil]
+      # @return [Boolean]
+      def forwards?(direction)
+        QueryBuilders::StreamsGlobalIndexFiltering::SQL_DIRECTIONS[direction] ==
+          QueryBuilders::StreamsGlobalIndexFiltering::SQL_DIRECTIONS[:asc]
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/regular_stream_read_paginated.rb

@@ -5,14 +5,14 @@ module PgEventstore
     # @!visibility private
     class RegularStreamReadPaginated < AbstractCommand
       # @see PgEventstore::Commands::Read for docs
-      def call(stream, options: {})
+      def call(stream, deserializer:, options: {})
         Enumerator.new do |yielder|
           next_revision = nil
           loop do
             options = options.merge(from_revision: next_revision) if next_revision
-            events = read_cmd.call(stream, options:)
+            events = read_cmd.call(stream, deserializer:, options:)
             yielder << events if events.any?
-            if end_reached?(events, options[:max_count] || QueryBuilders::EventsFiltering::DEFAULT_LIMIT)
+            if end_reached?(events, options[:max_count] || QueryBuilders::EventsGlobalIndexFiltering::DEFAULT_LIMIT)
               raise StopIteration
             end
 
@@ -43,7 +43,7 @@ module PgEventstore
       # @param direction [String, Symbol, nil]
       # @return [Boolean]
       def forwards?(direction)
-        QueryBuilders::EventsFiltering::SQL_DIRECTIONS[direction] == QueryBuilders::EventsFiltering::SQL_DIRECTIONS[:asc]
+        QueryBuilders::BasicFiltering::SQL_DIRECTIONS[direction] == QueryBuilders::BasicFiltering::SQL_DIRECTIONS[:asc]
       end
 
       # @return [PgEventstore::Commands::Read]

data/lib/pg_eventstore/commands/revision_check/current_revision.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      # @!visibility private
+      class CurrentRevision
+        class StreamRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute revision
+          #   @return [Integer]
+          attribute(:revision)
+        end
+
+        class EventTypeRevisions
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute revisions
+          #   @return [Array<PgEventstore::EventsGlobalIndex::RevisionCheckRepr>]
+          attribute(:revisions)
+        end
+
+        class << self
+          # @param stream [PgEventstore::Stream]
+          # @param stream_revision [Integer]
+          # @param expected_revision [ExpectedRevision::StreamRevision, ExpectedRevision::EventTypeRevisions, nil]
+          # @param index_filtering_queries [PgEventstore::IndexFilteringQueries]
+          # @return [CurrentRevision::StreamRevision, CurrentRevision::EventTypeRevisions, nil]
+          def build(stream, stream_revision, expected_revision, index_filtering_queries)
+            case expected_revision
+            in ExpectedRevision::StreamRevision
+              StreamRevision.new(revision: stream_revision)
+            in ExpectedRevision::EventTypeRevisions
+              indexes = index_filtering_queries.fetch_indexes_for_revision_validation(
+                stream, expected_revision.revisions
+              )
+              EventTypeRevisions.new(revisions: indexes)
+            in NilClass
+              # do nothing
+            else
+              raise ArgumentError, "Unsupported expected revision #{expected_revision.inspect}."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/revision_check/event_type_revisions_comparison.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      # @!visibility private
+      class EventTypeRevisionsComparison
+        class << self
+          # @param current_revision [Integer]
+          # @param expected_revision [Symbol, Integer]
+          # @param expected_markers [Array<String>, nil]
+          # @param event_type [String, Symbol]
+          # @return [PgEventstore::WrongExpectedTypesRevisionError::Verdict, nil]
+          def verdict(current_revision, expected_revision, expected_markers: nil, event_type: :any)
+            return if expected_revision == :any
+
+            verdict_sym =
+              case [current_revision, expected_revision]
+              in [Event::NON_EXISTING_EVENT_REVISION, Integer]
+                :event_is_absent
+              in [Integer, Integer]
+                :event_revision_does_not_match unless current_revision == expected_revision
+              in [Integer, Symbol]
+                if current_revision == Event::NON_EXISTING_EVENT_REVISION && expected_revision == :event_exists
+                  :event_is_absent
+                elsif current_revision > Event::NON_EXISTING_EVENT_REVISION && expected_revision == :no_event
+                  :event_is_present
+                end
+              else
+                Utils.missing_implementation!([current_revision, expected_revision])
+              end
+            return unless verdict_sym
+
+            WrongExpectedTypesRevisionError::Verdict.new(
+              verdict: verdict_sym,
+              event_type:,
+              current_revision:,
+              expected_revision:,
+              expected_markers:
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/revision_check/expected_revision.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      # @!visibility private
+      class ExpectedRevision
+        class StreamRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute revision
+          #   @return [Symbol, Integer]
+          attribute(:revision)
+        end
+
+        class EventTypeRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute expected_revision
+          #   @return [Symbol, Integer]
+          attribute(:expected_revision)
+          # @!attribute event_type
+          #   @return [String, nil]
+          attribute(:event_type)
+          # @!attribute sequence_number
+          #   @return [Integer]
+          attribute(:sequence_number)
+        end
+
+        class EventTypeRevisionWithMarkers
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute expected_revision
+          #   @return [Symbol, Integer]
+          attribute(:expected_revision)
+          # @!attribute event_type
+          #   @return [String, nil]
+          attribute(:event_type)
+          # @!attribute markers
+          #   @return [Array<String>]
+          attribute(:markers)
+          # @!attribute sequence_number
+          #   @return [Integer]
+          attribute(:sequence_number)
+        end
+
+        class MarkersRevision
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute expected_revision
+          #   @return [Symbol, Integer]
+          attribute(:expected_revision)
+          # @!attribute markers
+          #   @return [Array<String>]
+          attribute(:markers)
+          # @!attribute sequence_number
+          #   @return [Integer]
+          attribute(:sequence_number)
+        end
+
+        class EventTypeRevisions
+          include Extensions::OptionsExtension
+          include Extensions::OptionsDefaults
+
+          # @!attribute revisions
+          #   @return [Array<EventTypeRevision, EventTypeRevisionWithMarkers, MarkersRevision>]
+          attribute(:revisions)
+        end
+
+        class << self
+          # @param expected_revision [Symbol, Integer, Hash]
+          # @return [ExpectedRevision::StreamRevision, ExpectedRevision::EventTypeRevisions, nil]
+          def build(expected_revision)
+            case expected_revision
+            in Integer | Symbol
+              StreamRevision.new(revision: expected_revision)
+            in Hash
+              revisions = expected_revision.map.with_index do |(key, value), index|
+                case [key, value]
+                # { 'Foo' => 1 }, { 'Foo' => :any }, etc
+                in [String, Integer | Symbol]
+                  EventTypeRevision.new(event_type: key, expected_revision: value, sequence_number: index)
+                  # { 'Foo' => { expected_revision: 1, markers: ['foo'] } },
+                  # { 'Foo' => { expected_revision: :any, markers: ['foo'] } }, etc
+                in [String, Hash]
+                  markers = extract_markers(value)
+                  expected_revision = extract_expected_revision(value)
+                  EventTypeRevisionWithMarkers.new(
+                    event_type: key, expected_revision:, markers:, sequence_number: index
+                  )
+                # { any: => { expected_revision: 1, markers: ['foo'] } },
+                # { any: => { expected_revision: :any, markers: ['foo'] } }, etc
+                in [:any, Hash]
+                  markers = extract_markers(value)
+                  expected_revision = extract_expected_revision(value)
+                  MarkersRevision.new(expected_revision:, markers:, sequence_number: index)
+                else
+                  nil
+                end
+              end.compact
+              EventTypeRevisions.new(revisions:)
+            in NilClass
+              # do nothing
+            else
+              raise ArgumentError, "Unsupported :expected_revision #{expected_revision.inspect} option."
+            end
+          end
+
+          private
+
+          # @param hash [Hash]
+          # @return [Symbol, Integer]
+          def extract_expected_revision(hash)
+            hash in { expected_revision: Symbol | Integer => expected_revision }
+            expected_revision ||
+              raise(ArgumentError, "Unsupported expected revision #{hash[:expected_revision].inspect} value.")
+          end
+
+          # @param hash [Hash]
+          # @return [Array<String>]
+          def extract_markers(hash)
+            markers = hash[:markers]&.grep(String)
+            raise ArgumentError, "Unsupported markers: #{hash[:markers].inspect}." if markers.nil? || markers.empty?
+
+            markers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/revision_check/stream_revision_check.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'expected_revision'
+require_relative 'current_revision'
+require_relative 'event_type_revisions_comparison'
+require_relative 'stream_revision_comparison'
+
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      # @!visibility private
+      class StreamRevisionCheck
+        class << self
+          # @param current_revision [CurrentRevision::StreamRevision, CurrentRevision::EventTypeRevisions, nil]
+          # @param expected_revision [ExpectedRevision::StreamRevision, ExpectedRevision::EventTypeRevisions, nil]
+          # @param stream [PgEventstore::Stream]
+          # @return [void]
+          def assert_eq!(current_revision, expected_revision, stream)
+            case [current_revision, expected_revision]
+            in [_, NilClass]
+              # do nothing. We don't have expected revision
+            in [CurrentRevision::StreamRevision, ExpectedRevision::StreamRevision]
+              verdict = StreamRevisionComparison.verdict(current_revision.revision, expected_revision.revision)
+              if verdict
+                raise WrongExpectedRevisionError.new(
+                  revision: current_revision.revision,
+                  expected_revision: expected_revision.revision,
+                  stream:,
+                  verdict:
+                )
+              end
+            in [CurrentRevision::EventTypeRevisions, ExpectedRevision::EventTypeRevisions]
+              verdicts = []
+              rev_check_indexes = current_revision.revisions.to_h { [_1.sequence_number, _1] }
+              expected_revision.revisions.each do |revision|
+                index = find_index(revision, rev_check_indexes)
+                verdict =
+                  case revision
+                  when ExpectedRevision::EventTypeRevision
+                    EventTypeRevisionsComparison.verdict(
+                      index.stream_revision,
+                      revision.expected_revision,
+                      event_type: revision.event_type
+                    )
+                  when ExpectedRevision::EventTypeRevisionWithMarkers
+                    EventTypeRevisionsComparison.verdict(
+                      index.stream_revision,
+                      revision.expected_revision,
+                      expected_markers: revision.markers,
+                      event_type: revision.event_type
+                    )
+                  when ExpectedRevision::MarkersRevision
+                    EventTypeRevisionsComparison.verdict(
+                      index.stream_revision,
+                      revision.expected_revision,
+                      expected_markers: revision.markers
+                    )
+                  else
+                    Utils.missing_implementation!(revision)
+                  end
+                verdicts.push(verdict) if verdict
+              end
+              raise WrongExpectedTypesRevisionError.new(stream:, verdicts:) if verdicts.any?
+            else
+              Utils.missing_implementation!([current_revision, expected_revision])
+            end
+          end
+
+          private
+
+          # @param expected_revision [ExpectedRevision::EventTypeRevision,
+          #   ExpectedRevision::EventTypeRevisionWithMarkers, ExpectedRevision::MarkersRevision]
+          # @param rev_check_indexes [Hash<Integer, PgEventstore::EventGlobalIndex::RevisionCheckRepr>]
+          # @return [PgEventstore::EventGlobalIndex::RevisionCheckRepr]
+          def find_index(expected_revision, rev_check_indexes)
+            from_dictionary = rev_check_indexes[expected_revision.sequence_number]
+            return from_dictionary if from_dictionary
+
+            case expected_revision
+            when ExpectedRevision::EventTypeRevision
+              EventGlobalIndex::RevisionCheckRepr.new(
+                sequence_number: expected_revision.sequence_number, stream_revision: Event::NON_EXISTING_EVENT_REVISION
+              )
+            when ExpectedRevision::EventTypeRevisionWithMarkers, ExpectedRevision::MarkersRevision
+              EventGlobalIndex::RevisionCheckRepr.new(
+                sequence_number: expected_revision.sequence_number,
+                stream_revision: Event::NON_EXISTING_EVENT_REVISION,
+                marker: Event::SYSTEM_SYMBOL
+              )
+            else
+              Utils.missing_implementation!(expected_revision)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/revision_check/stream_revision_comparison.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    module RevisionCheck
+      # @!visibility private
+      class StreamRevisionComparison
+        class << self
+          # @param current_revision [Integer]
+          # @param expected_revision [Integer, Symbol]
+          # @return [Symbol]
+          def verdict(current_revision, expected_revision)
+            return if expected_revision == :any
+
+            case [current_revision, expected_revision]
+            in [Stream::NON_EXISTING_STREAM_REVISION, Integer]
+              :expected_to_have_stream_with_given_revision
+            in [Integer, Integer]
+              :unmatched_stream_revision unless current_revision == expected_revision
+            in [Integer, Symbol]
+              if current_revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
+                return :expected_to_have_stream
+              end
+
+              if current_revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
+                :expected_not_to_have_stream
+              end
+            else
+              raise ArgumentError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/stream_revision.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Commands
+    # @!visibility private
+    class StreamRevision < AbstractCommand
+      # @param stream [PgEventstore::Stream]
+      # @return [Integer]
+      def call(stream)
+        queries.streams_global_index.stream_revision(stream) || Stream::NON_EXISTING_STREAM_REVISION
+      end
+    end
+  end
+end

data/lib/pg_eventstore/commands/system_stream_read_paginated.rb

@@ -5,14 +5,14 @@ module PgEventstore
     # @!visibility private
     class SystemStreamReadPaginated < AbstractCommand
       # @see PgEventstore::Commands::Read for docs
-      def call(stream, options: {})
+      def call(stream, deserializer:, options: {})
         Enumerator.new do |yielder|
           next_position = nil
           loop do
             options = options.merge(from_position: next_position) if next_position
-            events = read_cmd.call(stream, options:)
+            events = read_cmd.call(stream, deserializer:, options:)
             yielder << events if events.any?
-            if end_reached?(events, options[:max_count] || QueryBuilders::EventsFiltering::DEFAULT_LIMIT)
+            if end_reached?(events, options[:max_count] || QueryBuilders::EventsGlobalIndexFiltering::DEFAULT_LIMIT)
               raise StopIteration
             end
 
@@ -43,7 +43,7 @@ module PgEventstore
       # @param direction [String, Symbol, nil]
       # @return [Boolean]
       def forwards?(direction)
-        QueryBuilders::EventsFiltering::SQL_DIRECTIONS[direction] == QueryBuilders::EventsFiltering::SQL_DIRECTIONS[:asc]
+        QueryBuilders::BasicFiltering::SQL_DIRECTIONS[direction] == QueryBuilders::BasicFiltering::SQL_DIRECTIONS[:asc]
       end
 
       # @return [PgEventstore::Commands::Read]

data/lib/pg_eventstore/commands.rb

@@ -5,11 +5,13 @@ require_relative 'commands/event_modifiers/prepare_link_event'
 require_relative 'commands/event_modifiers/prepare_regular_event'
 require_relative 'commands/append'
 require_relative 'commands/read'
-require_relative 'commands/regular_stream_read_grouped'
-require_relative 'commands/all_stream_read_grouped'
+require_relative 'commands/read_grouped'
+require_relative 'commands/read_streams'
+require_relative 'commands/read_streams_paginated'
 require_relative 'commands/regular_stream_read_paginated'
 require_relative 'commands/system_stream_read_paginated'
 require_relative 'commands/multiple'
 require_relative 'commands/link_to'
 require_relative 'commands/delete_stream'
 require_relative 'commands/delete_event'
+require_relative 'commands/stream_revision'

data/lib/pg_eventstore/config.rb

@@ -1,10 +1,27 @@
 # frozen_string_literal: true
 
 module PgEventstore
-  class Config
-    include Extensions::OptionsExtension
+  class Config < BasicConfig
+    module NodeRole
+      # @return [Symbol]
+      STANDALONE = :standalone
+      # @return [Symbol]
+      PRIMARY = :primary
+      # @return [Symbol]
+      REPLICA = :replica
 
-    attr_reader :name
+      class << self
+        # @return [Array<Symbol>]
+        def writable
+          [STANDALONE, PRIMARY]
+        end
+
+        # @return [Array<Symbol>]
+        def maintainable
+          [STANDALONE]
+        end
+      end
+    end
 
     # @!attribute pg_uri
     #   @return [String] PostgreSQL connection URI docs
@@ -55,16 +72,20 @@ module PgEventstore
     # @!attribute subscription_graceful_shutdown_timeout
     #   @return [Integer] the number of seconds to wait until force-shutdown the subscription during the stop process
     option(:subscription_graceful_shutdown_timeout) { 15 }
-
-    # @param name [Symbol] config's name. Its value matches the appropriate key in PgEventstore.config hash
-    def initialize(name:, **options)
-      super
-      @name = name
-    end
+    # @!attribute events_subscription_position_update_interval
+    #   @return [Float, Integer] events subscription position update interval
+    option(:events_subscription_position_update_interval) { 0.2 }
+    # @!attribute eventstore_role
+    #   @return [Symbol] the role of this node
+    option(:eventstore_role) { NodeRole::STANDALONE }
+    # @!attribute max_events_to_replicate
+    #   @return [Integer] max number of events to replicate at a time
+    option(:max_events_to_replicate) { 10_000 }
 
     # Computes a value for usage in PgEventstore::Connection
     # @return [Hash]
     def connection_options
+      puts "DEPRECATED: Config##{__method__} will be removed in next major version with no replacement"
       { uri: pg_uri, pool_size: connection_pool_size, pool_timeout: connection_pool_timeout }
     end
   end

data/lib/pg_eventstore/connection.rb

@@ -31,17 +31,22 @@ module PgEventstore
     end
 
     # A shorthand from ConnectionPool#with.
-    # @yieldparam connection [PG::Connection] PostgreSQL connection instance
+    # @yieldparam connection [PgEventstore::PgConnection] PostgreSQL connection instance
     # @return [Object] a value of a given block
     def with(&)
       should_retry = true
       @pool.with do |conn|
         yield conn
       rescue PG::ConnectionBad, PG::UnableToSend
+        unless should_retry
+          # Connection is broken. We should throw it away
+          @pool.discard_current_connection
+          raise
+        end
+
         # Recover a connection after fork or when we lost a connection to PostgreSQL. We retry only once and without any
         # delay.
         conn.sync_reset
-        raise unless should_retry
 
         should_retry = false
         retry
@@ -53,6 +58,20 @@ module PgEventstore
       @pool.shutdown(&:close)
     end
 
+    # Restore connection after shutdown by re-initializing connection pool
+    # @return [void]
+    def establish_connection
+      @pool = nil
+      init_pool
+    end
+
+    # @return [void]
+    def discard_current_connection
+      @pool.discard_current_connection do |conn|
+        conn.close unless conn.finished?
+      end
+    end
+
     private
 
     # @return [ConnectionPool]