pg_eventstore 2.0.0 → 3.0.0

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
 
@@ -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,6 +33,12 @@ 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) { {} }
@@ -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,6 +75,7 @@ module PgEventstore
 
       attributes_hash.except(:link) == other.attributes_hash.except(:link)
     end
+    alias eql? ==
 
     # Detect whether an event is a link event
     # @return [Boolean]
@@ -61,10 +83,20 @@ module PgEventstore
       !link_global_position.nil?
     end
 
+    # @return [Integer]
+    def hash
+      attributes_hash.except(:link).hash
+    end
+
     # Detect whether an event is a system event
     # @return [Boolean]
     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

data/lib/pg_eventstore/extensions/options_defaults.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  module Extensions
+    # @!visibility private
+    module OptionsDefaults
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        attributes_hash == other.attributes_hash
+      end
+      alias eql? ==
+
+      # @return [Integer]
+      def hash
+        attributes_hash.hash
+      end
+
+      # @return [self]
+      def dup
+        self.class.new(**Utils.deep_dup(options_hash))
+      end
+    end
+  end
+end

data/lib/pg_eventstore/extensions/options_extension.rb

@@ -173,8 +173,8 @@ module PgEventstore
       # value
       # @return [Hash]
       def options_hash
-        self.class.options.each_with_object({}) do |option, res|
-          res[option.name] = public_send(option.name)
+        self.class.options.to_h do |option|
+          [option.name, public_send(option.name)]
         end
       end
       alias attributes_hash options_hash

data/lib/pg_eventstore/feature_marker.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module PgEventstore
+  class FeatureMarker
+    include Extensions::OptionsExtension
+    include Extensions::OptionsDefaults
+
+    # @!attribute marker
+    #   @return [String]
+    attribute(:marker)
+    # @!attribute description
+    #   @return [String, nil] the description of the maker. Can be used as human-friendly explanation of the purpose
+    attribute(:description)
+    # @!attribute purpose
+    #   @return [Symbol, nil] the purpose of the maker. Can be used as an identifier in your implementation
+    attribute(:purpose)
+  end
+end

data/lib/pg_eventstore/maintenance.rb

@@ -15,17 +15,17 @@ module PgEventstore
     # @param stream [PgEventstore::Stream]
     # @return [Boolean] whether a stream was deleted successfully
     def delete_stream(stream)
-      Commands::DeleteStream.new(
-        Queries.new(transactions: transaction_queries, maintenance: maintenance_queries)
-      ).call(stream)
+      Utils.assert_node_role!(config, Config::NodeRole.maintainable)
+      queries = Queries.new(maintenance: maintenance_queries)
+      Commands::DeleteStream.new(queries).call(stream)
     end
 
     # @param event [PgEventstore::Event] persisted event
     # @return [Boolean] whether an event was deleted successfully
     def delete_event(event, force: false)
-      Commands::DeleteEvent.new(
-        Queries.new(transactions: transaction_queries, maintenance: maintenance_queries)
-      ).call(event, force:)
+      Utils.assert_node_role!(config, Config::NodeRole.maintainable)
+      queries = Queries.new(maintenance: maintenance_queries, events_global_index: events_global_index_queries)
+      Commands::DeleteEvent.new(queries).call(event, force:)
     end
 
     private
@@ -44,5 +44,10 @@ module PgEventstore
     def connection
       PgEventstore.connection(config.name)
     end
+
+    # @return [PgEventstore::EventsGlobalIndexQueries]
+    def events_global_index_queries
+      EventsGlobalIndexQueries.new(connection, QueryStrategy::Foreground.new(connection))
+    end
   end
 end