pg_eventstore 1.13.4 → 3.0.0

data/lib/pg_eventstore/client.rb

@@ -20,20 +20,34 @@ module PgEventstore
     # @param stream [PgEventstore::Stream]
     # @param events_or_event [PgEventstore::Event, Array<PgEventstore::Event>]
     # @param options [Hash]
-    # @option options [Integer] :expected_revision provide your own revision number
+    # @option options [Integer] :expected_revision expected stream revision
     # @option options [Symbol] :expected_revision provide one of next values: :any, :no_stream or :stream_exists
-    # @param middlewares [Array, nil] provide a list of middleware names to override a config's middlewares
+    # @option options [Hash<String, Integer>, Hash<String, Symbol>] :expected_revision
+    #   <even type>-to-<expected stream revision> map. Allows to define expected stream revision at the given event
+    #   type. Useful when implementing Dynamic Consistency Boundaries
+    # @option options [Hash<String, Hash>] :expected_revision <even type>-to-<markers> map. Allows to define expected
+    #   stream revision at the given event type, scoped to the specific marker(s). Useful when implementing
+    #   Dynamic Consistency Boundaries
+    # @param middlewares [Array<Symbol>, nil] provide a list of middleware names to override a config's middlewares
     # @return [PgEventstore::Event, Array<PgEventstore::Event>] persisted event(s)
     # @raise [PgEventstore::WrongExpectedRevisionError]
     def append_to_stream(stream, events_or_event, options: {}, middlewares: nil)
-      result =
-        Commands::Append.new(
-          Queries.new(
-            partitions: partition_queries,
-            events: event_queries(middlewares(middlewares)),
-            transactions: transaction_queries
-          )
-        ).call(stream, *events_or_event, options: options)
+      Utils.assert_node_role!(config, Config::NodeRole.writable)
+      middlewares = self.middlewares(middlewares)
+      event_modifier = Commands::EventModifiers::PrepareRegularEvent.new(EventSerializer.new(middlewares))
+      queries = Queries.new(
+        partitions: partition_queries,
+        events: event_queries,
+        transactions: transaction_queries,
+        events_global_index: events_global_index_queries,
+        streams_global_index: streams_global_index_queries,
+        event_subscription_positions: event_subscription_position_queries,
+        event_markers: event_marker_queries,
+        index_filtering: index_filtering_queries
+      )
+      result = Commands::Append.new(queries).call(
+        stream, *events_or_event, event_modifier:, deserializer: event_deserializer(middlewares), options:
+      )
       events_or_event.is_a?(Array) ? result : result.first
     end
 
@@ -47,9 +61,11 @@ module PgEventstore
     #     PgEventstore.client.append_to_stream(...)
     #   end
     #
+    # @param read_only [Boolean] whether transaction is read-only. Running mutation queries within read-only transaction
+    #   will result in exception
     # @return the result of the given block
-    def multiple(&blk)
-      Commands::Multiple.new(Queries.new(transactions: transaction_queries)).call(&blk)
+    def multiple(read_only: false, &)
+      Commands::Multiple.new(Queries.new(transactions: transaction_queries)).call(read_only:, &)
     end
 
     # Read events from the specific stream or from "all" stream.
@@ -59,16 +75,22 @@ module PgEventstore
     #   :asc, :desc
     # @option options [Integer] :from_revision a starting revision number. **Use this option when stream name is a
     #   normal stream name**
+    # @option options [Integer] :to_revision ending revision number. **Use this option when stream name is a
+    #   normal stream name**
     # @option options [Integer] :from_position a starting global position number. **Use this option when reading
     #   from "all" stream**
+    # @option options [Integer] :to_position ending global position number. **Use this option when reading from
+    #   "all" stream**
     # @option options [Integer] :max_count max number of events to return in one response. Defaults to config.max_count
     # @option options [Boolean] :resolve_link_tos When using projections to create new events you
     #   can set whether the generated events are pointers to existing events. Setting this option to true tells
     #   PgEventstore to return the original event instead a link event.
