event_store_client 2.3.0 → 3.0.0

data/lib/event_store_client/adapters/grpc/commands/command.rb

@@ -14,8 +14,6 @@ module EventStoreClient
           end
         end
 
-        include Dry::Monads[:try, :result]
-
         attr_reader :connection, :config
         private :connection, :config
 

data/lib/event_store_client/adapters/grpc/commands/gossip/cluster_info.rb

@@ -11,7 +11,7 @@ module EventStoreClient
           # @api private
           # @see {EventStoreClient::GRPC::Client#cluster_info}
           def call
-            Success(retry_request { service.read(request.new, metadata: metadata) })
+            retry_request { service.read(request.new, metadata: metadata) }
           end
         end
       end

data/lib/event_store_client/adapters/grpc/commands/streams/append.rb

@@ -20,7 +20,7 @@ module EventStoreClient
             response = retry_request(skip_retry: config.eventstore_url.throw_on_append_failure) do
               service.append(payload, metadata: metadata)
             end
-            validate_response(response)
+            validate_response(response, caused_by: event)
           end
 
           private
@@ -41,11 +41,17 @@ module EventStoreClient
           end
 
           # @param resp [EventStore::Client::Streams::AppendResp]
-          # @return [Dry::Monads::Success, Dry::Monads::Failure]
-          def validate_response(resp)
-            return Success(resp) if resp.success
+          # @param caused_by [EventStoreClient::DeserializedEvent]
+          # @return [EventStore::Client::Streams::AppendResp]
+          # @raise [EventStoreClient::WrongExpectedVersionError]
+          def validate_response(resp, caused_by:)
+            return resp if resp.success
 
-            Failure(resp.wrong_expected_version)
+            error = WrongExpectedVersionError.new(
+              resp.wrong_expected_version,
+              caused_by: caused_by
+            )
+            raise error
           end
         end
       end

data/lib/event_store_client/adapters/grpc/commands/streams/append_multiple.rb

@@ -10,9 +10,8 @@ module EventStoreClient
           # @api private
           # @see {EventStoreClient::GRPC::Client#append_to_stream}
           def call(stream_name, events, options:, &blk)
