event_store_client 1.4.9 → 2.0.1

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grpc'
-require 'event_store_client/adapters/grpc/connection'
-
 module EventStoreClient
   module GRPC
     class CommandRegistrar
@@ -19,13 +16,16 @@ module EventStoreClient
       end
 
       def self.request(command_klass)
-        @commands[command_klass][:request]
+        @commands.dig(command_klass, :request)
       end
 
+      # @param command_klass [Class]
+      #   Examples:
+      #     - EventStoreClient::GRPC::Commands::Streams::Append
+      #     - EventStoreClient::GRPC::Commands::Streams::Read
+      # @return [Object] GRPC service class
       def self.service(command_klass)
-        EventStoreClient::GRPC::Connection.new.call(
-          @commands[command_klass][:service]
-        )
+        @commands.dig(command_klass, :service)
       end
     end
   end

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

@@ -1,43 +1,81 @@
 # frozen_string_literal: true
 
-require 'dry-monads'
-require 'event_store_client/adapters/grpc/command_registrar'
-
 module EventStoreClient
   module GRPC
     module Commands
       class Command
-        include Configuration
-
-        class GRPCUnavailableRetryFailed < StandardError; end
+        class << self
+          def use_request(request_klass)
+            CommandRegistrar.register_request(self, request: request_klass)
+          end
 
-        def self.inherited(klass)
-          super
-          klass.class_eval do
-            include Dry::Monads[:try, :result]
+          def use_service(service_klass)
+            CommandRegistrar.register_service(self, service: service_klass)
+          end
+        end
 
-            def self.use_request(request_klass)
-              CommandRegistrar.register_request(self, request: request_klass)
-            end
+        include Configuration
+        include Dry::Monads[:try, :result]
 
-            def self.use_service(service_klass)
-              CommandRegistrar.register_service(self, service: service_klass)
-            end
+        attr_reader :connection
+        private :connection
 
-            def request
-              CommandRegistrar.request(self.class)
-            end
+        # @param conn_options [Hash]
+        # @option conn_options [String] :host
+        # @option conn_options [Integer] :port
+        # @option conn_options [String] :username
+        # @option conn_options [String] :password
+        def initialize(**conn_options)
+          @connection = EventStoreClient::GRPC::Connection.new(**conn_options)
+        end
 
-            def service
-              CommandRegistrar.service(self.class)
-            end
-          end
+        # Override it in your implementation of command.
+        def call
+          raise NotImplementedError
         end
 
+        # @return [Hash]
         def metadata
+          return {} unless connection.class.secure?
+
           credentials =
-            Base64.encode64("#{config.eventstore_user}:#{config.eventstore_password}")
-          { 'authorization' => "Basic #{credentials.delete("\n")}" }
+            Base64.encode64("#{connection.username}:#{connection.password}").delete("\n")
+          { 'authorization' => "Basic #{credentials}" }
+        end
+
+        # @return GRPC params class to be used in the request.
+        #   E.g.EventStore::Client::Streams::ReadReq
+        def request
+          CommandRegistrar.request(self.class)
+        end
+
+        # @return GRPC request stub class. E.g. EventStore::Client::Streams::Streams::Stub
+        def service
+          connection.call(CommandRegistrar.service(self.class))
+        end
+
+        # @return [Hash] connection options' hash
+        def connection_options
+          @connection.options_hash
+        end
+
+        private
+
+        def retry_request(skip_retry: false)
+          return yield if skip_retry
+
+          retries = 0
+          begin
+            yield
+          rescue ::GRPC::Unavailable => e
+            sleep config.eventstore_url.grpc_retry_interval / 1000.0
+            retries += 1
+            if retries <= config.eventstore_url.grpc_retry_attempts
+              config.logger&.debug("Request failed. Reason: #{e.class}. Retying.")
+              retry
+            end
+            raise
+          end
         end
       end
     end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'event_store_client/adapters/grpc/generated/shared_pb'
+require 'event_store_client/adapters/grpc/generated/gossip_pb'
+require 'event_store_client/adapters/grpc/generated/gossip_services_pb'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Gossip
+        class ClusterInfo < Command
+          use_request EventStore::Client::Empty
+          use_service EventStore::Client::Gossip::Gossip::Stub
+
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#cluster_info}
+          def call
+            Success(retry_request { service.read(request.new, metadata: metadata) })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require 'grpc'
 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'
-
 module EventStoreClient
   module GRPC
     module Commands
@@ -17,91 +14,69 @@ module EventStoreClient
           ALLOWED_EVENT_METADATA = %w[type content-type created_at].freeze
 
           # @api private
-          def call(stream, events, options: {})
-            return unless events.any?
-
-            serialized_events = events.map { |event| config.mapper.serialize(event) }
-
-            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?
+          # @see {EventStoreClient::GRPC::Client#append_to_stream}
+          def call(stream_name, event, options:, &blk)
+            payload =
+              [
+                request.new(options: options(stream_name, options)),
+                request.new(proposed_message: proposed_message(event))
+              ]
+            yield(*payload) if blk
+            response = retry_request(skip_retry: config.eventstore_url.throw_on_append_failure) do
+              service.append(payload, metadata: metadata)
             end
-
-            res.success? ? Success(events) : Failure(res.failure)
+            validate_response(response)
+          rescue ::GRPC::Unavailable => e
+            Failure(e)
           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)
+          # @param event [EventStoreClient::DeserializedEvent]
+          # @return [EventStore::Client::Streams::AppendReq::ProposedMessage]
+          def proposed_message(event)
+            serialized_event = config.mapper.serialize(event)
+            event_metadata = JSON.parse(serialized_event.metadata)
+            custom_metadata = custom_metadata(serialized_event.type, event_metadata)
+            opts =
+              {
+                id: {
+                  string: serialized_event.id
+                },
+                data: serialized_event.data.b,
+                custom_metadata: custom_metadata.to_json,
+                metadata: event_metadata.slice(*ALLOWED_EVENT_METADATA)
+              }
+            EventStore::Client::Streams::AppendReq::ProposedMessage.new(opts)
           end
 
+          # @param event_type [String]
+          # @param event_metadata [Hash]
+          # @return [Hash]
           def custom_metadata(event_type, event_metadata)
             {
               type: event_type,
-              created_at: Time.current,
+              created_at: Time.now.utc,
               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
-            }
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @return [EventStore::Client::Streams::AppendReq::Options]
+          def options(stream_name, options)
+            opts = Options::Streams::WriteOptions.new(stream_name, options).request_options
+            EventStore::Client::Streams::AppendReq::Options.new(opts)
           end
 
+          # @param resp [EventStore::Client::Streams::AppendResp]
+          # @return [Dry::Monads::Success, Dry::Monads::Failure]
           def validate_response(resp)
-            return Success() if resp.success
+            return Success(resp) if resp.success
 
-            Failure(
-              "current version: #{resp.wrong_expected_version.current_revision} | "\
-              "expected: #{resp.wrong_expected_version.expected_revision}"
-            )
+            Failure(resp.wrong_expected_version)
           end
         end
       end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# rubocop:disable Naming/PredicateName
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Streams
+        class AppendMultiple < Command
+          # @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(**connection_options).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?
+            end
+            result
+          end
+
+          private
+
+          # Even if #revision is not set explicitly - its value defaults to 0. Thus, you can't
+          # detect whether #revision is set just by calling #revision method. Instead - check if
+          # option does not set #no_stream, #any or #stream_exists options - they are self-exclusive
+          # options and only one of them can be active at a time
+          # @param options [EventStore::Client::Streams::AppendReq::Options]
+          # @return [Boolean]
+          def has_revision_option?(options)
+            [options.no_stream, options.any, options.stream_exists].all?(&:nil?)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Naming/PredicateName

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

@@ -1,10 +1,7 @@
 # frozen_string_literal: true
 
-require 'grpc'
-require 'event_store_client/adapters/grpc/generated/projections_pb.rb'
-require 'event_store_client/adapters/grpc/generated/projections_services_pb.rb'
-
-require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/generated/streams_pb'
+require 'event_store_client/adapters/grpc/generated/streams_services_pb'
 
 module EventStoreClient
   module GRPC
@@ -14,19 +11,26 @@ module EventStoreClient
           use_request EventStore::Client::Streams::DeleteReq
           use_service EventStore::Client::Streams::Streams::Stub
 
-          def call(name, options: {}) # rubocop:disable Lint/UnusedMethodArgument
-            opts =
-              {
-                stream_identifier: {
-                  streamName: name
-                },
-                any: {}
-              }
-
-            service.delete(request.new(options: opts), metadata: metadata)
-            Success()
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#delete_stream}
+          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(:not_found)
+            Failure(:stream_not_found)
+          end
+
+          private
+
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @return [EventStore::Client::Streams::TombstoneReq::Options]
+          def normalize_options(stream_name, options)
+            opts = Options::Streams::WriteOptions.new(stream_name, options).request_options
+            EventStore::Client::Streams::DeleteReq::Options.new(opts)
           end
         end
       end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'event_store_client/adapters/grpc/generated/streams_pb'
+require 'event_store_client/adapters/grpc/generated/streams_services_pb'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Streams
+        class HardDelete < Command
+          use_request EventStore::Client::Streams::TombstoneReq
+          use_service EventStore::Client::Streams::Streams::Stub
+
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#hard_delete_stream}
+          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)
+          end
+
+          private
+
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @return [EventStore::Client::Streams::TombstoneReq::Options]
+          def normalize_options(stream_name, options)
+            opts = Options::Streams::WriteOptions.new(stream_name, options).request_options
+            EventStore::Client::Streams::TombstoneReq::Options.new(opts)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,62 +1,17 @@
 # frozen_string_literal: true
 
-require 'securerandom'
-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/commands/command'
-
 module EventStoreClient
   module GRPC
     module Commands
       module Streams
         class LinkTo < Command
-          include Configuration
-
-          use_request EventStore::Client::Streams::AppendReq
-          use_service EventStore::Client::Streams::Streams::Stub
-
-          def call(stream_name, events, options: {})
-            events.each_with_index do |event, index|
-              custom_metadata = JSON.generate(
-                "type": '$>',
-                "created_at": Time.now,
-                "encryption": event.metadata['encryption'] || ''
-              )
-
-              event_metadata = event.metadata.tap do |h|
-                h['type'] = '$>'
-                h['content-type'] = 'application/json'
-                h.delete('encryption')
-              end
-
-              event_id = event.id
-              event_id = SecureRandom.uuid if event.id.nil? || event.id.empty?
-
-              payload = [
-                request.new(
-                  options: {
-                    stream_identifier: {
-                      streamName: stream_name
-                    },
-                    any: {}
-                  }
-                ),
-                request.new(
-                  proposed_message: {
-                    id: {
-                      string: event_id
-                    },
-                    data: event.title,
-                    custom_metadata: custom_metadata,
-                    metadata: event_metadata
-                  }
-                )
-              ]
-              service.append(payload, metadata: metadata)
-            end
-            Success()
+          # @see {EventStoreClient::GRPC::Client#hard_delete_stream}
+          def call(stream_name, event, options:, &blk)
+            append_cmd = Append.new(**connection_options)
+            link_event = EventStoreClient::DeserializedEvent.new(
+              id: event.id, type: '$>', data: event.title
+            )
+            append_cmd.call(stream_name, link_event, options: options, &blk)
           end
         end
       end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# rubocop:disable Naming/PredicateName
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Streams
+        class LinkToMultiple < Command
+          # @api private
+          # @see {EventStoreClient::GRPC::Client#link_to}
+          def call(stream_name, events, options:, &blk)
+            result = []
+            link_cmd = Commands::Streams::LinkTo.new(**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?
+            end
+            result
+          end
+
+          private
+
+          # Even if #revision is not set explicitly - its value defaults to 0. Thus, you can't
+          # detect whether #revision is set just by calling #revision method. Instead - check if
+          # option does not set #no_stream, #any or #stream_exists options - they are self-exclusive
+          # options and only one of them can be active at a time
+          # @param options [EventStore::Client::Streams::AppendReq::Options]
+          # @return [Boolean]
+          def has_revision_option?(options)
+            [options.no_stream, options.any, options.stream_exists].all?(&:nil?)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Naming/PredicateName