-    # @option options [Hash] :filter provide it to filter events. You can filter by: stream and by event type. Filtering
-    #   by stream is only available when reading from "all" stream.
-    #   Examples:
-    #     # Filtering by stream's context. This will return all events which #context is 'User
+    # @option options [Hash] :filter provide it to filter events. You can filter by: stream, event type and event
+    #   markers. Filtering by stream is only available when reading from "all" stream.
+    #   Basically, you can mix almost all combinations of stream attributes, event types and markers. That are some
+    #   limitations, though. Please refer to docs/reading_events.md for details.
+    #   Here are some examples:
+    #     # Filtering by stream's context. This will return all events which #context is 'User'
     #     PgEventstore.client.read(
     #       PgEventstore::Stream.all_stream,
     #       options: { filter: { streams: [{ context: 'User' }] } }
@@ -103,42 +125,92 @@ module PgEventstore
     #
     #     # Filtering by specific event when reading from the specific stream
     #     PgEventstore.client.read(stream, options: { filter: { event_types: ['MyAwesomeEvent'] } })
-    # @param middlewares [Array, nil] provide a list of middleware names to override a config's middlewares
+    #
+    #     # Filtering a specific stream by event markers
+    #     PgEventstore.client.read(stream, options: { filter: { event_types: [{ markers: ['foo'] }] } })
+    #
+    #     # Filtering a specific stream by event type with markers and event types
+    #     PgEventstore.client.read(
+    #       stream, options: { filter: { event_types: [{ type: 'Foo', markers: ['foo'] }, 'Bar'] } }
+    #     )
+    #
+    #     # Filtering all events by markers
+    #     PgEventstore.client.read(
+    #       PgEventstore::Stream.all_stream, options: { filter: { event_types: [{ markers: ['foo'] }] } }
+    #     )
+    # @param middlewares [Array<Symbol>, nil] provide a list of middleware names to override a config's middlewares
     # @return [Array<PgEventstore::Event>]
     # @raise [PgEventstore::StreamNotFoundError]
     def read(stream, options: {}, middlewares: nil)
-      Commands::Read.
-        new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
-        call(stream, options: { max_count: config.max_count }.merge(options))
+      queries = Queries.new(
+        index_filtering: index_filtering_queries,
+        streams_global_index: streams_global_index_queries
+      )
+      Commands::Read.new(queries).call(
+        stream,
+        deserializer: event_deserializer(middlewares(middlewares)),
+        options: { max_count: config.max_count }.merge(options)
+      )
     end
 
     # @see {#read} for the detailed docs
     # @param stream [PgEventstore::Stream]
     # @param options [Hash] request options
-    # @param middlewares [Array, nil]
-    # @return [Enumerator] enumerator will yield PgEventstore::Event
+    # @param middlewares [Array<Symbol>, nil]
+    # @return [Enumerator] enumerator will yield Array<PgEventstore::Event>
     def read_paginated(stream, options: {}, middlewares: nil)
       cmd_class = stream.system? ? Commands::SystemStreamReadPaginated : Commands::RegularStreamReadPaginated
-      cmd_class.
-        new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
-        call(stream, options: { max_count: config.max_count }.merge(options))
+      queries = Queries.new(
+        index_filtering: index_filtering_queries,
+        streams_global_index: streams_global_index_queries
+      )
+      cmd_class.new(queries).call(
+        stream,
+        deserializer: event_deserializer(middlewares(middlewares)),
+        options: { max_count: config.max_count }.merge(options)
+      )
     end
 
-    # Takes a stream, determines a list of even types in it and returns most recent(or very first - depending on
-    # :direction option) events, one of each type. If :event_types filter is provided - uses it instead of automatic
-    # event types lookup logic. The result size is almost always less than or equal to event types list size, so passing
-    # :max_count option does not make any effect. In case if event of same type appears in different context/stream
-    # name - it will be counted as a different event, thus, may appear several times in the result.
+    # Takes a stream, event types filter and returns most recent(or very first - depending on :direction option) events,
+    # one of each given type. The result size is almost always less than or equal to event types list size, so passing
+    # :max_count option does not take any effect. In case if event of same type appears in different context/stream
+    # name - it will be counted as a different event, thus, may appear several times in the result, scoped to each
+    # context and stream name in the result. Useful when implementing Dynamic Consistency Boundaries.
     # @see {#read} for the detailed docs
     # @param stream [PgEventstore::Stream]
     # @param options [Hash] request options
