pg_eventstore 1.13.4 → 3.0.0

data/lib/pg_eventstore/connection.rb

@@ -8,36 +8,6 @@ require_relative 'pg_connection'
 
 module PgEventstore
   class Connection
-    # Starting from ruby v3.1 ConnectionPool closes connections after forking by default. For ruby v3 we need this patch
-    # to correctly reload the ConnectionPool. Otherwise the same connection will leak into another process which will
-    # result in disaster.
-    # @!visibility private
-    module Ruby30Patch
-      def initialize(**)
-        @current_pid = Process.pid
-        @mutext = Mutex.new
-        super
-      end
-
-      def with(&blk)
-        reload_after_fork
-        super
-      end
-
-      private
-
-      def reload_after_fork
-        return if @current_pid == Process.pid
-
-        @mutext.synchronize do
-          return if @current_pid == Process.pid
-
-          @pool.reload(&:close)
-          @current_pid = Process.pid
-        end
-      end
-    end
-
     # @!attribute uri
     #   @return [String]
     attr_reader :uri
@@ -61,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(&_blk)
+    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
@@ -83,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]
@@ -107,7 +96,3 @@ module PgEventstore
     end
   end
 end
-
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1')
-  PgEventstore::Connection.prepend(PgEventstore::Connection::Ruby30Patch)
-end

data/lib/pg_eventstore/errors.rb

@@ -55,14 +55,19 @@ module PgEventstore
     # @!attribute expected_revision
     #   @return [Integer, Symbol]
     attr_reader :expected_revision
+    # @!attribute verdict
+    #   @return [Symbol]
+    attr_reader :verdict
 
     # @param revision [Integer]
     # @param expected_revision [Integer, Symbol]
     # @param stream [PgEventstore::Stream]
-    def initialize(revision:, expected_revision:, stream:)
+    # @param verdict [Symbol]
+    def initialize(revision:, expected_revision:, stream:, verdict:)
       @revision = revision
       @expected_revision = expected_revision
       @stream = stream
+      @verdict = verdict
       super(user_friendly_message)
     end
 
@@ -70,13 +75,18 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
-        return expected_stream_exists
+      case verdict
+      when :expected_to_have_stream_with_given_revision
+        current_no_stream
+      when :unmatched_stream_revision
+        unmatched_stream_revision
+      when :expected_to_have_stream
+        expected_stream_exists
+      when :expected_not_to_have_stream
+        expected_no_stream
+      else
+        Utils.missing_implementation!(verdict)
       end
-      return expected_no_stream if revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
-      return current_no_stream if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision.is_a?(Integer)
-
-      unmatched_stream_revision
     end
 
     # @return [String]
@@ -108,16 +118,129 @@ module PgEventstore
     end
   end
 
