event_store_client 1.2.3 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f72e92a631da57d27b68c2ba2644a1a089f3cd60ef910151801afd5d74bb3f1
-  data.tar.gz: c92a76c6955aec9296bd4cbf57d29584672dea95887c2d9e531238dd8adfe347
+  metadata.gz: 1f3c838968ea465d5b8c8facea48379e2cd8deab75622df62e124e68e52a123e
+  data.tar.gz: 7ab8a39443e9eaa15a4dccb95c32309fbfc1081de9bc854faef9b433a58f54a5
 SHA512:
-  metadata.gz: 25e44c8b41e5c22e2b469e096db5789e6c2aad0b18bfb82283a0959ddf73860058a700095aaf614fb931722f6e7184b91c050516cc208b7bf72b11d4cb277023
-  data.tar.gz: 00e87f69e1da44a28995c187397d42f19cbec0701120b6961a64f3e489c4a6c6598fcfc0701f5a2954a46019ea81b3efd0d7f17d07fb44af7ac514892adec2b9
+  metadata.gz: 80ccafc122496126f946ff52437a0fe1fbe856628e508f97c96cf8f802350b94399c557ce276042a4dd4ef0ee5f669952f131bddaeac08f9da73707382bb15bc
+  data.tar.gz: cd3c8af6fb3dfe71cc710ed2bfdc5cce89a954afc9bedbe2381438564a9584e777741bb43bd9c69e2fb3d2822cf1449048e1baba80617f695e93cdcaad10ebe3

data/lib/event_store_client/adapters/grpc/client.rb

@@ -11,7 +11,7 @@ module EventStoreClient
       #
       def append_to_stream(stream_name, events, options: {})
         Commands::Streams::Append.new.call(
-          stream_name, events, options: {}
+          stream_name, events, options: options
         )
       end
 

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require 'grpc'
-require 'event_store_client/adapters/grpc/generated/streams_pb.rb'
-require 'event_store_client/adapters/grpc/generated/streams_services_pb.rb'
+require 'event_store_client/adapters/grpc/generated/streams_pb'
+require 'event_store_client/adapters/grpc/generated/streams_services_pb'
 
 require 'event_store_client/adapters/grpc/commands/command'
 
@@ -14,45 +14,94 @@ module EventStoreClient
           use_request EventStore::Client::Streams::AppendReq
           use_service EventStore::Client::Streams::Streams::Stub
 
+          ALLOWED_EVENT_METADATA = %w[type content-type created_at].freeze
+
           # @api private
-          # TODO: Add support to verify the expected version
-          def call(stream, events, options: {}) # rubocop:disable Lint/UnusedMethodArgument,Metrics/LineLength
+          def call(stream, events, options: {})
+            return unless events.any?
+
             serialized_events = events.map { |event| config.mapper.serialize(event) }
 
-            serialized_events.each do |event|
-              event_metadata = JSON.parse(event.metadata)
-              custom_metadata = {
-                "type": event.type,
-                "created_at": Time.now,
-                'content-type': event_metadata['content-type']
-              }
-              custom_metadata['encryption'] = event_metadata['encryption'] unless event_metadata['encryption'].nil?
-              custom_metadata['transaction'] = event_metadata['transaction'] unless event_metadata['transaction'].nil?
-              event_metadata = event_metadata.select { |k| ['type', 'content-type', 'created_at'].include?(k) }
-
-              payload = [
-                request.new(
-                  options: {
-                    stream_identifier: {
-                      streamName: stream
-                    },
-                    any: {}
-                  }
-                ),
-                request.new(
-                  proposed_message: {
-                    id: {
-                      string: SecureRandom.uuid
-                    },
-                    data: event.data.b,
-                    custom_metadata: JSON.generate(custom_metadata),
-                    metadata: event_metadata
-                  }
-                )
-              ]
-              service.append(payload, metadata: metadata)
+            expected_version = options[:expected_version]
+
+            res = nil
+            serialized_events.each_with_index do |event, i|
+              expected_version += i if expected_version
+              res = append(stream, event, expected_version)
+              break if res.failure?
             end