-    # @param middlewares [Array, nil]
+    # @param middlewares [Array<Symbol>, nil]
     # @return [Array<PgEventstore::Event>]
     def read_grouped(stream, options: {}, middlewares: nil)
-      cmd_class = stream.all_stream? ? Commands::AllStreamReadGrouped : Commands::RegularStreamReadGrouped
-      cmd_class.
-        new(Queries.new(partitions: partition_queries, events: event_queries(middlewares(middlewares)))).
-        call(stream, options: options)
+      queries = Queries.new(
+        index_filtering: index_filtering_queries,
+        streams_global_index: streams_global_index_queries
+      )
+      Commands::ReadGrouped.new(queries).call(
+        stream, deserializer: event_deserializer(middlewares(middlewares)), options:
+      )
+    end
+
+    # @param options [Hash] request options
+    # @option options [String] :direction read direction. Allowed values are "Forwards", "Backwards", "asc", "desc",
+    #   :asc, :desc
+    # @option options [Integer] :from_position a starting global position number
+    # @option options [Integer] :max_count max number of streams to return in one response. Defaults to config.max_count
+    # @return [Array<PgEventstore::Stream>]
+    def read_streams(options: {})
+      queries = Queries.new(streams_global_index: streams_global_index_queries)
+      Commands::ReadStreams.new(queries).call(options: { max_count: config.max_count }.merge(options))
+    end
+
+    # @param options [Hash] request options
+    # @option options [String] :direction read direction. Allowed values are "Forwards", "Backwards", "asc", "desc",
+    #   :asc, :desc
+    # @option options [Integer] :from_position a starting global position number
+    # @option options [Integer] :max_count max number of streams to yield. Defaults to config.max_count
+    # @return [Enumerator] yields Array<PgEventstore::Stream>
+    def read_streams_paginated(options: {})
+      queries = Queries.new(streams_global_index: streams_global_index_queries)
+      Commands::ReadStreamsPaginated.new(queries).call(options: { max_count: config.max_count }.merge(options))
     end
 
     # Links event from one stream into another stream. You can later access it by providing :resolve_link_tos option
@@ -148,25 +220,42 @@ module PgEventstore
     # @param options [Hash]
     # @option options [Integer] :expected_revision provide your own revision number
     # @option options [Symbol] :expected_revision provide one of next values: :any, :no_stream or :stream_exists
-    # @param middlewares [Array] provide a list of middleware names to use. Defaults to empty array, meaning no
+    # @param middlewares [Array<Symbol>] provide a list of middleware names to use. Defaults to empty array, meaning no
     #   middlewares will be applied to the "link" event
     # @return [PgEventstore::Event, Array<PgEventstore::Event>] persisted event(s)
     # @raise [PgEventstore::WrongExpectedRevisionError]
     def link_to(stream, events_or_event, options: {}, middlewares: [])
-      result =
-        Commands::LinkTo.new(
-          Queries.new(
-            partitions: partition_queries,
-            events: event_queries(middlewares(middlewares)),
-            transactions: transaction_queries
-          )
-        ).call(stream, *events_or_event, options: options)
+      Utils.assert_node_role!(config, Config::NodeRole.writable)
+      middlewares = self.middlewares(middlewares)
+      event_modifier = Commands::EventModifiers::PrepareLinkEvent.new(
+        partition_queries, EventSerializer.new(middlewares)
+      )
+      queries = Queries.new(
+        partitions: partition_queries,
+        events: event_queries,
+        transactions: transaction_queries,
+        events_global_index: events_global_index_queries,
+        streams_global_index: streams_global_index_queries,
+        event_subscription_positions: event_subscription_position_queries,
+        event_markers: event_marker_queries,
+        index_filtering: index_filtering_queries
+      )
+      result = Commands::LinkTo.new(queries).call(
+        stream, *events_or_event, event_modifier:, deserializer: event_deserializer(middlewares), options:
+      )
       events_or_event.is_a?(Array) ? result : result.first
     end
 
+    # @param stream [PgEventstore::Stream]
+    # @return [Integer]
+    def stream_revision(stream)
+      queries = Queries.new(streams_global_index: streams_global_index_queries)
+      Commands::StreamRevision.new(queries).call(stream)
+    end
+
     private
 