-            result = []
-            events.each.with_index do |event, index|
-              response = Commands::Streams::Append.new(
+            events.map.with_index do |event, index|
+              Commands::Streams::Append.new(
                 config: config, **connection_options
               ).call(
                 stream_name, event, options: options
@@ -21,10 +20,7 @@ module EventStoreClient
 
                 yield(req_opts, proposed_msg_opts) if blk
               end
-              result.push(response)
-              break if response.failure?
             end
-            result
           end
 
           private

data/lib/event_store_client/adapters/grpc/commands/streams/delete.rb

@@ -13,11 +13,13 @@ module EventStoreClient
           def call(stream_name, options:, &blk)
             options = normalize_options(stream_name, options)
             yield options if blk
-            Success(
-              retry_request { service.delete(request.new(options: options), metadata: metadata) }
-            )
-          rescue ::GRPC::FailedPrecondition
-            Failure(:stream_not_found)
+            retry_request { service.delete(request.new(options: options), metadata: metadata) }
+          rescue ::GRPC::FailedPrecondition => e
+            # GRPC::FailedPrecondition may happen for several reasons. For example, stream may not
+            # be existing, or :expected_revision option value does not match the current state of
+            # the stream. So, re-raise our own error, and pass there the original message - just in
+            # case.
+            raise StreamDeletionError.new(stream_name, details: e.message)
           end
 
           private

data/lib/event_store_client/adapters/grpc/commands/streams/hard_delete.rb

@@ -13,11 +13,13 @@ module EventStoreClient
           def call(stream_name, options:, &blk)
             options = normalize_options(stream_name, options)
             yield options if blk
-            Success(
-              retry_request { service.delete(request.new(options: options), metadata: metadata) }
-            )
-          rescue ::GRPC::FailedPrecondition
-            Failure(:stream_not_found)
+            retry_request { service.delete(request.new(options: options), metadata: metadata) }
+          rescue ::GRPC::FailedPrecondition => e
+            # GRPC::FailedPrecondition may happen for several reasons. For example, stream may not
+            # be existing, or :expected_revision option value does not match the current state of
+            # the stream. So, re-raise our own error, and pass there the original message - just in
+            # case.
+            raise StreamDeletionError.new(stream_name, details: e.message)
           end
 
           private

data/lib/event_store_client/adapters/grpc/commands/streams/link_to_multiple.rb

@@ -10,18 +10,13 @@ module EventStoreClient
           # @api private
           # @see {EventStoreClient::GRPC::Client#link_to}
           def call(stream_name, events, options:, &blk)
-            result = []
             link_cmd = Commands::Streams::LinkTo.new(config: config, **connection_options)
-            events.each.with_index do |event, index|
-              response =
-                link_cmd.call(stream_name, event, options: options) do |req_opts, proposed_msg_opts|
-                  req_opts.options.revision += index if has_revision_option?(req_opts.options)
-                  yield(req_opts, proposed_msg_opts) if blk
-                end
-              result.push(response)
-              break if response.failure?
+            events.map.with_index do |event, index|
+              link_cmd.call(stream_name, event, options: options) do |req_opts, proposed_msg_opts|
+                req_opts.options.revision += index if has_revision_option?(req_opts.options)
+                yield(req_opts, proposed_msg_opts) if blk
+              end
             end
-            result
           end
 
           private

data/lib/event_store_client/adapters/grpc/commands/streams/read_paginated.rb

@@ -40,22 +40,19 @@ module EventStoreClient
 
                     paginate_options(opts, position)
                   end
-                unless response.success?
-                  yielder << response
-                  raise StopIteration
-                end
                 processed_response =
                   EventStoreClient::GRPC::Shared::Streams::ProcessResponses.
                     new(config: config).
                     call(
-                      response.success,
+                      response,
                       skip_deserialization,
                       skip_decryption
                     )
-                yielder << processed_response if processed_response.success.any?
-                raise StopIteration if end_reached?(response.success, max_count)
 
-                position = calc_next_position(response.success, direction, stream_name)
+                yielder << processed_response if processed_response.any?
+                raise StopIteration if end_reached?(response, max_count)
+
+                position = calc_next_position(response, direction, stream_name)
                 raise StopIteration if position.negative?
               end
             end

data/lib/event_store_client/adapters/grpc/commands/streams/subscribe.rb

@@ -28,11 +28,9 @@ module EventStoreClient
 
               handler.call(result) if result
             end
-            Success(
-              retry_request do
-                service.read(request.new(options: options), metadata: metadata, &callback)
-              end
-            )
+            retry_request do
+              service.read(request.new(options: options), metadata: metadata, &callback)
+            end
           end
 
           private

data/lib/event_store_client/adapters/grpc/shared/streams/process_response.rb

@@ -5,8 +5,6 @@ module EventStoreClient
     module Shared
       module Streams
         class ProcessResponse
-          include Dry::Monads[:result]
-
           attr_reader :config
           private :config
 
@@ -19,15 +17,15 @@ module EventStoreClient
           # @param response [EventStore::Client::Streams::ReadResp]
           # @param skip_deserialization [Boolean]
           # @param skip_decryption [Boolean]
-          # @return [Dry::Monads::Success, Dry::Monads::Failure, nil]
+          # @return [EventStoreClient::DeserializedEvent, EventStore::Client::Streams::ReadResp, nil]
+          # @raise [EventStoreClient::StreamNotFoundError]
           def call(response, skip_deserialization, skip_decryption)
-            return Failure(:stream_not_found) if response.stream_not_found
-            return Success(response) if skip_deserialization
+            non_existing_stream = response.stream_not_found&.stream_identifier&.stream_name
+            raise StreamNotFoundError, non_existing_stream if non_existing_stream
+            return response if skip_deserialization
             return unless response.event&.event
 
-            Success(
-              config.mapper.deserialize(response.event.event, skip_decryption: skip_decryption)
-            )
+            config.mapper.deserialize(response.event.event, skip_decryption: skip_decryption)
           end
         end
       end

data/lib/event_store_client/adapters/grpc/shared/streams/process_responses.rb

@@ -5,8 +5,6 @@ module EventStoreClient
     module Shared
       module Streams
         class ProcessResponses
-          include Dry::Monads[:result]
-
           attr_reader :config
           private :config
 
@@ -19,20 +17,20 @@ module EventStoreClient
           # @param responses [Array<EventStore::Client::Streams::ReadResp>]
           # @param skip_deserialization [Boolean]
           # @param skip_decryption [Boolean]
-          # @return [Dry::Monads::Success, Dry::Monads::Failure]
+          # @return [Array<EventStoreClient::DeserializedEvent>, Array<EventStore::Client::Streams::ReadResp>]
+          # @raise [EventStoreClient::StreamNotFoundError]
           def call(responses, skip_deserialization, skip_decryption)
-            return Failure(:stream_not_found) if responses.first&.stream_not_found
-            return Success(responses) if skip_deserialization
+            non_existing_stream = responses.first&.stream_not_found&.stream_identifier&.stream_name
+            raise StreamNotFoundError, non_existing_stream if non_existing_stream
+            return responses if skip_deserialization
 
-            events =
-              responses.map do |response|
-                # It could be <EventStore::Client::Streams::ReadResp: last_stream_position: 39> for
-                # example. Such responses should be skipped. See generated files for more info.
-                next unless response.event&.event
+            responses.map do |response|
+              # It could be <EventStore::Client::Streams::ReadResp: last_stream_position: 39> for
+              # example. Such responses should be skipped. See generated files for more info.
+              next unless response.event&.event
 
-                config.mapper.deserialize(response.event.event, skip_decryption: skip_decryption)
-              end
-            Success(events.compact)
+              config.mapper.deserialize(response.event.event, skip_decryption: skip_decryption)
+            end.compact
           end
         end
       end

data/lib/event_store_client/adapters/grpc.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'grpc'
-require 'dry-monads'
 
 # Load all generated by google-protobuf files
 Dir[File.expand_path('grpc/generated/*.rb', __dir__)].each { |f| require f }

data/lib/event_store_client/deserialized_event.rb

@@ -7,8 +7,8 @@ module EventStoreClient
     InvalidDataError = Class.new(StandardError)
     private_constant :InvalidDataError
 
-    attr_reader :id, :type, :title, :data, :metadata, :stream_name, :stream_revision,
-                :prepare_position, :commit_position
+    attr_reader :id, :type, :title, :data, :metadata, :custom_metadata, :stream_name,
+                :stream_revision, :prepare_position, :commit_position
 
     # @args [Hash] opts
     # @option opts [Boolean] :skip_validation
@@ -34,6 +34,7 @@ module EventStoreClient
           'type' => @type,
           'content-type' => payload_content_type
         )
+      @custom_metadata = args[:custom_metadata] || {}
       @stream_name = args[:stream_name]
       @stream_revision = args[:stream_revision]
       @prepare_position = args[:prepare_position]
@@ -57,7 +58,7 @@ module EventStoreClient
     def ==(other)
       return false unless other.is_a?(EventStoreClient::DeserializedEvent)
 
-      to_h == other.to_h
+      meaningful_attrs(to_h) == meaningful_attrs(other.to_h)
     end
 
     # @return [Hash]
@@ -75,8 +76,25 @@ module EventStoreClient
       type == LINK_TYPE
     end
 
+    # Detect whether an event is a system event
+    # @return [Boolean]
+    def system?
+      return false unless type
+
+      type.start_with?('$')
+    end
+
     private
 
+    # When comparing two events - we drop commit_position and prepare_position from attributes list
+    # to compare. This is because their value are different when retrieving the same event from
+    # '$all' stream and from specific stream.
+    # @param hash [Hash]
+    # @return [Hash]
+    def meaningful_attrs(hash)
+      hash.delete_if { |key, _val| %i(commit_position prepare_position).include?(key) }
+    end
+
     def validate(data)
       return unless schema
 

data/lib/event_store_client/errors.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  class Error < StandardError
+    # @return [Hash]
+    def as_json(*)
+      to_h.transform_keys(&:to_s)
+    end
+
+    # @return [Hash]
+    def to_h
+      hash =
+        instance_variables.each_with_object({}) do |var, result|
+          key = var.to_s
+          key[0] = '' # remove @ sign
+          result[key.to_sym] = instance_variable_get(var)
+        end
+      hash[:message] = message
+      hash[:backtrace] = backtrace
+      hash
+    end
+  end
+
+  class StreamNotFoundError < Error
+    attr_reader :stream_name
+
+    # @param stream_name [String]
+    def initialize(stream_name)
+      @stream_name = stream_name
+      super("Stream #{stream_name.inspect} does not exist.")
+    end
+  end
+
+  class WrongExpectedVersionError < Error
+    attr_reader :wrong_expected_version, :caused_by
+
+    # @param wrong_expected_version [EventStore::Client::Streams::AppendResp::WrongExpectedVersion]
+    # @param caused_by [EventStoreClient::DeserializedEvent] an event on which
+    #   WrongExpectedVersionError error happened. It can be useful when appending array of events -
+    #   based on it you will know which events were appended and which weren't.
+    def initialize(wrong_expected_version, caused_by:)
+      @wrong_expected_version = wrong_expected_version
+      @caused_by = caused_by
+      super(user_friendly_message)
+    end
+
+    private
+
+    # @return [String]
+    def user_friendly_message
+      if wrong_expected_version.expected_stream_exists
+        return "Expected stream to exist, but it doesn't."
+      end
+      if wrong_expected_version.expected_no_stream
+        return "Expected stream to be absent, but it actually exists."
+      end
+      if wrong_expected_version.current_no_stream
+        return <<~TEXT.strip
+          Stream revision #{wrong_expected_version.expected_revision.inspect} is expected, but \
+          stream does not exist.
+        TEXT
+      end
+      unless wrong_expected_version.expected_revision == wrong_expected_version.current_revision
+        return <<~TEXT.strip
+          Stream revision #{wrong_expected_version.expected_revision.inspect} is expected, but \
+          actual stream revision is #{wrong_expected_version.current_revision.inspect}.
+        TEXT
+      end
+      # Unhandled case. Could happen if something else would be added to proto and I don't add it
+      # here.
+      self.class.to_s
+    end
+  end
+
+  class StreamDeletionError < Error
+    attr_reader :stream_name, :details
+
+    # @param stream_name [String]
+    # @param details [String]
+    def initialize(stream_name, details:)
+      @stream_name = stream_name
+      @details = details
+      super(user_friendly_message)
+    end
+
+    # @return [String]
+    def user_friendly_message
+      <<~TEXT.strip
+        Could not delete #{stream_name.inspect} stream. It seems that a stream with that \
+        name does not exist, has already been deleted or its state does not match the \
+        provided :expected_revision option. Please check #details for more info.
+      TEXT
+    end
+  end
+end

data/lib/event_store_client/mapper/default.rb

@@ -18,7 +18,7 @@ module EventStoreClient
       # @param event [EventStoreClient::DeserializedEvent]
       # @return [EventStoreClient::SerializedEvent]
       def serialize(event)
-        Serializer::EventSerializer.call(event, serializer: serializer)
+        Serializer::EventSerializer.call(event, serializer: serializer, config: config)
       end
 
       # @param event_or_raw_event [EventStoreClient::DeserializedEvent, EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent, EventStore::Client::PersistentSubscriptions::ReadResp::ReadEvent::RecordedEvent]

data/lib/event_store_client/mapper/encrypted.rb

@@ -32,7 +32,7 @@ module EventStoreClient
         # Links don't need to be encrypted
         return Default.new(serializer: serializer, config: config).serialize(event) if event.link?
 
-        serialized = Serializer::EventSerializer.call(event, serializer: serializer)
+        serialized = Serializer::EventSerializer.call(event, serializer: serializer, config: config)
         encryption_schema =
           if event.class.respond_to?(:encryption_schema)
             event.class.encryption_schema
@@ -70,7 +70,7 @@ module EventStoreClient
         decrypted_data =
           EventStoreClient::DataDecryptor.new(
             data: event.data,
-            schema: event.metadata['encryption'],
+            schema: event.custom_metadata['encryption'],
             repository: key_repository
           ).call
         event.class.new(**event.to_h.merge(data: decrypted_data, skip_validation: true))

data/lib/event_store_client/serializer/event_deserializer.rb

@@ -7,8 +7,8 @@ module EventStoreClient
     class EventDeserializer
       class << self
         # @param raw_event [EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent, EventStore::Client::PersistentSubscriptions::ReadResp::ReadEvent::RecordedEvent]
-        # @param serializer [#serialize, #deserialize]
         # @param config [EventStoreClient::Config]
+        # @param serializer [#serialize, #deserialize]
         # @return [EventStoreClient::DeserializedEvent]
         def call(raw_event, config:, serializer: Serializer::Json)
           new(config: config, serializer: serializer).call(raw_event)
@@ -19,6 +19,7 @@ module EventStoreClient
       private :serializer, :config
 
       # @param serializer [#serialize, #deserialize]
+      # @param config [EventStoreClient::Config]
       def initialize(serializer:, config:)
         @serializer = serializer
         @config = config
@@ -29,7 +30,7 @@ module EventStoreClient
       def call(raw_event)
         data = serializer.deserialize(normalize_serialized(raw_event.data))
         custom_metadata = serializer.deserialize(normalize_serialized(raw_event.custom_metadata))
-        metadata = custom_metadata.merge(raw_event.metadata.to_h)
+        metadata = raw_event.metadata.to_h
 
         event_class(metadata['type']).new(
           skip_validation: true,
@@ -38,6 +39,7 @@ module EventStoreClient
           type: metadata['type'],
           data: data,
           metadata: metadata,
+          custom_metadata: custom_metadata,
           stream_revision: raw_event.stream_revision,
           commit_position: raw_event.commit_position,
           prepare_position: raw_event.prepare_position,

data/lib/event_store_client/serializer/event_serializer.rb

@@ -3,35 +3,39 @@
 module EventStoreClient
   module Serializer
     class EventSerializer
-      ALLOWED_EVENT_METADATA = %w[type content-type created_at].freeze
+      # So far there are only these keys can be persisted in the metadata. You can pass **whatever**
+      # you want into a metadata hash, but all keys, except these - will be rejected. Define
+      # whitelisted keys and cut unwanted keys explicitly(later in this class).
+      ALLOWED_EVENT_METADATA = %w[type content-type].freeze
 
       class << self
         # @param event [EventStoreClient::DeserializedEvent]
+        # @param config [EventStoreClient::Config]
         # @param serializer [#serialize, #deserialize]
         # @return [EventStoreClient::SerializedEvent]
-        def call(event, serializer: Serializer::Json)
-          new(serializer: serializer).call(event)
+        def call(event, config:, serializer: Serializer::Json)
+          new(serializer: serializer, config: config).call(event)
         end
       end
 
-      attr_reader :serializer
-      private :serializer
+      attr_reader :serializer, :config
+      private :serializer, :config
 
       # @param serializer [#serialize, #deserialize]
-      def initialize(serializer:)
+      # @param config [EventStoreClient::Config]
+      def initialize(serializer:, config:)
         @serializer = serializer
+        @config = config
       end
 
       # @param event [EventStoreClient::DeserializedEvent]
       # @return [EventStoreClient::SerializedEvent]
       def call(event)
-        event_metadata = metadata(event)
-        event_custom_metadata = custom_metadata(event, event_metadata)
         SerializedEvent.new(
           id: event.id || SecureRandom.uuid,
           data: data(event),
-          custom_metadata: event_custom_metadata,
-          metadata: event_metadata.slice(*ALLOWED_EVENT_METADATA),
+          metadata: metadata(event),
+          custom_metadata: custom_metadata(event),
           serializer: serializer
         )
       end
@@ -42,17 +46,24 @@ module EventStoreClient
       # @return [Hash]
       def metadata(event)
         metadata = serializer.deserialize(serializer.serialize(event.metadata))
-        metadata['created_at'] ||= Time.now.utc.to_s
-        metadata
+        # 'created' is returned in the metadata hash of the event when reading from a stream. It,
+        # however, can not be overridden - it is always defined automatically by EventStore db when
+        # appending new event. Thus, just ignore it - no need even to mention it in the
+        # #log_metadata_difference method's message.
+        metadata = metadata.slice(*(metadata.keys - ['created']))
+        filtered_metadata = metadata.slice(*ALLOWED_EVENT_METADATA)
+        log_metadata_difference(metadata) unless filtered_metadata == metadata
+        filtered_metadata
       end
 
+      # Compute custom metadata for the event. **Exactly these** values you can see in ES admin's
+      # web UI under "Metadata" section of the event.
       # @param event [EventStoreClient::DeserializedEvent]
-      # @param metadata [Hash]
       # @return [Hash]
-      def custom_metadata(event, metadata)
-        metadata.
-          slice('created_at', 'encryption', 'content-type', 'transaction').
-          merge('type' => event.type.to_s)
+      def custom_metadata(event)
+        custom_metadata = serializer.deserialize(serializer.serialize(event.custom_metadata))
+        custom_metadata['created_at'] ||= Time.now.utc.to_s
+        custom_metadata
       end
 
       # @param event [EventStoreClient::DeserializedEvent]
@@ -64,6 +75,19 @@ module EventStoreClient
 
         serializer.deserialize(serializer.serialize(event.data))
       end
+
+      # @param metadata [Hash]
+      # @return [void]
+      def log_metadata_difference(metadata)
+        rest_hash = metadata.slice(*(metadata.keys - ALLOWED_EVENT_METADATA))
+        debug_message = <<~TEXT
+          Next keys were filtered from metadata during serialization: \
+          #{(metadata.keys - ALLOWED_EVENT_METADATA).map(&:inspect).join(', ')}. If you would like \
+          to provide your custom values in the metadata - please provide them via custom_metadata. \
+          Example: EventStoreClient::DeserializedEvent.new(custom_metadata: #{rest_hash.inspect})
+        TEXT
+        config.logger&.debug(debug_message)
+      end
     end
   end
 end

data/lib/event_store_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EventStoreClient
-  VERSION = '2.3.0'
+  VERSION = '3.0.0'
 end

data/lib/event_store_client.rb

@@ -2,7 +2,9 @@
 
 require 'json'
 require 'set'
+require 'securerandom'
 
+require 'event_store_client/errors'
 require 'event_store_client/serializer/json'
 require 'event_store_client/serializer/event_serializer'
 require 'event_store_client/serializer/event_deserializer'
@@ -29,7 +31,7 @@ module EventStoreClient
     end
 
     # @param name [Symbol, String]
-    # @return [EventStore::Config]
+    # @return [EventStoreClient::Config]
     def config(name = :default)
       @config[name] ||= Config.new(name: name)
     end