event_store_client 1.2.2 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23572ade9e7d340341d26d103fc2a330ecfa7df71f9a98a8369061b64b206133
-  data.tar.gz: e8104a10545a460adf71d445d4f203ef347da27793c23f785b03e54908369304
+  metadata.gz: d1fd97d12d7212eed5e7fef538bd4896ab2183ba223350d36f1cbc44fc2c75fc
+  data.tar.gz: aa7b1f637b4d9b36b532c9e7bfb22ceaa9c144acc28868bfa05658141e22d07d
 SHA512:
-  metadata.gz: dc01f4661a550f1a6b3bd56b86eff3601a4693e50ceec51dc4f0e5fda63bc4b14bcf27f2da8933d7e5263dbc2ccc490f23e0b3d128b12ae0527c5fd6e51b74b8
-  data.tar.gz: a6968eae108d9964d3ccecc3d82acd28076c03bb78a0a8ab1b2856a858dac9bbacd87607a1271d08424c7755c8e7cc759ef4eefe1c008616afaa326ddeed4749
+  metadata.gz: b807db30af1cc618c3bcfb8f51e91fbe0a538ac99322b9e6736ab0dbc2f1b0b816d28a69a7f2996591bb481f7396dab03cc1ae6d5e1c9c9681b1342a551d880c
+  data.tar.gz: 6165caf9a71bdb547c45d872a216223f7f765802770ef00a978785f1882b82f1404cd8e194120c06efdd07af7255a89ffa3cd20545fc75fbc8e2d1551a3d7229

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/client.rb

@@ -11,7 +11,7 @@ module EventStoreClient
 
     def publish(stream:, events:, options: {})
       res = connection.append_to_stream(stream, events, options: options)
-      raise WrongExpectedEventVersion.new(e.message) if res.failure?
+      raise WrongExpectedEventVersion.new(res.failure) if res.failure?
       res
     end
 

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,53 @@ 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)
+      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/event.rb

@@ -14,7 +14,7 @@ module EventStoreClient
 
     private
 
-    def initialize(**args)
+    def initialize(args = {})
       args[:id] = SecureRandom.uuid if args[:id].nil?
       hash_meta = JSON.parse(args[:metadata] || '{}')
       hash_meta['created_at'] ||= Time.now

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.2'
+  VERSION = '1.4.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_store_client
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.4.1
 platform: ruby
 authors:
 - Sebastian Wilgosz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-16 00:00:00.000000000 Z
+date: 2021-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -262,7 +262,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.0.pre1
 signing_key:
 specification_version: 4
 summary: Ruby integration for https://eventstore.org