ruby_event_store 0.31.1 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adebf7df2d0a0bec7857885c1e080e92000adcce6e802b2c7162c0e7b4e0ed8a
-  data.tar.gz: cd37b31c70dcd4646ce59a70a7956f38664792777fca133d08a992deeef43e91
+  metadata.gz: bab926d223e59f80a3c302a45cc70f6cfd4d82e5f768294701ca5474c63c03bd
+  data.tar.gz: 8856dbe54742b11daa510d45b9d6b7dd48d19b82593796786c9a4a859b852655
 SHA512:
-  metadata.gz: 04f7de987acc0e3d52ddd8dc70c158f46967aece05ddf8f109bc5fe395ede108c1e402cbc98b089f6adcbd48219a076f7b678a9106657807a4a8d4eeba2de9b7
-  data.tar.gz: c2c1eb24d23f2f5d98b7b44e06e90f0901fe99b108adf3865de81af41bc161b4253e188c370bcd27cb1cf61bdb732bf6ba7f224f1436375bb885a5c9ec8bea95
+  metadata.gz: 528ba2456e22858c87dea1cea275fd97a63404080c2b7143248ccec3b43c2be45781fe20caf3460afb8d01e900cc5db40c99962686d66a84d40c66cee694288f
+  data.tar.gz: 65100e90a4ed432b7ded41bca6f15d30a4acd60b21bdea373ad191900f8f98bb610605481fd4b3f3d9b1bf19718a527114f8f6582b941d4a7f48286fe8f41ec3

data/Gemfile

@@ -1,3 +1,4 @@
 source 'https://rubygems.org'
 gemspec
-gem 'protobuf_nested_struct'
+
+gem 'protobuf_nested_struct'

data/Makefile

@@ -1,25 +1,25 @@
 GEM_VERSION = $(shell cat ../RES_VERSION)
 GEM_NAME    = ruby_event_store
 REQUIRE     = $(GEM_NAME)
-IGNORE      = RubyEventStore.const_missing \
-              RubyEventStore::InMemoryRepository\#append_with_synchronize \
+IGNORE      = RubyEventStore::InMemoryRepository\#append_with_synchronize \
               RubyEventStore::InMemoryRepository\#normalize_to_array \
               RubyEventStore::Client\#normalize_to_array \
               RubyEventStore::Client::Within\#normalize_to_array \
               RubyEventStore::Client::Within\#add_thread_subscribers \
               RubyEventStore::Client::Within\#add_thread_global_subscribers \
-              RubyEventStore::Client\#read_all_streams_forward \
-              RubyEventStore::Client\#read_all_streams_backward \
-              RubyEventStore::Client\#read_stream_events_forward \
-              RubyEventStore::Client\#read_stream_events_backward \
-              RubyEventStore::Client\#read_events_forward \
-              RubyEventStore::Client\#read_events_backward \
               RubyEventStore::DeprecatedReadAPIRunner* \
               RubyEventStore::DeprecatedReadAPIRewriter* \
               RubyEventStore::Client\#publish_event \
               RubyEventStore::Client\#publish_events \
               RubyEventStore::Client\#link_to_stream \
               RubyEventStore::Client\#append_to_stream \
+              RubyEventStore::AsyncDispatcher* \
+              RubyEventStore::AsyncProxyStrategy::Inline* \
+              RubyEventStore::SpecificationResult\#count \
+              RubyEventStore::SpecificationResult\#direction \
+              RubyEventStore::SpecificationResult\#stream_name \
+              RubyEventStore::SpecificationResult\#global_stream? \
+
 
 SUBJECT     ?= RubyEventStore*
 

data/lib/ruby_event_store.rb

@@ -8,10 +8,11 @@ require 'ruby_event_store/constants'
 require 'ruby_event_store/client'
 require 'ruby_event_store/metadata'
 require 'ruby_event_store/specification'
+require 'ruby_event_store/specification_result'
+require 'ruby_event_store/specification_reader'
 require 'ruby_event_store/event'
 require 'ruby_event_store/stream'
 require 'ruby_event_store/expected_version'
-require 'ruby_event_store/deprecations'
 require 'ruby_event_store/serialized_record'
 require 'ruby_event_store/mappers/default'
 require 'ruby_event_store/mappers/protobuf'