+  class WrongExpectedTypesRevisionError < Error
+    class Verdict
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      # @!attribute verdict
+      #   @return [Symbol]
+      attribute(:verdict)
+      # @!attribute event_type
+      #   @return [String, Symbol]
+      attribute(:event_type)
+      # @!attribute current_revision
+      #   @return [Integer]
+      attribute(:current_revision)
+      # @!attribute expected_revision
+      #   @return [Integer, Symbol]
+      attribute(:expected_revision)
+      # @!attribute expected_markers
+      #   @return [Array<String>, nil]
+      attribute(:expected_markers)
+    end
+
+    # @!attribute stream
+    #   @return [PgEventstore::Stream]
+    attr_reader :stream
+    # @!attribute verdicts
+    #   @return [Array<PgEventstore::WrongExpectedTypesRevisionError::Verdict>]
+    attr_reader :verdicts
+
+    # @param stream [PgEventstore::Stream]
+    # @param verdicts [Array<PgEventstore::WrongExpectedTypesRevisionError::Verdict>]
+    def initialize(stream:, verdicts:)
+      @stream = stream
+      @verdicts = verdicts
+      super(user_friendly_message)
+    end
+
+    private
+
+    # @return [String]
+    def user_friendly_message
+      messages =
+        verdicts.map do |verdict|
+          case verdict.verdict
+          when :event_is_absent
+            event_is_absent(verdict)
+          when :event_revision_does_not_match
+            event_revision_does_not_match(verdict)
+          when :event_is_present
+            event_is_present(verdict)
+          else
+            Utils.missing_implementation!(verdict.verdict)
+          end
+        end
+      messages.join('; ')
+    end
+
+    # @param verdict [PgEventstore::WrongExpectedTypesRevisionError::Verdict]
+    # @return [String]
+    def event_is_absent(verdict)
+      <<~TEXT.strip
+        Expected #{stream_descr} stream to contain #{event_descr(verdict)} with #{revision_descr(verdict)}, \
+        but this event does not exist.
+      TEXT
+    end
+
+    # @param verdict [PgEventstore::WrongExpectedTypesRevisionError::Verdict]
+    # @return [String]
+    def event_is_present(verdict)
+      "Expected #{stream_descr} stream not to contain #{event_descr(verdict)}, but it actually exists."
+    end
+
+    # @param verdict [PgEventstore::WrongExpectedTypesRevisionError::Verdict]
+    # @return [String]
+    def event_revision_does_not_match(verdict)
+      <<~TEXT.strip
+        Expected #{stream_descr} stream to contain #{event_descr(verdict)} with #{revision_descr(verdict)}, \
+        but it actually has #{verdict.current_revision} revision.
+      TEXT
+    end
+
+    # @return [String]
+    def stream_descr
+      stream.to_hash.inspect
+    end
+
+    # @param verdict [PgEventstore::WrongExpectedTypesRevisionError::Verdict]
+    # @return [String]
+    def event_descr(verdict)
+      if verdict.event_type == :any
+        markers = verdict.expected_markers.map(&:inspect).join(', ')
+        "any event with some of #{markers} marker(s)"
+      elsif verdict.expected_markers
+        markers = verdict.expected_markers.map(&:inspect).join(', ')
+        "#{verdict.event_type.inspect} event with some of #{markers} marker(s)"
+      else
+        "#{verdict.event_type.inspect} event"
+      end
+    end
+
+    # @param verdict [PgEventstore::WrongExpectedTypesRevisionError::Verdict]
+    # @return [String]
+    def revision_descr(verdict)
+      if verdict.expected_revision.is_a?(Integer)
+        "#{verdict.expected_revision} revision"
+      elsif verdict.expected_revision == :event_exists
+        'some revision'
+      else
+        "#{verdict.expected_revision.inspect} revision"
+      end
+    end
+  end
+
   class RecordNotFound < Error
     # @!attribute table_name
     #   @return [String]
     attr_reader :table_name
     # @!attribute id
-    #   @return [Integer, String]
+    #   @return [Object]
     attr_reader :id
 
     # @param table_name [String]
-    # @param id [Integer, String]
+    # @param id [Object]
     def initialize(table_name, id)
       @table_name = table_name
       @id = id
@@ -126,7 +249,7 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      "Could not find/update #{table_name.inspect} record with #{id.inspect} id."
+      "Could not find/update/delete #{table_name.inspect} record by #{@id.inspect}."
     end
   end
 
@@ -203,7 +326,7 @@ module PgEventstore
 
     # @return [String]
     def user_friendly_message
-      "Event with #id #{event.id.inspect} must be present, but it could not be found."
+      "Event #{event.inspect} is not persisted a persisted event."
     end
   end
 
@@ -255,4 +378,7 @@ module PgEventstore
       super()
     end
   end
+
+  class NotSupportedError < Error
+  end
 end

data/lib/pg_eventstore/event.rb

@@ -7,11 +7,17 @@ module PgEventstore
     # @return [String] a type of link event
     LINK_TYPE = '$>'
     # @return [String]
+    SYSTEM_SYMBOL = "\u2592"
+    # @return [String]
+    MARKERS_METADATA_KEY = "#{SYSTEM_SYMBOL}m".freeze
+    # @return [String]
     PRIMARY_TABLE_NAME = 'events'