-    # @param middlewares [Array, nil]
+    # @param middlewares [Array<Symbol>, nil]
     # @return [Array<PgEventstore::Middleware>]
     def middlewares(middlewares = nil)
       return config.middlewares.values unless middlewares
@@ -189,14 +278,40 @@ module PgEventstore
       TransactionQueries.new(connection)
     end
 
-    # @param middlewares [Array<Object<#serialize, #deserialize>>]
     # @return [PgEventstore::EventQueries]
-    def event_queries(middlewares)
-      EventQueries.new(
-        connection,
-        EventSerializer.new(middlewares),
-        EventDeserializer.new(middlewares, config.event_class_resolver)
-      )
+    def event_queries
+      EventQueries.new(connection)
+    end
+
+    # @param middlewares [Array<Middleware>]
+    # @return [PgEventstore::EventDeserializer]
+    def event_deserializer(middlewares)
+      EventDeserializer.new(middlewares, config.event_class_resolver)
+    end
+
+    # @return [PgEventstore::EventsGlobalIndexQueries]
+    def events_global_index_queries
+      EventsGlobalIndexQueries.new(connection, QueryStrategy::Foreground.new(connection))
+    end
+
+    # @return [PgEventstore::StreamsGlobalIndexQueries]
+    def streams_global_index_queries
+      StreamsGlobalIndexQueries.new(connection, QueryStrategy::Foreground.new(connection))
+    end
+
+    # @return [PgEventstore::EventSubscriptionPositionQueries]
+    def event_subscription_position_queries
+      EventSubscriptionPositionQueries.new(connection)
+    end
+
+    # @return [PgEventstore::EventMarkerQueries]
+    def event_marker_queries
+      EventMarkerQueries.new(connection, QueryStrategy::Foreground.new(connection))
+    end
+
+    # @return [PgEventstore::IndexFilteringQueries]
+    def index_filtering_queries
+      IndexFilteringQueries.new(connection, QueryStrategy::Foreground.new(connection))
     end
   end
 end

data/lib/pg_eventstore/commands/append.rb

@@ -1,71 +1,90 @@
 # frozen_string_literal: true
 
+require_relative 'revision_check/stream_revision_check'
+
 module PgEventstore
   module Commands
     # @!visibility private
     class Append < AbstractCommand
       # @param stream [PgEventstore::Stream]
       # @param events [Array<PgEventstore::Event>]
+      # @param event_modifier [#call]
+      # @param deserializer [PgEventstore::EventDeserializer]
       # @param options [Hash]
       # @option options [Integer] :expected_revision provide your own revision number
       # @option options [Symbol] :expected_revision provide one of next values: :any, :no_stream or :stream_exists
-      # @param event_modifier [#call]
       # @return [Array<PgEventstore::Event>] persisted events
       # @raise [PgEventstore::WrongExpectedRevisionError]
-      def call(stream, *events, options: {}, event_modifier: EventModifiers::PrepareRegularEvent.new)
+      def call(stream, *events, event_modifier:, deserializer:, options: {})
         raise SystemStreamError, stream if stream.system?
+        raise ArgumentError, 'No events to append.' if events.empty?
 