@@ -21,4 +22,8 @@ require 'ruby_event_store/correlated_commands'
 require 'ruby_event_store/link_by_metadata'
 require 'ruby_event_store/async_proxy_strategy'
 require 'ruby_event_store/async_dispatcher'
+require 'ruby_event_store/immediate_async_dispatcher'
+require 'ruby_event_store/composed_dispatcher'
 require 'ruby_event_store/version'
+require 'ruby_event_store/instrumented_repository'
+require 'ruby_event_store/instrumented_dispatcher'

data/lib/ruby_event_store/async_dispatcher.rb

@@ -1,8 +1,14 @@
 module RubyEventStore
+  # @deprecated Use RubyEventStore::ImmediateAsyncDispatcher instead
   class AsyncDispatcher < PubSub::Dispatcher
     def initialize(proxy_strategy: AsyncProxyStrategy::Inline.new, scheduler:)
       @async_proxy_strategy = proxy_strategy
       @scheduler = scheduler
+      warn <<~EOW
+        RubyEventStore::AsyncDispatcher has been deprecated.
+
+        Use RubyEventStore::ImmediateAsyncDispatcher instead
+      EOW
     end
 
     def call(subscriber, _, serialized_event)
@@ -14,7 +20,7 @@ module RubyEventStore
     end
 
     def verify(subscriber)
-      super unless @scheduler.async_handler?(subscriber)
+      @scheduler.async_handler?(subscriber) || super
     end
   end
 end

data/lib/ruby_event_store/async_proxy_strategy.rb

@@ -1,6 +1,15 @@
 module RubyEventStore
   module AsyncProxyStrategy
+    # @deprecated Use RubyEventStore::ImmediateAsyncDispatcher instead
     class Inline
+      def initialize
+        warn <<~EOW
+          RubyEventStore::AsyncProxyStrategy::Inline has been deprecated.
+
+          Use RubyEventStore::ImmediateAsyncDispatcher instead
+        EOW
+      end
+
       def call(schedule_proc)
         schedule_proc.call
       end

data/lib/ruby_event_store/client.rb

@@ -7,12 +7,10 @@ module RubyEventStore
                    mapper: Mappers::Default.new,
                    subscriptions: PubSub::Subscriptions.new,
                    dispatcher: PubSub::Dispatcher.new,
-                   page_size: PAGE_SIZE,
                    clock: ->{ Time.now.utc })
       @repository     = repository
       @mapper         = mapper
       @broker         = PubSub::Broker.new(subscriptions: subscriptions, dispatcher: dispatcher)
-      @page_size      = page_size
       @clock          = clock
       @metadata       = Concurrent::ThreadLocalVar.new
     end
@@ -23,7 +21,7 @@ module RubyEventStore
     # @param events [Array<Event, Proto>, Event, Proto] event(s)
     # @param stream_name [String] name of the stream for persisting events.
     # @param expected_version [:any, :auto, :none, Integer] controls optimistic locking strategy. {http://railseventstore.org/docs/expected_version/ Read more}