+    # @return [Integer]
+    NON_EXISTING_EVENT_REVISION = -1
 
     # @!attribute id
-    #   @return [String] UUIDv4 string
-    attribute(:id)
+    #   @return [String] UUIDv7
+    attribute(:id) { SecureRandom.uuid_v7 }
     # @!attribute type
     #   @return [String] event type
     attribute(:type) { self.class.name }
@@ -27,13 +33,19 @@ module PgEventstore
     # @!attribute data
     #   @return [Hash] event's data
     attribute(:data) { {} }
+    # @!attribute markers
+    #   @return [Array<String>] event markers
+    attribute(:markers) { [] }
+    # @!attribute feature_markers
+    #   @return [Array<FeatureMarker>] feature-specific markers that can't be put under #markers
+    attribute(:feature_markers) { [] }
     # @!attribute metadata
     #   @return [Hash] event's metadata
     attribute(:metadata) { {} }
-    # @!attribute link_id
-    #   @return [String, nil] UUIDv4 of an event the current event points to. If it is not nil, then the current
-    #     event is a link
-    attribute(:link_id)
+    # @!attribute link_global_position
+    #   @return [Integer, nil] global_position of an event the current event points to. If it is not nil, then the
+    #     current event is a link
+    attribute(:link_global_position)
     # @!attribute link_partition_id
     #   @return [Integer, nil] a partition id of an event the link event points to. It is used to load original event
     #     when resolve_link_tos: true option is provided when reading events.
@@ -45,6 +57,15 @@ module PgEventstore
     # @!attribute created_at
     #   @return [Time, nil] a timestamp an event was created at
     attribute(:created_at)
+    # @!attribute caused_by
+    #   @return [PgEventstore::Event, nil]
+    attribute(:caused_by)
+    # @!attribute correlation_id
+    #   @return [String, nil] UUIDv7
+    attribute(:correlation_id)
+    # @!attribute causation_id
+    #   @return [String, nil] UUIDv7
+    attribute(:causation_id)
 
     # Implements comparison of `PgEventstore::Event`-s. Two events matches if all of their attributes matches
     # @param other [Object, PgEventstore::Event]
@@ -54,11 +75,17 @@ module PgEventstore
 
       attributes_hash.except(:link) == other.attributes_hash.except(:link)
     end
+    alias eql? ==
 
     # Detect whether an event is a link event
     # @return [Boolean]
     def link?
-      !link_id.nil?
+      !link_global_position.nil?
+    end
+
+    # @return [Integer]
+    def hash
+      attributes_hash.except(:link).hash
     end
 
     # Detect whether an event is a system event
@@ -66,5 +93,10 @@ module PgEventstore
     def system?
       type.start_with?('$')
     end
+
+    # @return [self]
+    def dup
+      self.class.new(**Utils.deep_dup(options_hash))
+    end
   end
 end

data/lib/pg_eventstore/event_deserializer.rb

@@ -4,20 +4,20 @@ module PgEventstore
   # @!visibility private
   class EventDeserializer
     # @!attribute middlewares
-    #   @return [Array<#deserialize, #serialize>]
+    #   @return [Array<Middleware>]
     attr_reader :middlewares
     # @!attribute event_class_resolver
     #   @return [#call]
     attr_reader :event_class_resolver
 
-    # @param middlewares [Array<Object<#deserialize, #serialize>>]
+    # @param middlewares [Array<Middleware>]
     # @param event_class_resolver [#call]
     def initialize(middlewares, event_class_resolver)
       @middlewares = middlewares
       @event_class_resolver = event_class_resolver
     end
 
-    # @param raw_events [Array<Hash>]
+    # @param raw_events [Array<Hash>, Enumerator<Hash>]
     # @return [Array<PgEventstore::Event>]
     def deserialize_many(raw_events)
       raw_events.map(&method(:deserialize))
@@ -33,7 +33,8 @@ module PgEventstore
       event.stream = PgEventstore::Stream.new(
         **attrs.slice('context', 'stream_name', 'stream_id').transform_keys(&:to_sym)
       )