-        queries.transactions.transaction do
-          revision = queries.events.stream_revision(stream) || Stream::NON_EXISTING_STREAM_REVISION
-          assert_expected_revision!(revision, options[:expected_revision], stream) if options[:expected_revision]
-          formatted_events = events.map.with_index(1) do |event, index|
-            event_modifier.call(event, revision + index)
+        events = events.map(&event_modifier.method(:call))
+        markers = events.flat_map { _1.markers + feature_markers(_1) }.uniq
+        raw_events = queries.transactions.transaction(:repeatable_read) do
+          revision_to_marker_ids_map = {}
+          partitions = prepare_partitions(stream, events)
+          markers_map = queries.event_markers.find_or_create_by(markers).to_h { [_1.name, _1.id] } if markers.any?
+          stream_index = queries.streams_global_index.find_or_create_by(stream)
+          revision = stream_index.stream_revision
+          expected_revision = RevisionCheck::ExpectedRevision.build(options[:expected_revision])
+          current_revision = RevisionCheck::CurrentRevision.build(
+            stream, revision, expected_revision, queries.index_filtering
+          )
+          RevisionCheck::StreamRevisionCheck.assert_eq!(current_revision, expected_revision, stream)
+          events.each.with_index(1) do |event, index|
+            event.stream_revision = revision + index
+            event.markers.each do |event_marker|
+              revision_to_marker_ids_map[revision + index] ||= Set.new
+              revision_to_marker_ids_map[revision + index].add(markers_map[event_marker])
+            end
+            event.feature_markers.each do |feature_marker|
+              revision_to_marker_ids_map[revision + index] ||= Set.new
+              revision_to_marker_ids_map[revision + index].add(markers_map[feature_marker.marker])
+            end
+          end
+          revision += events.size
+          queries.events.insert(stream, events).tap do |created_events|
+            stream_idx_attrs_to_update = { stream_revision: revision }
+            if stream_index.starting_position == StreamGlobalIndex::INITIAL_STARTING_POSITION
+              stream_idx_attrs_to_update[:starting_position] = created_events.first['global_position']
+            end
+            queries.streams_global_index.update(stream_index.id, **stream_idx_attrs_to_update)
+            write_api_events_idx = queries.events_global_index.index_events(created_events, partitions, stream_index.id)
+            queries.event_subscription_positions.create_unprocessed_positions(created_events)
+            if markers.any?
+              queries.event_markers.create_indexes(
+                stream_index.id, write_api_events_idx, revision_to_marker_ids_map
+              )
+            end
           end
-          create_partitions(stream, formatted_events)
-          queries.events.insert(stream, formatted_events)
         end
+        # It is important to return events in the form they were persisted into the database instead passing them
+        # through the configured middlewares
+        deserializer.deserialize_many(raw_events)
       end
 
       private
 
-      # @param stream [PgEventstore::Stream]
-      # @param events [Array<PgEventstore::Event>]
-      # @return [void]
-      def create_partitions(stream, events)
-        missing_event_types = events.map(&:type).map(&:to_s).uniq.select do |event_type|
-          queries.partitions.partition_required?(stream, event_type)
-        end
-        raise MissingPartitions.new(stream, missing_event_types) if missing_event_types.any?
+      # @param event [PgEventstore::Event]
+      # @return [Array<String>]
+      def feature_markers(event)
+        event.feature_markers.map(&:marker)
       end
 
-      # @param revision [Integer]
-      # @param expected_revision [Symbol, Integer]
       # @param stream [PgEventstore::Stream]
-      # @raise [PgEventstore::WrongExpectedRevisionError] in case if revision does not satisfy expected revision
-      # @return [void]
-      def assert_expected_revision!(revision, expected_revision, stream)
-        return if expected_revision == :any
-
-        case [revision, expected_revision]
-        in [Integer, Integer]
-          unless revision == expected_revision
-            raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
-            )
-          end
+      # @param events [Array<PgEventstore::Event>]
+      # @return [Array<PgEventstore::Partition>]
+      def prepare_partitions(stream, events)
+        event_types = events.map { _1.type.to_s }.uniq
+        filter_collection = QueryBuilders::Filters::Collection.from_options(
+          { filter: { streams: [{ context: stream.context, stream_name: stream.stream_name }], event_types: } }
+        )
+        existing_partitions = queries.partitions.partitions(filter_collection)
+        missing_event_types = event_types - existing_partitions.map(&:event_type)
+        raise MissingPartitions.new(stream, missing_event_types) if missing_event_types.any?
 
-        in [Integer, Symbol]
-          if revision == Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :stream_exists
-            raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
-            )
-          end
-          if revision > Stream::NON_EXISTING_STREAM_REVISION && expected_revision == :no_stream
-            raise WrongExpectedRevisionError.new(
-              revision: revision, expected_revision: expected_revision, stream: stream
-            )
-          end
-        end
+        existing_partitions
       end
     end
   end

data/lib/pg_eventstore/commands/delete_event.rb

@@ -13,15 +13,14 @@ module PgEventstore
       # @param force [Boolean]
       # @return [Boolean]
       def call(event, force:)