-    # @return [:ok]
+    # @return [self]
     def publish(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       enriched_events = enrich_events_metadata(events)
       serialized_events = serialize_events(enriched_events)
@@ -36,7 +34,7 @@ module RubyEventStore
           broker.(event, serialized_event)
         end
       end
-      :ok
+      self
     end
 
     # @deprecated Use {#publish} instead
@@ -72,11 +70,11 @@ module RubyEventStore
     # Persists new event(s) without notifying any subscribed handlers
     #
     # @param (see #publish)
-    # @return [:ok]
+    # @return [self]
     def append(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       serialized_events = serialize_events(enrich_events_metadata(events))
       append_to_stream_serialized_events(serialized_events, stream_name: stream_name, expected_version: expected_version)
-      :ok
+      self
     end
 
     # Links already persisted event(s) to a different stream.
@@ -106,76 +104,10 @@ module RubyEventStore
     # longer linked to the stream.
     #
     # @param stream_name [String] name of the stream to be cleared.
-    # @return [:ok]
+    # @return [self]
     def delete_stream(stream_name)
       repository.delete_stream(Stream.new(stream_name))
-      :ok
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_events_forward(stream_name, start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_events_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).limit(count).from(start).each.to_a
-      EOW
-      read.stream(stream_name).limit(count).from(start).each.to_a
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_events_backward(stream_name, start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_events_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).limit(count).from(start).backward.each.to_a
-      EOW
-      read.stream(stream_name).limit(count).from(start).backward.each.to_a
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_stream_events_forward(stream_name)
-      warn <<~EOW
-        RubyEventStore::Client#read_stream_events_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).each.to_a
-      EOW
-      read.stream(stream_name).each.to_a
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_stream_events_backward(stream_name)
-      warn <<~EOW
-        RubyEventStore::Client#read_stream_events_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.stream(stream_name).backward.each.to_a
-      EOW
-      read.stream(stream_name).backward.each.to_a
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_all_streams_forward(start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_all_streams_forward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.limit(count).from(start).each.to_a
-      EOW
-      read.limit(count).from(start).each.to_a
-    end
-
-    # @deprecated Use {#read} instead. {https://github.com/RailsEventStore/rails_event_store/releases/tag/v0.30.0 More info}
-    def read_all_streams_backward(start: :head, count: page_size)
-      warn <<~EOW
-        RubyEventStore::Client#read_all_streams_backward has been deprecated.
-
-        Use following fluent API to receive exact results:
-        client.read.limit(count).from(start).backward.each.to_a
-      EOW
-      read.limit(count).from(start).backward.each.to_a
+      self
     end
 
     # Returns a single, persisted event based on its ID.
@@ -191,7 +123,14 @@ module RubyEventStore
     #
     # @return [Specification]
     def read
-      Specification.new(repository, mapper)
+      Specification.new(SpecificationReader.new(repository, mapper))
+    end
+
+    # Gets list of streams where event is stored or linked
+    #
+    # @return [Array<Stream>] where event is stored or linked
+    def streams_of(event_id)
+      repository.streams_of(event_id)
     end
 
     # Subscribes a handler (subscriber) that will be invoked for published events of provided type.
@@ -345,6 +284,42 @@ module RubyEventStore
       @metadata.value || EMPTY_HASH
     end
 
+    # Overwrite existing event(s) with the same ID.
+    #
+    # Does not notify any subscribed handlers.
+    # Does not enrich with additional current metadata.
+    # Does not allow changing which streams these events are in.
+    # {http://railseventstore.org/docs/migrating_messages Read more}
+    #
+    # @example Add data and metadata to existing events
+    #
+    #   events = event_store.read.limit(10).each.to_a
+    #   events.each do |ev|
+    #     ev.data[:tenant_id] = 1
+    #     ev.metadata[:server_id] = "eu-west-2"
+    #   end
+    #   event_store.overwrite(events)
+    #
+    # @example Change event type
+    #
+    #   events = event_store.read.limit(10).each.select{|ev| OldType === ev }.map do |ev|
+    #     NewType.new(
+    #       event_id: ev.event_id,
+    #       data: ev.data,
+    #       metadata: ev.metadata,
+    #     )
+    #   end
+    #   event_store.overwrite(events)
+    #
+    # @param events [Array<Event, Proto>, Event, Proto] event(s) to serialize and overwrite again
+    # @return [self]
+    def overwrite(events_or_event)
+      events = normalize_to_array(events_or_event)
+      serialized_events = serialize_events(events)
+      repository.update_messages(serialized_events)
+      self
+    end
+
     EMPTY_HASH = {}.freeze
     private_constant :EMPTY_HASH
 
@@ -385,6 +360,6 @@ module RubyEventStore
       @metadata.value = value
     end
 
-    attr_reader :repository, :mapper, :broker, :clock, :page_size
+    attr_reader :repository, :mapper, :broker, :clock
   end
 end

data/lib/ruby_event_store/composed_dispatcher.rb

@@ -0,0 +1,22 @@
+module RubyEventStore
+  class ComposedDispatcher
+    def initialize(*dispatchers)
+      @dispatchers = dispatchers
+    end
+
+    def call(subscriber, event, serialized_event)
+      @dispatchers.each do |dispatcher|
+        if dispatcher.verify(subscriber)
+          dispatcher.call(subscriber, event, serialized_event)
+          break
+        end
+      end
+    end
+
+    def verify(subscriber)
+      @dispatchers.any? do |dispatcher|
+        dispatcher.verify(subscriber)
+      end
+    end
+  end
+end

data/lib/ruby_event_store/deprecated_read_api_rewriter.rb

@@ -4,11 +4,22 @@ require 'ruby_event_store'
 
 
 module RubyEventStore
-  class DeprecatedReadAPIRewriter < ::Parser::Rewriter
+  class DeprecatedReadAPIRewriter < ::Parser::TreeRewriter
+    DEPRECATED_READER_METHODS = [
+      :read_all_streams_backward,
+      :read_events_backward,
+      :read_stream_events_backward,
+      :read_all_streams_forward,
+      :read_events_forward,
+      :read_stream_events_forward
+    ]
+    private_constant :DEPRECATED_READER_METHODS
+
     def on_send(node)
       node.each_descendant(:send) { |desc_node| on_send(desc_node) }
 
       _, method_name, *args = node.children
+      return unless DEPRECATED_READER_METHODS.include?(method_name)
       replace_range = node.location.selector
       replace_range = replace_range.join(node.location.end) if node.location.end
 
@@ -64,4 +75,4 @@ module RubyEventStore
       node.children[0].to_sym
     end
   end
-end
+end

data/lib/ruby_event_store/errors.rb

@@ -8,6 +8,7 @@ module RubyEventStore
   EventDuplicatedInStream    = Class.new(StandardError)
   NotSupported               = Class.new(StandardError)
   ReservedInternalName       = Class.new(StandardError)
+  InvalidHandler             = Class.new(StandardError)
 
   class EventNotFound < StandardError
     attr_reader :event_id
@@ -16,10 +17,4 @@ module RubyEventStore
       @event_id = event_id
     end
   end
-
-  class InvalidHandler < StandardError
-    def initialize(object)
-      super("#call method not found in #{object.inspect} subscriber. Are you sure it is a valid subscriber?")
-    end
-  end
 end

data/lib/ruby_event_store/immediate_async_dispatcher.rb

@@ -0,0 +1,15 @@
+module RubyEventStore
+  class ImmediateAsyncDispatcher
+    def initialize(scheduler:)
+      @scheduler = scheduler
+    end
+
+    def call(subscriber, _, serialized_event)
+      @scheduler.call(subscriber, serialized_event)
+    end
+
+    def verify(subscriber)
+      @scheduler.verify(subscriber)
+    end
+  end
+end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -36,18 +36,39 @@ module RubyEventStore
     end
 
     def read(spec)
-      events = spec.global_stream? ? global : stream_of(spec.stream_name)
+      events = spec.stream.global? ? global : stream_of(spec.stream.name)
       events = events.reverse if spec.backward?
       events = events.drop(index_of(events, spec.start) + 1) unless spec.head?
-      events = events[0...spec.count] if spec.limit?
+      events = events[0...spec.limit] if spec.limit?
       if spec.batched?
         batch_reader = ->(offset, limit) { events.drop(offset).take(limit) }
         BatchEnumerator.new(spec.batch_size, events.size, batch_reader).each
+      elsif spec.first?
+        events.first
+      elsif spec.last?
+        events.last
       else
         events.each
       end
     end
 
+    def update_messages(messages)
+      messages.each do |new_msg|
+        location = global.index{|m| new_msg.event_id.eql?(m.event_id)} or raise EventNotFound.new(new_msg.event_id)
+        global[location] = new_msg
+        streams.values.each do |str|
+          location = str.index{|m| new_msg.event_id.eql?(m.event_id)}
+          str[location] = new_msg if location
+        end
+      end
+    end
+
+    def streams_of(event_id)
+      streams.select do |_, stream_events|
+        stream_events.any? { |event| event.event_id.equal?(event_id) }
+      end.map { |name, _| Stream.new(name) }
+    end
+
     private
 
     def stream_of(name)

data/lib/ruby_event_store/instrumented_dispatcher.rb

@@ -0,0 +1,21 @@
+module RubyEventStore
+  class InstrumentedDispatcher
+    def initialize(dispatcher, instrumentation)
+      @dispatcher = dispatcher
+      @instrumentation = instrumentation
+    end
+
+    def call(subscriber, event, serialized_event)
+      instrumentation.instrument("call.dispatcher.rails_event_store", event: event, subscriber: subscriber) do
+        dispatcher.call(subscriber, event, serialized_event)
+      end
+    end
+
+    def verify(subscriber)
+      dispatcher.verify(subscriber)
+    end
+
+    private
+    attr_reader :instrumentation, :dispatcher
+  end
+end