-      event.link = without_middlewares.deserialize(attrs['link']) if attrs.key?('link')
+      event.link = deserialize(attrs['link']) if attrs.key?('link')
+      event.markers = event.metadata[Event::MARKERS_METADATA_KEY] || []
       event
     end
 

data/lib/pg_eventstore/event_global_index.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventGlobalIndex
+    include Extensions::OptionsExtension
+    include Extensions::OptionsDefaults
+
+    # @!attribute global_position
+    #   @return [Integer]
+    attribute(:global_position)
+    # @!attribute stream_revision
+    #   @return [Integer]
+    attribute(:stream_revision)
+    # @!attribute context_partition_id
+    #   @return [Integer]
+    attribute(:context_partition_id)
+    # @!attribute stream_name_partition_id
+    #   @return [Integer]
+    attribute(:stream_name_partition_id)
+    # @!attribute event_type_partition_id
+    #   @return [Integer]
+    attribute(:event_type_partition_id)
+    # @!attribute streams_global_index_id
+    #   @return [Integer]
+    attribute(:streams_global_index_id)
+
+    # EventGlobalIndex representation that is used in subscriptions
+    class SubscriptionRepr
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      # @!attribute global_position
+      #   @return [Integer]
+      attribute(:global_position)
+      # @!attribute subscription_position
+      #   @return [Integer]
+      attribute(:subscription_position)
+      # @!attribute event_type_partition_id
+      #   @return [Integer]
+      attribute(:event_type_partition_id)
+
+      # @return [Hash]
+      def to_subscription_position_attrs
+        { global_position:, subscription_position: }
+      end
+    end
+
+    # EventGlobalIndex representation that is used in Read API
+    class ReadApiRepr
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      # @!attribute global_position
+      #   @return [Integer]
+      attribute(:global_position)
+      # @!attribute event_type_partition_id
+      #   @return [Integer]
+      attribute(:event_type_partition_id)
+    end
+
+    # EventGlobalIndex representation that is used in Write API
+    class WriteApiRepr
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      # @!attribute global_position
+      #   @return [Integer]
+      attribute(:global_position)
+      # @!attribute event_type_partition_id
+      #   @return [Integer]
+      attribute(:event_type_partition_id)
+      # @!attribute stream_revision
+      #   @return [Integer]
+      attribute(:stream_revision)
+    end
+
+    # EventGlobalIndex representation for revision validation in #append_to_stream
+    class RevisionCheckRepr
+      include Extensions::OptionsExtension
+      include Extensions::OptionsDefaults
+
+      # @!attribute stream_revision
+      #   @return [Integer]
+      attribute(:stream_revision)
+      # @!attribute sequence_number
+      #   @return [Integer]
+      attribute(:sequence_number)
+    end
+
+    module ReprType
+      SUBSCRIPTION = :subscription
+      READ_API = :read_api
+      WRITE_API = :write_api
+      REVISION_CHECK = :revision_check
+    end
+
+    class << self
+      # @param attributes [Hash<Symbol, Object>]
+      # @param repr [Symbol, nil]
+      # @return [EventGlobalIndex, SubscriptionRepr, ReadApiRepr, WriteApiRepr, RevisionCheckRepr]
+      def create_representation(attributes, repr: nil)
+        case repr
+        when ReprType::SUBSCRIPTION
+          SubscriptionRepr.new(**attributes)
+        when ReprType::READ_API
+          ReadApiRepr.new(**attributes)
+        when ReprType::WRITE_API
+          WriteApiRepr.new(**attributes)
+        when ReprType::REVISION_CHECK
+          RevisionCheckRepr.new(**attributes)
+        else
+          new(**attributes)
+        end
+      end
+    end
+  end
+end

data/lib/pg_eventstore/event_marker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventMarker
+    include Extensions::OptionsExtension
+    include Extensions::OptionsDefaults
+
+    # @!attribute id
+    #   @return [Integer]
+    attribute(:id)
+    # @!attribute name
+    #   @return [String]
+    attribute(:name)
+  end
+end