-            Success(events)
+
+            res.success? ? Success(events) : Failure(res.failure)
+          end
+
+          private
+
+          def append(stream, event, expected_version)
+            event_metadata = JSON.parse(event.metadata)
+
+            payload = append_request_payload(
+              options(stream, expected_version),
+              message(
+                data: event.data.b,
+                event_metadata: event_metadata.select { |k| ALLOWED_EVENT_METADATA.include?(k) },
+                custom_metadata: custom_metadata(event.type, event_metadata)
+              )
+            )
+
+            resp = service.append(payload, metadata: metadata)
+
+            validate_response(resp)
+          end
+
+          def custom_metadata(event_type, event_metadata)
+            {
+              type: event_type,
+              created_at: Time.current,
+              encryption: event_metadata['encryption'],
+              'content-type': event_metadata['content-type'],
+              transaction: event_metadata['transaction']
+            }.compact
+          end
+
+          def append_request_payload(options, message)
+            [
+              request.new(
+                options: options
+              ),
+              request.new(
+                proposed_message: message
+              )
+            ]
+          end
+
+          def options(stream, expected_version)
+            {
+              stream_identifier: {
+                streamName: stream
+              },
+              revision: expected_version,
+              any: (expected_version ? nil : {})
+            }.compact
+          end
+
+          def message(data:, event_metadata:, custom_metadata:)
+            {
+              id: {
+                string: SecureRandom.uuid
+              },
+              data: data,
+              custom_metadata: JSON.generate(custom_metadata),
+              metadata: event_metadata
+            }
+          end
+
+          def validate_response(resp)
+            return Success() if resp.success
+
+            Failure(
+              "current version: #{resp.wrong_expected_version.current_revision} | "\
+              "expected: #{resp.wrong_expected_version.expected_revision}"
+            )
           end
         end
       end

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

@@ -44,7 +44,12 @@ module EventStoreClient
             end
 
             skip_decryption = options[:skip_decryption] || false
-            events = read_stream(opts, skip_decryption)
+            events =
+              if options[:skip_deserialization]
+                read_stream_raw(opts)
+              else
+                read_stream(opts, skip_decryption)
+              end
             Success(events)
           rescue StreamNotFound
             Failure(:not_found)
@@ -64,6 +69,18 @@ module EventStoreClient
             raise GRPCUnavailableRetryFailed
           end
 
+          def read_stream_raw(options)
+            retries ||= 0
+            service.read(request.new(options: options), metadata: metadata).map do |res|
+              raise StreamNotFound if res.stream_not_found
+              res.event.event
+            end
+          rescue ::GRPC::Unavailable
+            sleep config.grpc_unavailable_retry_sleep
+            retry if (retries += 1) <= config.grpc_unavailable_retry_count
+            raise GRPCUnavailableRetryFailed
+          end
+
           def deserialize_event(entry, skip_decryption: false)
             data = (entry.data.nil? || entry.data.empty?) ? '{}' : entry.data
 

data/lib/event_store_client/configuration.rb

@@ -8,35 +8,35 @@ module EventStoreClient
 
   # Supported adapters: %i[api in_memory grpc]
   #
-  setting :adapter, :grpc
-  setting :verify_ssl, true
+  setting :adapter, default: :grpc
+  setting :verify_ssl, default: true
 
-  setting :error_handler, ErrorHandler.new
-  setting :eventstore_url, 'http://localhost:2113' do |value|
+  setting :error_handler, default: ErrorHandler.new
+  setting :eventstore_url, default: 'http://localhost:2113' do |value|
     value.is_a?(URI) ? value : URI(value)
   end
 
-  setting :eventstore_user, 'admin'
-  setting :eventstore_password, 'changeit'
+  setting :eventstore_user, default: 'admin'
+  setting :eventstore_password, default: 'changeit'
 
-  setting :db_port, 2113
+  setting :db_port, default: 2113
 