-        queries.transactions.transaction do
-          event = queries.maintenance.reload_event(event)
-          next false unless event
+        raise ArgumentError, "Event#stream is nil: #{event.inspect}" unless event.stream
+        return false if queries.events_global_index.global_positions_from_db([event]).empty?
 
-          check_records_number_to_lock(event) unless force
-          queries.maintenance.delete_event(event)
-          queries.maintenance.adjust_stream_revisions(event.stream, event.stream_revision)
-          true
-        end
+        check_records_number_to_lock(event) unless force
+        queries.maintenance.delete_event(event)
+        true
+      rescue RecordNotFound
+        false
       end
 
       private

data/lib/pg_eventstore/commands/delete_stream.rb

@@ -9,9 +9,9 @@ module PgEventstore
       def call(stream)
         raise SystemStreamError, stream if stream.system?
 
-        queries.transactions.transaction do
-          queries.maintenance.delete_stream(stream) > 0
-        end
+        queries.maintenance.delete_stream(stream) > 0
+      rescue RecordNotFound
+        false
       end
     end
   end

data/lib/pg_eventstore/commands/event_modifiers/prepare_link_event.rb

@@ -9,20 +9,25 @@ module PgEventstore
         attr_reader :partition_queries, :partitions
 
         # @param partition_queries [PgEventstore::PartitionQueries]
-        def initialize(partition_queries)
+        # @param serializer [PgEventstore::EventSerializer]
+        def initialize(partition_queries, serializer)
           @partitions = {}
           @partition_queries = partition_queries
+          @serializer = serializer
         end
 
         # @param event [PgEventstore::Event]
-        # @param revision [Integer]
         # @return [PgEventstore::Event]
-        def call(event, revision)
-          Event.new(
-            link_id: event.id, link_partition_id: partition_id(event), type: Event::LINK_TYPE, stream_revision: revision
+        def call(event)
+          event = Event.new(
+            link_global_position: event.global_position,
+            link_partition_id: partition_id(event),
+            type: Event::LINK_TYPE
           ).tap do |e|
-            %i[link_id link_partition_id type stream_revision].each { |attr| e.readonly!(attr) }
+            %i[link_global_position link_partition_id type].each { |attr| e.readonly!(attr) }
           end
+          @serializer.serialize(event)
+          event
         end
 
         private

data/lib/pg_eventstore/commands/event_modifiers/prepare_regular_event.rb

@@ -6,15 +6,20 @@ module PgEventstore
       # Defines how to transform regular event before appending it to the stream
       # @!visibility private
       class PrepareRegularEvent
+        # @param serializer [PgEventstore::EventSerializer]
+        def initialize(serializer)
+          @serializer = serializer
+        end
+
         # @param event [PgEventstore::Event]
-        # @param revision [Integer]
         # @return [PgEventstore::Event]
-        def call(event, revision)
-          event.class.new(
-            id: event.id, data: event.data, metadata: event.metadata, type: event.type, stream_revision: revision
-          ).tap do |e|
-            %i[link_id link_partition_id stream_revision].each { |attr| e.readonly!(attr) }
-          end
+        def call(event)
+          event = event.dup
+          event.link_global_position = nil
+          event.link_partition_id = nil
+          %i[link_global_position link_partition_id].each { |attr| event.readonly!(attr) }
+          @serializer.serialize(event)
+          event
         end
       end
     end

data/lib/pg_eventstore/commands/link_to.rb

@@ -6,32 +6,32 @@ module PgEventstore
     class LinkTo < AbstractCommand
       # @param stream [PgEventstore::Stream]
       # @param events [Array<PgEventstore::Event>]
+      # @param event_modifier [#call]
+      # @param deserializer [PgEventstore::EventDeserializer]
       # @param options [Hash]
       # @option options [Integer] :expected_revision provide your own revision number
       # @option options [Symbol] :expected_revision provide one of next values: :any, :no_stream or :stream_exists
       # @return [Array<PgEventstore::Event>] persisted events
       # @raise [PgEventstore::WrongExpectedRevisionError]
       # @raise [PgEventstore::NotPersistedEventError]
-      def call(stream, *events, options: {})
+      def call(stream, *events, event_modifier:, deserializer:, options: {})
         check_events_presence(events)
         append_cmd = Append.new(queries)
-        append_cmd.call(
-          stream, *events, options: options, event_modifier: EventModifiers::PrepareLinkEvent.new(queries.partitions)
-        )
+        append_cmd.call(stream, *events, event_modifier:, deserializer:, options:)
       end
 
       private
 
-      # Checks if the given events are persisted events. This is needed to prevent potentially non-existing id valuess
-      # from appearing in #link_id column.
+      # Checks if the given events are persisted events. This is needed to prevent potentially non-existing
+      # global_position values from appearing in #link_global_position column.
       # @param events [Array<PgEventstore::Event>]
       # @return [void]
       def check_events_presence(events)
-        ids_from_db = queries.events.ids_from_db(events)
-        missing_ids = events.map(&:id) - ids_from_db
+        global_positions_from_db = queries.events_global_index.global_positions_from_db(events)
+        missing_ids = events.map(&:global_position) - global_positions_from_db
         return if missing_ids.empty?
 
-        missing_event = events.find { |event| event.id == missing_ids.first }
+        missing_event = events.find { |event| event.global_position == missing_ids.first }
         raise NotPersistedEventError, missing_event
       end
     end

data/lib/pg_eventstore/commands/multiple.rb

@@ -4,8 +4,8 @@ module PgEventstore
   module Commands
     # @!visibility private
     class Multiple < AbstractCommand
-      def call(&blk)
-        queries.transactions.transaction(&blk)
+      def call(read_only:, &)
+        queries.transactions.transaction(read_only:, &)
       end
     end
   end

data/lib/pg_eventstore/commands/read.rb

@@ -5,19 +5,37 @@ module PgEventstore
     # @!visibility private
     class Read < AbstractCommand
       # @param stream [PgEventstore::Stream]
+      # @param deserializer [PgEventstore::EventDeserializer]
       # @param options [Hash] request options
       # @option options [String] :direction read direction - 'Forwards' or 'Backwards'
-      # @option options [Integer, Symbol] :from_revision. **Use this option when stream name is a normal stream name**
-      # @option options [Integer, Symbol] :from_position. **Use this option when reading from "all" stream**
+      # @option options [Integer] :from_revision. **Use this option when stream is a regular stream**
+      # @option options [Integer] :from_position. **Use this option when reading from "all" stream**
+      # @option options [Integer] :to_revision. **Use this option when stream is a regular stream**
+      # @option options [Integer] :to_position. **Use this option when reading from "all" stream**
       # @option options [Integer] :max_count
       # @option options [Boolean] :resolve_link_tos
       # @option options [Hash] :filter provide it to filter events
       # @return [Array<PgEventstore::Event>]
       # @raise [PgEventstore::StreamNotFoundError]
-      def call(stream, options: {})
-        queries.events.stream_revision(stream) || raise(StreamNotFoundError, stream) unless stream.system?
+      def call(stream, deserializer:, options: {})
+        queries.streams_global_index.stream_exists?(stream) || raise(StreamNotFoundError, stream) unless stream.system?
 
-        queries.events.stream_events(stream, options)
+        filter_collection = QueryBuilders::Filters::Collection.from_stream_and_options(stream, options)
+        cursor = QueryBuilders::ReadCursor::StreamCursor.from_stream_and_options(stream, options)
+        raise NotSupportedError, '#read does not support look up by prefix.' if filter_collection.has_prefix_filter?
+
+        if filter_collection.has_incomplete_markers_filter? && filter_collection.has_incomplete_stream_filter?
+          error_message = <<~TEXT.strip
+            #read does not support look up by context/context & stream name and markers filter without specifying \
+            event type explicitly. Please add specific event type to your markers filter. \
+            Example: { filter: { event_types: [{ type: 'Foo', markers: ['foo', 'bar'] }] } }
+          TEXT
+          raise NotSupportedError, error_message
+        end
+
+        indexes = queries.index_filtering.fetch_indexes_for_read_api(filter_collection, cursor)
+        repo = queries.index_filtering.compute_read_api_chunks_repo(indexes, options[:resolve_link_tos] || false)
+        deserializer.deserialize_many(repo.consume_all)
       end
     end
   end