data/lib/pg_eventstore/event_marker_index.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  # @!visibility private
+  class EventMarkerIndex
+    include Extensions::OptionsExtension
+    include Extensions::OptionsDefaults
+
+    # @!attribute marker_id
+    #   @return [Integer]
+    attribute(:marker_id)
+    # @!attribute streams_global_index_id
+    #   @return [Integer]
+    attribute(:streams_global_index_id)
+    # @!attribute event_type_partition_id
+    #   @return [Integer]
+    attribute(:event_type_partition_id)
+    # @!attribute global_position
+    #   @return [Integer]
+    attribute(:global_position)
+    # @!attribute stream_revision
+    #   @return [Integer]
+    attribute(:stream_revision)
+  end
+end

data/lib/pg_eventstore/event_serializer.rb

@@ -18,6 +18,12 @@ module PgEventstore
       @middlewares.each do |middleware|
         middleware.serialize(event)
       end
+      event.markers.uniq!
+      if event.markers.any?
+        event.metadata[Event::MARKERS_METADATA_KEY] = event.markers
+      else
+        event.metadata.delete(Event::MARKERS_METADATA_KEY)
+      end
       event
     end
 

data/lib/pg_eventstore/extensions/acts_as_configurable.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    module ActsAsConfigurable
+      # @param config_class [Class<PgEventstore:::BasicConfig>]
+      # @param default_config [Symbol]
+      # @return [void]
+      def acts_as_configurable(config_class:, default_config: :default)
+        const_set(:DEFAULT_CONFIG, default_config)
+        const_set(:CONFIG_CLASS, config_class)
+        extend Configurable
+        init_variables
+      end
+
+      module Configurable
+        # @!attribute mutex
+        #   @return [Thread::Mutex]
+        attr_reader :mutex
+        private :mutex
+
+        # Creates a Config if not exists and yields it to the given block.
+        # @param name [Symbol] a name to assign to a config
+        # @return [Object] a result of the given block
+        def configure(name: const_get(:DEFAULT_CONFIG))
+          config_class = const_get(:CONFIG_CLASS)
+          mutex.synchronize do
+            @config[name] = @config[name] ? config_class.new(name:, **@config[name].options_hash) : config_class.new(name:)
+            connection_config_was = connection_options(@config[name])
+
+            yield(@config[name]).tap do
+              @config[name].freeze
+              next if connection_config_was == connection_options(@config[name])
+
+              # Reset the connection if user decided to reconfigure connection's options
+              @connection.delete(name)
+            end
+          end
+        end
+
+        # @return [Array<Symbol>]
+        def available_configs
+          @config.keys
+        end
+
+        # @param name [Symbol]
+        # @return [PgEventstore::Config]
+        def config(name = const_get(:DEFAULT_CONFIG))
+          return @config[name] if @config[name]
+
+          error_message = <<~TEXT
+            Could not find #{name.inspect} config. You can define it like this:
+            #{self}.configure(name: #{name.inspect}) do |config|
+              # your config goes here
+            end
+          TEXT
+          raise error_message
+        end
+
+        # Look ups and returns a Connection, based on the given config. If not exists - it creates one. This operation
+        # is a thread-safe
+        # @param name [Symbol]
+        # @return [PgEventstore::Connection]
+        def connection(name = const_get(:DEFAULT_CONFIG))
+          mutex.synchronize do
+            @connection[name] ||= Connection.new(**connection_options(config(name)))
+          end
+        end
+
+        private
+
+        # @param config [PgEventstore::Extensions::OptionsExtension]
+        # @return [Hash] { uri: String, pool_size: Integer, pool_timeout: Integer }
+        def connection_options(config)
+          raise NotImplementedError
+        end
+
+        # @return [void]
+        def init_variables
+          default_config = const_get(:DEFAULT_CONFIG)
+          @config = { default_config => const_get(:CONFIG_CLASS).new(name: default_config) }
+          @connection = {}
+          @mutex = Thread::Mutex.new
+        end
+      end
+    end
+  end
+end