-  setting :per_page, 20
-  setting :pid_path, 'tmp/poll.pid'
+  setting :per_page, default: 20
+  setting :pid_path, default: 'tmp/poll.pid'
 
-  setting :service_name, 'default'
+  setting :service_name, default: 'default'
 
-  setting :mapper, Mapper::Default.new
+  setting :mapper, default: Mapper::Default.new
 
   setting :subscriptions_repo
 
   setting :logger
 
-  setting :socket_error_retry_sleep, 0.5
-  setting :socket_error_retry_count, 3
+  setting :socket_error_retry_sleep, default: 0.5
+  setting :socket_error_retry_count, default: 3
 
-  setting :grpc_unavailable_retry_sleep, 0.5
-  setting :grpc_unavailable_retry_count, 3
+  setting :grpc_unavailable_retry_sleep, default: 0.5
+  setting :grpc_unavailable_retry_count, default: 3
 
   def self.configure
     yield(config) if block_given?

data/lib/event_store_client/deserialized_event.rb

@@ -4,34 +4,55 @@ require 'dry/schema'
 
 module EventStoreClient
   class DeserializedEvent
-    attr_reader :id
-    attr_reader :type
-    attr_reader :title
-    attr_reader :data
-    attr_reader :metadata
-
-    def schema
-      Dry::Schema.Params do
-      end
-    end
+    InvalidDataError = Class.new(StandardError)
+    private_constant :InvalidDataError
+
+    attr_reader :id, :type, :title, :data, :metadata
+
+    # @args [Hash] opts
+    # @option opts [Boolean] :skip_validation
+    # @option opts [Hash] :data
+    # @option opts [Hash] :metadata
+    # @option opts [String] :type
+    # @option opts [String] :title
+    # @option opts [UUID] :id
+    #
+    def initialize(args = {})
+      validate(args[:data]) unless args[:skip_validation]
 
-    def initialize(**args)
-      validation = schema.call(args[:data] || {})
       @data = args.fetch(:data) { {} }
-      @metadata = args.fetch(:metadata) { {} }.merge(
-        'type' => self.class.name,
-        'content-type' => content_type
-      )
-      @metadata.merge!('validation-errors' => validation.errors.to_h) if validation.errors.any?
+      @metadata =
+        args.fetch(:metadata) { {} }
+            .merge(
+              'type' => self.class.name,
+              'content-type' => payload_content_type
+            )
+
       @type = args[:type] || self.class.name
       @title = args[:title]
       @id = args[:id]
     end
 
-    def content_type
+    # event schema
+    def schema; end
+
+    # content type of the event data
+    def payload_content_type
       return 'application/json' if EventStoreClient.config.adapter == :grpc
 
       'application/vnd.eventstore.events+json'
     end
+
+    private
+
+    def validate(data)
+      return unless schema
+
+      validation = schema.call(data || {})
+
+      return unless validation.errors.any?
+
+      raise(InvalidDataError.new(message: "#{schema.class.name} #{validation.errors.to_h}"))
+    end
   end
 end

data/lib/event_store_client/mapper/default.rb

@@ -23,6 +23,7 @@ module EventStoreClient
             EventStoreClient::DeserializedEvent
           end
         event_class.new(
+          skip_validation: true,
           id: event.id,
           type: event.type,
           title: event.title,

data/lib/event_store_client/mapper/encrypted.rb

@@ -51,7 +51,7 @@ module EventStoreClient
 
       def deserialize(event, skip_decryption: false)
         metadata = serializer.deserialize(event.metadata)
-        encryption_schema = serializer.deserialize(event.metadata)['encryption']
+        encryption_schema = metadata['encryption']
 
         decrypted_data =
           if skip_decryption
@@ -72,6 +72,7 @@ module EventStoreClient
           end
 
         event_class.new(
+          skip_validation: true,
           id: event.id,
           type: event.type,
           title: event.title,

data/lib/event_store_client/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_store_client
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.4.2
 platform: ruby
 authors:
 - Sebastian Wilgosz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-04 00:00:00.000000000 Z
+date: 2021-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable