event_store_client 1.4.9 → 2.0.0

data/lib/event_store_client/adapters/grpc/shared/options/stream_options.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Shared
+      module Options
+        class StreamOptions
+          attr_reader :stream_name, :options
+          private :stream_name, :options
+
+          # @param stream_name [String]
+          # @param options [Hash]
+          # @option options [Integer, Symbol] :from_revision. If number is provided - it is threaded
+          #   as starting revision number. Alternatively you can provide :start or :end value to
+          #   define a stream revision. **Use this option when stream name is a normal stream name**
+          # @option options [Hash, Symbol] :from_position. If hash is provided - you should supply
+          #   it with :commit_position and/or :prepare_position keys. Alternatively you can provide
+          #   :start or :end value to define a stream position. **Use this option when stream name
+          #   is "$all"**
+          def initialize(stream_name, options)
+            @stream_name = stream_name
+            @options = options
+          end
+
+          # @return [Hash]
+          def request_options
+            stream_name == '$all' ? all_stream : stream
+          end
+
+          private
+
+          # @return [Hash]
+          #   Examples:
+          #   ```ruby
+          #   { all: { start: EventStore::Client::Empty.new } }
+          #   ```
+          #   ```ruby
+          #   { all: { end: EventStore::Client::Empty.new } }
+          #   ```
+          #   ```ruby
+          #   { all: { position: { commit_position: 1, prepare_position: 1 } } }
+          #   ```
+          def all_stream
+            position_opt =
+              case options[:from_position]
+              when :start, :end
+                { options[:from_position] => EventStore::Client::Empty.new }
+              when Hash
+                { position: options[:from_position] }
+              else
+                { start: EventStore::Client::Empty.new }
+              end
+            { all: position_opt }
+          end
+
+          # @return [Hash]
+          #   Examples:
+          #   ```ruby
+          #   { stream: {
+          #       start: EventStore::Client::Empty.new,
+          #       stream_identifier: { stream_name: 'some-stream' }
+          #     }
+          #   }
+          #   ```
+          #   ```ruby
+          #   { stream: {
+          #       end: EventStore::Client::Empty.new,
+          #       stream_identifier: { stream_name: 'some-stream' }
+          #     }
+          #   }
+          #   ```
+          #   ```ruby
+          #   { stream: { revision: 1, stream_identifier: { stream_name: 'some-stream' } } }
+          #   ```
+          def stream
+            revision_opt =
+              case options[:from_revision]
+              when :start, :end
+                { options[:from_revision] => EventStore::Client::Empty.new }
+              when Integer
+                { revision: options[:from_revision] }
+              else
+                { start: EventStore::Client::Empty.new }
+              end
+            { stream: revision_opt.merge(stream_identifier: { stream_name: stream_name }) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Shared
+      module Streams
+        class ProcessResponse
+          include Dry::Monads[:result]
+
+          # @api private
+          # @param response [EventStore::Client::Streams::ReadResp]
+          # @param skip_deserialization [Boolean]
+          # @param skip_decryption [Boolean]
+          # @return [Dry::Monads::Success, Dry::Monads::Failure, nil]
+          def call(response, skip_deserialization, skip_decryption)
+            return Failure(:stream_not_found) if response.stream_not_found
+            return Success(response) if skip_deserialization
+            return unless response.event&.event
+
+            Success(
+              EventDeserializer.new.call(response.event.event, skip_decryption: skip_decryption)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Shared
+      module Streams
+        class ProcessResponses
+          include Dry::Monads[:result]
+
+          # @api private
+          # @param responses [Array<EventStore::Client::Streams::ReadResp>]
+          # @param skip_deserialization [Boolean]
+          # @param skip_decryption [Boolean]
+          # @return [Dry::Monads::Success, Dry::Monads::Failure]
+          def call(responses, skip_deserialization, skip_decryption)
+            return Failure(:stream_not_found) if responses.first&.stream_not_found
+            return Success(responses) if skip_deserialization
+
+            events =
+              responses.map do |read_resp|
+                # 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 read_resp.event&.event
+
+                EventDeserializer.new.call(read_resp.event.event, skip_decryption: skip_decryption)
+              end
+            Success(events.compact)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc.rb

@@ -1,22 +1,38 @@
 # frozen_string_literal: true
 
-require 'event_store_client/value_objects/read_direction.rb'
+require 'grpc'
+require 'dry-monads'
+
+require 'event_store_client/adapters/grpc/options/streams/read_options'
+require 'event_store_client/adapters/grpc/options/streams/write_options'
+
+require 'event_store_client/adapters/grpc/shared/event_deserializer'
+require 'event_store_client/adapters/grpc/shared/options/stream_options'
+require 'event_store_client/adapters/grpc/shared/options/filter_options'
+require 'event_store_client/adapters/grpc/shared/streams/process_response'
+require 'event_store_client/adapters/grpc/shared/streams/process_responses'
+
+require 'event_store_client/adapters/grpc/connection'
+require 'event_store_client/adapters/grpc/discover'
+require 'event_store_client/adapters/grpc/cluster/insecure_connection'
+require 'event_store_client/adapters/grpc/cluster/secure_connection'
+require 'event_store_client/adapters/grpc/cluster/queryless_discover'
+require 'event_store_client/adapters/grpc/cluster/gossip_discover'
+require 'event_store_client/adapters/grpc/cluster/member'
+
+require 'event_store_client/adapters/grpc/command_registrar'
+require 'event_store_client/adapters/grpc/commands/command'
+
+require 'event_store_client/adapters/grpc/commands/gossip/cluster_info'
 
 require 'event_store_client/adapters/grpc/commands/streams/append'
+require 'event_store_client/adapters/grpc/commands/streams/append_multiple'
 require 'event_store_client/adapters/grpc/commands/streams/delete'
+require 'event_store_client/adapters/grpc/commands/streams/hard_delete'
 require 'event_store_client/adapters/grpc/commands/streams/link_to'
+require 'event_store_client/adapters/grpc/commands/streams/link_to_multiple'
 require 'event_store_client/adapters/grpc/commands/streams/read'
-require 'event_store_client/adapters/grpc/commands/streams/read_all'
+require 'event_store_client/adapters/grpc/commands/streams/read_paginated'
 require 'event_store_client/adapters/grpc/commands/streams/subscribe'
-require 'event_store_client/adapters/grpc/commands/streams/tombstone'
-
-require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/create'
-require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/update'
-require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/delete'
-require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/read'
-
-require 'event_store_client/adapters/grpc/commands/projections/create'
-require 'event_store_client/adapters/grpc/commands/projections/update'
-require 'event_store_client/adapters/grpc/commands/projections/delete'
 
 require 'event_store_client/adapters/grpc/client'

data/lib/event_store_client/configuration.rb

@@ -1,64 +1,49 @@
 # frozen_string_literal: true
 
 require 'dry-configurable'
-require 'event_store_client/error_handler'
-require 'event_store_client/deserialized_event'
 
 module EventStoreClient
-  extend Dry::Configurable
-
-  # Supported adapters: %i[api in_memory grpc]
-  #
-  setting :adapter, default: :grpc
-  setting :verify_ssl, default: true
-
-  setting :error_handler, default: ErrorHandler.new
-  setting :eventstore_url,
-          default: 'http://localhost:2113',
-          constructor: proc { |value| value.is_a?(URI) ? value : URI(value) }
-  setting :eventstore_user, default: 'admin'
-  setting :eventstore_password, default: 'changeit'
-
-  setting :db_port, default: 2113
-
-  setting :per_page, default: 20
-  setting :pid_path, default: 'tmp/poll.pid'
-
-  setting :service_name, default: 'default'
-
-  setting :mapper, default: Mapper::Default.new
-
-  setting :default_event_class, default: DeserializedEvent
-
-  setting :subscriptions_repo
-
-  setting :logger
-
-  setting :socket_error_retry_sleep, default: 0.5
-  setting :socket_error_retry_count, default: 3
-
-  setting :grpc_unavailable_retry_sleep, default: 0.5
-  setting :grpc_unavailable_retry_count, default: 3
-
-  def self.configure
-    yield(config) if block_given?
-  end
+  class << self
+    def configure
+      yield(config) if block_given?
+    end
 
-  def self.adapter
-    @adapter =
-      case config.adapter
-      when :http
-        require 'event_store_client/adapters/http'
-        HTTP::Client.new
-      when :grpc
-        require 'event_store_client/adapters/grpc'
-        GRPC::Client.new
-      else
-        require 'event_store_client/adapters/in_memory'
-        InMemory.new(
-          mapper: config.mapper, per_page: config.per_page
-        )
+    def config
+      @config ||= Class.new do
+        extend Dry::Configurable
+
+        # @param logger [Logger, nil]
+        # @return [Logger, nil]
+        def self.assign_grpc_logger(logger)
+          ::GRPC.define_singleton_method :logger do
+            @logger ||= logger.nil? ? ::GRPC::DefaultLogger::NoopLogger.new : logger
+          end
+          logger
+        end
+
+        setting :eventstore_url,
+                default: 'esdb://localhost:2113',
+                constructor:
+                  proc { |value|
+                    value.is_a?(Connection::Url) ? value : Connection::UrlParser.new.call(value)
+                  }
+        setting :per_page, default: 20
+
+        setting :mapper, default: Mapper::Default.new
+
+        setting :default_event_class, default: DeserializedEvent
+
+        setting :logger, constructor: method(:assign_grpc_logger).to_proc
+
+        setting :skip_deserialization, default: false
+        setting :skip_decryption, default: false
       end
+      @config.config
+    end
+
+    def client
+      GRPC::Client.new
+    end
   end
 
   # Configuration module to be included in classes required configured variables

data/lib/event_store_client/connection/url.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module Connection
+    # Structured representation of connection string. You should not use it directly. If you would
+    # like to parse connection string into an instance of this class - use
+    # EventStoreClient::Connection::UrlParser instead.
+    # @api private
+    class Url
+      include Extensions::OptionsExtension
+
+      NODE_PREFERENCES = %i[Leader Follower ReadOnlyReplica].freeze
+      Node = Struct.new(:host, :port)
+
+      # This option will allow you to perform the discovery by only one host
+      # https://developers.eventstore.com/server/v21.10/cluster.html#cluster-with-dns
+      option(:dns_discover) { false }
+      option(:username) { 'admin' }
+      option(:password) { 'changeit' }
+      # Defines if append request should raise error immediately. If set to `false`, in case of
+      # server error - request will be retried.
+      option(:throw_on_append_failure) { true }
+      # Whether to use secure connection
+      option(:tls) { true }
+      # Whether to verify a certificate
+      option(:tls_verify_cert) { false }
+      # A path to certificate file
+      option(:tls_ca_file)
+      # Interval between X.509 certificate lookup attempts. This option is useful when you set tls
+      # option to true, but you didn't provide tls_ca_file option. In this case the certificate
+      # will be retrieved using Net::HTTP#peer_cert method.
+      option(:ca_lookup_interval) { 100 } # milliseconds
+      # Number of attempts of lookup of X.509 certificate
+      option(:ca_lookup_attempts) { 3 }
+      # Discovery request timeout. Only useful when there are several nodes or when dns_discover
+      # option is true
+      option(:gossip_timeout) { 200 } # milliseconds
+      # Max attempts before giving up to find a suitable cluster member. Only useful when there are
+      # several nodes or when dns_discover option is true
+      option(:max_discover_attempts) { 10 }
+      # Interval between discover attempts
+      option(:discover_interval) { 100 } # milliseconds
+      # Response timeout
+      option(:timeout) # milliseconds
+      # During the discovery - set which state will be taken in prio during cluster members look up
+      option(:node_preference) { NODE_PREFERENCES.first }
+      # A list of nodes to discover. It is represented as an array of
+      # EventStoreClient::Connection::Url::Node instances
+      option(:nodes) { Set.new }
+      # Number of time to retry GRPC request. Does not apply to discover request. Final number of
+      # requests in cases of error will be initial request + grpc_retry_attempts.
+      option(:grpc_retry_attempts) { 3 }
+      # Delay between GRPC request retries
+      option(:grpc_retry_interval) { 100 } # milliseconds
+    end
+  end
+end

data/lib/event_store_client/connection/url_parser.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module Connection
+    class UrlParser
+      class << self
+        def boolean_param(value)
+          return unless %w[true false].include?(value)
+
+          value == 'true'
+        end
+      end
+
+      ParsedUrl = Struct.new(:scheme, :host, :port, :user, :password, :params)
+      # It is used to detect if string starts from some scheme. E.g. "esdb://", "esdb+discover://",
+      # "http://", "https://" and so on
+      SCHEME_REGEXP = %r{\A[\w|+]*://}.freeze
+
+      # Define a set of rules to translate connection string into
+      # EventStoreClient::Connection::Url options.
+      #
+      # "First url" means first extracted from the connection string url. It may contain schema,
+      # discover flag, user name and password.
+      # Example. Let's say a developer provided
+      # "esdb+discover://admin:some-password@localhost:2112,localhost:2113" connection string. Then,
+      # during parsing, the first url will be 'esdb+discover://admin:some-password@localhost:2112'
+      FIRST_URL_RULES = {
+        dns_discover: ->(parsed_url) { parsed_url.scheme&.include?('+discover') },
+        username: ->(parsed_url) { parsed_url.user },
+        password: ->(parsed_url) { parsed_url.password }
+      }.freeze
+      # "Last url" means the latest extracted url from the connections string. It contains params.
+      # So LAST_URL_RULES rules defines rules how to translate params into
+      # EventStoreClient::Connection::Url options.
+      # Example. Let's say a developer provided
+      # "esdb+discover://admin:some-password@localhost:2112,localhost:2113/?tls=false" connection
+      # string. Then, during parsing, last url will be 'localhost:2113/?tls=false'.
+      LAST_URL_RULES = {
+        throw_on_append_failure: lambda { |parsed_url|
+          boolean_param(parsed_url.params['throwOnAppendFailure'])
+        },
+        tls: ->(parsed_url) { boolean_param(parsed_url.params['tls']) },
+        tls_verify_cert: ->(parsed_url) { boolean_param(parsed_url.params['tlsVerifyCert']) },
+        tls_ca_file: ->(parsed_url) { parsed_url.params['tlsCAFile'] },
+        gossip_timeout: ->(parsed_url) { parsed_url.params['gossipTimeout']&.to_i },
+        discover_interval: ->(parsed_url) { parsed_url.params['discoverInterval']&.to_i },
+        max_discover_attempts: ->(parsed_url) { parsed_url.params['maxDiscoverAttempts']&.to_i },
+        ca_lookup_interval: ->(parsed_url) { parsed_url.params['caLookupInterval']&.to_i },
+        ca_lookup_attempts: ->(parsed_url) { parsed_url.params['caLookupAttempts']&.to_i },
+        node_preference: lambda { |parsed_url|
+          value = parsed_url.params['nodePreference']&.dup
+          if value
+            value[0] = value[0]&.upcase
+            value = value.to_sym
+          end
+          value if Url::NODE_PREFERENCES.include?(value)
+        },
+        timeout: ->(parsed_url) { parsed_url.params['timeout']&.to_i },
+        grpc_retry_attempts: ->(parsed_url) { parsed_url.params['grpcRetryAttempts']&.to_i },
+        grpc_retry_interval: ->(parsed_url) { parsed_url.params['grpcRetryInterval']&.to_i }
+      }.freeze
+
+      # @param connection_str [String] EventStore DB connection string
+      # @return [EventStoreClient::Connection::Url]
+      def call(connection_str)
+        urls = connection_str.split(',')
+        return Url.new if urls.empty?
+
+        first_url, *other, last_url = urls
+
+        es_url = Url.new
+        options_from_first(es_url, first_url)
+        if last_url.nil? # We are dealing with one node in the url
+          options_from_last(es_url, first_url)
+        else
+          options_from_other(es_url, other)
+          options_from_last(es_url, last_url)
+        end
+
+        es_url
+      end
+
+      private
+
+      # @param es_url [EventStoreClient::Connection::Url]
+      # @param first_url [String]
+      # @return [void]
+      def options_from_first(es_url, first_url)
+        parsed_url = parse(first_url)
+        return unless parsed_url
+
+        FIRST_URL_RULES.each do |opt, rule|
+          value = rule.call(parsed_url)
+          es_url.public_send("#{opt}=", value) unless value.nil?
+        end
+        es_url.nodes.add(Url::Node.new(parsed_url.host, parsed_url.port))
+      end
+
+      # @param es_url [EventStoreClient::Connection::Url]
+      # @param last_url [String, nil]
+      # @return [void]
+      def options_from_last(es_url, last_url)
+        parsed_url = parse(last_url)
+        return unless parsed_url
+
+        LAST_URL_RULES.each do |opt, rule|
+          value = rule.call(parsed_url)
+          es_url.public_send("#{opt}=", value) unless value.nil?
+        end
+        es_url.nodes.add(Url::Node.new(parsed_url.host, parsed_url.port))
+      end
+
+      # @param es_url [EventStoreClient::Connection::Url]
+      # @param urls [Array<String>]
+      # @return [void]
+      def options_from_other(es_url, urls)
+        urls.each do |url|
+          parsed_url = parse(url)
+          next unless parsed_url
+
+          es_url.nodes.add(Url::Node.new(parsed_url.host, parsed_url.port))
+        end
+      end
+
+      # @param url [String, nil]
+      # @return [EventStoreClient::Connection::UrlParser::ParsedUrl, nil]
+      def parse(url)
+        return unless url
+
+        url = "esdb://#{url}" unless url.start_with?(SCHEME_REGEXP)
+        uri = URI.parse(url)
+
+        ParsedUrl.new(
+          uri.scheme,
+          uri.host,
+          uri.port,
+          uri.user,
+          uri.password,
+          URI.decode_www_form(uri.query.to_s).to_h
+        )
+      end
+    end
+  end
+end

data/lib/event_store_client/data_decryptor.rb

@@ -43,21 +43,14 @@ module EventStoreClient
 
     def deep_dup(hash)
       return hash unless hash.instance_of?(Hash)
+
       dupl = hash.dup
       dupl.each { |k, v| dupl[k] = v.instance_of?(Hash) ? deep_dup(v) : v }
       dupl
     end
 
     def find_key(identifier)
-      key =
-        begin
-          key_repository.find(identifier).value!
-        rescue StandardError => e
-          config.error_handler&.call(e)
-          nil
-        end
-
-      key
+      key_repository.find(identifier).value!
     end
   end
 end

data/lib/event_store_client/deserialized_event.rb

@@ -7,7 +7,8 @@ module EventStoreClient
     InvalidDataError = Class.new(StandardError)
     private_constant :InvalidDataError
 
-    attr_reader :id, :type, :title, :data, :metadata
+    attr_reader :id, :type, :title, :data, :metadata, :stream_name, :stream_revision,
+                :prepare_position, :commit_position
 
     # @args [Hash] opts
     # @option opts [Boolean] :skip_validation
@@ -15,20 +16,27 @@ module EventStoreClient
     # @option opts [Hash] :metadata
     # @option opts [String] :type
     # @option opts [String] :title
+    # @option opts [String] :stream_name
+    # @option opts [Integer] :stream_revision
+    # @option opts [Integer] :prepare_position
+    # @option opts [Integer] :commit_position
     # @option opts [UUID] :id
     #
     def initialize(args = {})
       validate(args[:data]) unless args[:skip_validation]
 
       @data = args.fetch(:data) { {} }
-      @metadata =
-        args.fetch(:metadata) { {} }
-            .merge(
-              'type' => self.class.name,
-              'content-type' => payload_content_type
-            )
-
       @type = args[:type] || self.class.name
+      @metadata =
+        args.fetch(:metadata) { {} }.
+        merge(
+          'type' => @type,
+          'content-type' => payload_content_type
+        )
+      @stream_name = args[:stream_name]
+      @stream_revision = args[:stream_revision]
+      @prepare_position = args[:prepare_position]
+      @commit_position = args[:commit_position]
       @title = args[:title]
       @id = args[:id]
     end
@@ -38,9 +46,26 @@ module EventStoreClient
 
     # content type of the event data
     def payload_content_type
-      return 'application/json' if EventStoreClient.config.adapter == :grpc
+      'application/json'
+    end
+
+    # Implements comparison of `EventStoreClient::DeserializedEvent`-s. Two events matches if all of
+    # their attributes matches
+    # @param other [Object, EventStoreClient::DeserializedEvent]
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(EventStoreClient::DeserializedEvent)
+
+      to_h == other.to_h
+    end
 
-      'application/vnd.eventstore.events+json'
+    # @return [Hash]
+    def to_h
+      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
     end
 
     private

data/lib/event_store_client/encryption_metadata.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module EventStoreClient
   class EncryptionMetadata
     def call

data/lib/event_store_client/event.rb

@@ -11,8 +11,10 @@ module EventStoreClient
     attribute :title, Types::Strict::String.optional.default(nil)
     attribute :data, Types::Strict::String.default('{}')
     attribute :metadata, Types::Strict::String.default('{}')
-
-    private
+    attribute :stream_name, Types::Strict::String.optional.default(nil)
+    attribute :stream_revision, Types::Strict::Integer.optional.default(nil)
+    attribute :commit_position, Types::Strict::Integer.optional.default(nil)
+    attribute :prepare_position, Types::Strict::Integer.optional.default(nil)
 
     def initialize(args = {})
       args[:id] = SecureRandom.uuid if args[:id].nil?