event_store_client 2.2.0 → 2.3.0.pre.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f072cd6b9f3a8cb41ac746eed4cb472cf0581c042c117082076c9f29b391bbd5
-  data.tar.gz: 3fa6712c4be66e24b97bf364c22cbca1318a7681e1bc5ea765268ea19495545e
+  metadata.gz: 96e1f2743b3265c8776ffe39636f086af2be0bc19ff46e693f1fbf7373eeb3d4
+  data.tar.gz: 7595e367ccced285bb4e061d9875bf6ba84d9e999aa60f404609f0258aea1426
 SHA512:
-  metadata.gz: b0d8489a114c666079639e76817a01f1986df193434cdf0efc22e5fea968e4670e96176a433464ac2f5669f3bfdae5ef94a7b2f19b87a5ef891aebef5c6f65e2
-  data.tar.gz: 4e9ae526f384e00b2f4d5739b4f825f5336d87a9193e02f01ee87f94282c385344750653d844074e431ae1d59bad93270a362caa8d92c1a2972544e037372620
+  metadata.gz: 88e2b3324a0b59773f39077ad954e8a0f98ca0fd0bd67217a67c742bdc5ae6efbdf36878a0feeff9e2532e8f1d97f5a6eee0581268dc24cda631728fe5fc65d3
+  data.tar.gz: 73be7b894f397e323807adec3667b78ddc7f7b5973942cb7d77cb5872af1d6b01eee9f9e7c7440db213d3ea3fb23256e99066ce4d0e23af3c26bbd14c3c4bb56

data/docs/configuration.md

@@ -128,3 +128,50 @@ esdb://localhost:2113/?tls=false
 esdb+discover://localhost:2113/?grpcRetryAttempts=3&grpcRetryInterval=300&discoverInterval=200
 esdb://localhost:2113,localhost:2114,localhost:2115/?gossipTimeout=500&maxDiscoverAttempts=3
 ```
+
+### Multiple configurations
+
+`event_store_client` provides a possibility to configure as much connections as you want. To do so, you have to name your configuration, and later provide that name to `EventStoreClient` client.
+
+Setup your configs:
+```ruby
+EventStoreClient.configure(name: :es_db_1) do |config|
+  # adjust your config here
+  config.eventstore_url = 'esdb://localhost:2113'
+end
+EventStoreClient.configure(name: :es_db_2) do |config|
+  # adjust your second config here
+  config.eventstore_url = 'esdb://localhost:2114' 
+end
+```
+
+Tell `EventStoreClient` which config you want to use:
+
+```ruby
+client1 = EventStoreClient.client(config_name: :es_db_1)
+client2 = EventStoreClient.client(config_name: :es_db_2)
+# Read from $all stream using :es_db_1 config
+client1.read('$all')
+# Read from $all stream using :es_db_2 config
+client2.read('$all')
+```
+
+#### Default config
+
+If you only have one config - you don't have to bother naming it or passing a config name to the client when performing any operations. You can configure it as usual.
+
+Setup your default config:
+```ruby
+EventStoreClient.configure do |config|
+  # config goes here
+  config.eventstore_url = 'esdb://localhost:2113' 
+end
+```
+
+Use it:
+
+```ruby
+client = EventStoreClient.client
+# Read from $all stream using your default config
+client.read('$all')
+```

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

@@ -5,7 +5,13 @@
 module EventStoreClient
   module GRPC
     class Client
-      include Configuration
+      attr_reader :config
+      private :config
+
+      # @param config [EventStoreClient::Config]
+      def initialize(config)
+        @config = config
+      end
 
       # @param stream_name [String]
       # @param events_or_event [EventStoreClient::DeserializedEvent, Array<EventStoreClient::DeserializedEvent>]
@@ -30,11 +36,11 @@ module EventStoreClient
       #   Returns monads' Success/Failure in case whether request was performed.
       def append_to_stream(stream_name, events_or_event, options: {}, credentials: {}, &blk)
         if events_or_event.is_a?(Array)
-          Commands::Streams::AppendMultiple.new(**credentials).call(
+          Commands::Streams::AppendMultiple.new(config: config, **credentials).call(
             stream_name, events_or_event, options: options
           )
         else
-          Commands::Streams::Append.new(**credentials).call(
+          Commands::Streams::Append.new(config: config, **credentials).call(
             stream_name, events_or_event, options: options, &blk
           )
         end
@@ -91,7 +97,7 @@ module EventStoreClient
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def read(stream_name, options: {}, skip_deserialization: config.skip_deserialization,
                skip_decryption: config.skip_decryption, credentials: {}, &blk)
-        Commands::Streams::Read.new(**credentials).call(
+        Commands::Streams::Read.new(config: config, **credentials).call(
           stream_name,
           options: options,
           skip_deserialization: skip_deserialization,
@@ -106,7 +112,7 @@ module EventStoreClient
       def read_paginated(stream_name, options: {}, credentials: {},
                          skip_deserialization: config.skip_deserialization,
                          skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::ReadPaginated.new(**credentials).call(
+        Commands::Streams::ReadPaginated.new(config: config, **credentials).call(
           stream_name,
           options: options,
           skip_deserialization: skip_deserialization,
@@ -133,7 +139,9 @@ module EventStoreClient
       #     ```
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def hard_delete_stream(stream_name, options: {}, credentials: {}, &blk)
-        Commands::Streams::HardDelete.new(**credentials).call(stream_name, options: options, &blk)
+        Commands::Streams::HardDelete.
+          new(config: config, **credentials).
+          call(stream_name, options: options, &blk)
       end
 
       # Refs https://developers.eventstore.com/server/v5/streams.html#soft-delete-and-truncatebefore
@@ -154,7 +162,9 @@ module EventStoreClient
       #     ```
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def delete_stream(stream_name, options: {}, credentials: {}, &blk)
-        Commands::Streams::Delete.new(**credentials).call(stream_name, options: options, &blk)
+        Commands::Streams::Delete.
+          new(config: config, **credentials).
+          call(stream_name, options: options, &blk)
       end
 
       # Subscribe to the given stream and listens for events. Note, that it will block execution of
@@ -213,7 +223,7 @@ module EventStoreClient
       def subscribe_to_stream(stream_name, handler:, options: {}, credentials: {},
                               skip_deserialization: config.skip_deserialization,
                               skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::Subscribe.new(**credentials).call(
+        Commands::Streams::Subscribe.new(config: config, **credentials).call(
           stream_name,
           handler: handler,
           options: options,
@@ -229,7 +239,7 @@ module EventStoreClient
       def subscribe_to_all(handler:, options: {}, credentials: {},
                            skip_deserialization: config.skip_deserialization,
                            skip_decryption: config.skip_decryption, &blk)
-        Commands::Streams::Subscribe.new(**credentials).call(
+        Commands::Streams::Subscribe.new(config: config, **credentials).call(
           '$all',
           handler: handler,
           options: options,
@@ -246,14 +256,14 @@ module EventStoreClient
       # @see #append_to_stream for available params and returned value
       def link_to(stream_name, events_or_event, options: {}, credentials: {}, &blk)
         if events_or_event.is_a?(Array)
-          Commands::Streams::LinkToMultiple.new(**credentials).call(
+          Commands::Streams::LinkToMultiple.new(config: config, **credentials).call(
             stream_name,
             events_or_event,
             options: options,
             &blk
           )
         else
-          Commands::Streams::LinkTo.new(**credentials).call(
+          Commands::Streams::LinkTo.new(config: config, **credentials).call(
             stream_name,
             events_or_event,
             options: options,
@@ -267,7 +277,7 @@ module EventStoreClient
       # @option credentials [String] :password
       # @return [Dry::Monads::Success, Dry::Monads::Failure]
       def cluster_info(credentials: {})
-        Commands::Gossip::ClusterInfo.new(**credentials).call
+        Commands::Gossip::ClusterInfo.new(config: config, **credentials).call
       end
     end
   end

data/lib/event_store_client/adapters/grpc/cluster/gossip_discover.rb

@@ -6,8 +6,6 @@ module EventStoreClient
   module GRPC
     module Cluster
       class GossipDiscover
-        include Configuration
-
         DiscoverError = Class.new(StandardError)
 
         # Order is important - it plays role of states priority as well
@@ -15,6 +13,14 @@ module EventStoreClient
         ALLOWED_NODE_STATES =
           (%i[Leader Follower] + READ_ONLY_STATES).freeze
 
+        attr_reader :config
+        private :config
+
+        # @param config [EventStoreClient::Config]
+        def initialize(config:)
+          @config = config
+        end
+
         # @param nodes [Array<EventStoreClient::Connection::Url::Node>]
         # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
         # @return [EventStoreClient::GRPC::Cluster::Member]
@@ -58,7 +64,8 @@ module EventStoreClient
           connection = Connection.new(
             host: node.host,
             port: node.port,
-            timeout: config.eventstore_url.gossip_timeout
+            timeout: config.eventstore_url.gossip_timeout,
+            config: config
           )
           members =
             connection.

data/lib/event_store_client/adapters/grpc/cluster/queryless_discover.rb

@@ -4,10 +4,16 @@ module EventStoreClient
   module GRPC
     module Cluster
       class QuerylessDiscover
-        include Configuration
-
         NoHostError = Class.new(StandardError)
 
+        attr_reader :config
+        private :config
+
+        # @param config [EventStoreClient::Config]
+        def initialize(config:)
+          @config = config
+        end
+
         # @param nodes [EventStoreClient::Connection::Url::Node]
         # @return [EventStoreClient::GRPC::Cluster::Member]
         def call(nodes)

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

@@ -14,19 +14,20 @@ module EventStoreClient
           end
         end
 
-        include Configuration
         include Dry::Monads[:try, :result]
 
-        attr_reader :connection
-        private :connection
+        attr_reader :connection, :config
+        private :connection, :config
 
+        # @param config [EventStoreClient::Config]
         # @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)
+        def initialize(config:, **conn_options)
+          @config = config
+          @connection = EventStoreClient::GRPC::Connection.new(config: config, **conn_options)
         end
 
         # Override it in your implementation of command.
@@ -74,6 +75,7 @@ module EventStoreClient
               config.logger&.debug("Request failed. Reason: #{e.class}. Retying.")
               retry
             end
+            Discover.current_member(config: config)&.failed_endpoint = true
             raise
           end
         end

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

@@ -12,7 +12,9 @@ module EventStoreClient
           def call(stream_name, events, options:, &blk)
             result = []
             events.each.with_index do |event, index|
-              response = Commands::Streams::Append.new(**connection_options).call(
+              response = Commands::Streams::Append.new(
+                config: config, **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)

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

@@ -7,7 +7,7 @@ module EventStoreClient
         class LinkTo < Command
           # @see {EventStoreClient::GRPC::Client#hard_delete_stream}
           def call(stream_name, event, options:, &blk)
-            append_cmd = Append.new(**connection_options)
+            append_cmd = Append.new(config: config, **connection_options)
             link_event = DeserializedEvent.new(
               id: event.id, type: DeserializedEvent::LINK_TYPE, data: event.title
             )

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

@@ -11,12 +11,11 @@ module EventStoreClient
           # @see {EventStoreClient::GRPC::Client#link_to}
           def call(stream_name, events, options:, &blk)
             result = []
-            link_cmd = Commands::Streams::LinkTo.new(**connection_options)
+            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)

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

@@ -15,7 +15,7 @@ module EventStoreClient
             yield options if block_given?
             result =
               retry_request { service.read(request.new(options: options), metadata: metadata).to_a }
-            EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
+            EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new(config: config).call(
               result,
               skip_deserialization,
               skip_decryption
@@ -28,7 +28,10 @@ module EventStoreClient
           # @param options [Hash]
           # @return [EventStore::Client::Streams::ReadReq::Options]
           def normalize_options(stream_name, options)
-            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            options =
+              Options::Streams::ReadOptions.
+                new(stream_name, options, config: config).
+                request_options
             EventStore::Client::Streams::ReadReq::Options.new(options)
           end
         end

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

@@ -22,7 +22,7 @@ module EventStoreClient
             Enumerator.new do |yielder|
               loop do
                 response =
-                  Read.new(**connection_options).call(
+                  Read.new(config: config, **connection_options).call(
                     stream_name,
                     options: options,
                     skip_deserialization: true,
@@ -45,11 +45,13 @@ module EventStoreClient
                   raise StopIteration
                 end
                 processed_response =
-                  EventStoreClient::GRPC::Shared::Streams::ProcessResponses.new.call(
-                    response.success,
-                    skip_deserialization,
-                    skip_decryption
-                  )
+                  EventStoreClient::GRPC::Shared::Streams::ProcessResponses.
+                    new(config: config).
+                    call(
+                      response.success,
+                      skip_deserialization,
+                      skip_decryption
+                    )
                 yielder << processed_response if processed_response.success.any?
                 raise StopIteration if end_reached?(response.success, max_count)
 

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

@@ -20,7 +20,7 @@ module EventStoreClient
             yield options if block_given?
 
             callback = proc do |response|
-              result = Shared::Streams::ProcessResponse.new.call(
+              result = Shared::Streams::ProcessResponse.new(config: config).call(
                 response,
                 skip_deserialization,
                 skip_decryption
@@ -41,7 +41,10 @@ module EventStoreClient
           # @param options [Hash]
           # @return [EventStore::Client::Streams::ReadReq::Options]
           def normalize_options(stream_name, options)
-            options = Options::Streams::ReadOptions.new(stream_name, options).request_options
+            options =
+              Options::Streams::ReadOptions.
+                new(stream_name, options, config: config).
+                request_options
             EventStore::Client::Streams::ReadReq::Options.new(options).tap do |opts|
               opts.subscription =
                 EventStore::Client::Streams::ReadReq::Options::SubscriptionOptions.new

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

@@ -7,18 +7,7 @@ require 'net/http'
 module EventStoreClient
   module GRPC
     class Connection
-      include Configuration
-      include Extensions::OptionsExtension
-
-      option(:host) { Discover.current_member.host }
-      option(:port) { Discover.current_member.port }
-      option(:username) { config.eventstore_url.username }
-      option(:password) { config.eventstore_url.password }
-      option(:timeout) { config.eventstore_url.timeout }
-
       class << self
-        include Configuration
-
         # Resolve which connection class we instantiate, based on config.eventstore_url.tls config
         # option. If :new method is called from SecureConnection or InsecureConnection class - then
         # that particular class will be instantiated despite on config.eventstore_url.tls config
@@ -35,13 +24,14 @@ module EventStoreClient
         #   Cluster::InsecureConnection.new
         #   # => #<EventStoreClient::GRPC::Cluster::InsecureConnection>
         #   ```
-        def new(*args, **kwargs, &blk)
+        # @param config [EventStoreClient::Config]
+        def new(config:, **options)
           return super unless self == Connection
 
           if config.eventstore_url.tls
-            Cluster::SecureConnection.new(*args, **kwargs, &blk)
+            Cluster::SecureConnection.new(config: config, **options)
           else
-            Cluster::InsecureConnection.new(*args, **kwargs, &blk)
+            Cluster::InsecureConnection.new(config: config, **options)
           end
         end
 
@@ -52,6 +42,22 @@ module EventStoreClient
         end
       end
 
+      include Extensions::OptionsExtension
+
+      option(:host) { Discover.current_member(config: config).host }
+      option(:port) { Discover.current_member(config: config).port }
+      option(:username) { config.eventstore_url.username }
+      option(:password) { config.eventstore_url.password }
+      option(:timeout) { config.eventstore_url.timeout }
+
+      attr_reader :config
+      private :config
+
+      def initialize(config:, **options)
+        @config = config
+        super
+      end
+
       def call(stub_class)
         raise NotImplementedError
       end

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

@@ -5,55 +5,75 @@
 module EventStoreClient
   module GRPC
     class Discover
-      include Configuration
-
       class << self
+        # @param config [EventStoreClient::Config]
         # @return [EventStoreClient::GRPC::Cluster::Member]
-        def current_member
-          @exception = nil
-          return @current_member if member_alive?
-
-          semaphore.synchronize do
-            raise @exception if @exception
-            return @current_member if member_alive?
-
-            failed_member = @current_member if @current_member&.failed_endpoint
-            @current_member =
-              begin
-                new.call(failed_member: failed_member)
-              rescue StandardError => e
-                @exception = e
-                nil
-              end
+        def current_member(config:)
+          @exception[config.name] = nil
+          return @current_member[config.name] if member_alive?(@current_member[config.name])
+
+          semaphore(config.name).synchronize do
+            current_member = @current_member[config.name]
+            raise @exception[config.name] if @exception[config.name]
+            return current_member if member_alive?(current_member)
+
+            failed_member = current_member&.failed_endpoint ? current_member : nil
+            begin
+              @current_member[config.name] = new(config: config).call(failed_member: failed_member)
+            rescue StandardError => e
+              @exception[config.name] = e
+              @current_member[config.name] = nil
+              raise
+            end
           end
-          raise @exception if @exception
 
-          @current_member
+          @current_member[config.name]
         end
 
+        # @param member [EventStoreClient::GRPC::Cluster::Member, nil]
         # @return [Boolean]
-        def member_alive?
-          return false if @current_member&.failed_endpoint
+        def member_alive?(member)
+          return false if member&.failed_endpoint
+
+          !member.nil?
+        end
 
-          !@current_member.nil?
+        # @return [void]
+        def init_default_discover_vars
+          @exception = {}
+          @current_member = {}
+          @semaphore = {}
         end
 
         private
 
+        # @param config_name [String, Symbol]
         # @return [Thread::Mutex]
-        def semaphore
-          @semaphore ||= Thread::Mutex.new
+        def semaphore(config_name)
+          @semaphore[config_name] ||= Thread::Mutex.new
         end
       end
 
+      init_default_discover_vars
+
+      attr_reader :config
+      private :config
+
+      # @param config [EventStoreClient::Config]
+      def initialize(config:)
+        @config = config
+      end
+
       # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
       # @return [EventStoreClient::GRPC::Cluster::Member]
       def call(failed_member: nil)
         if needs_discover?
-          return Cluster::GossipDiscover.new.call(nodes, failed_member: failed_member)
+          discovery =
+            Cluster::GossipDiscover.new(config: config).call(nodes, failed_member: failed_member)
+          return discovery
         end
 
-        Cluster::QuerylessDiscover.new.call(config.eventstore_url.nodes.to_a)
+        Cluster::QuerylessDiscover.new(config: config).call(config.eventstore_url.nodes.to_a)
       end
 
       private

data/lib/event_store_client/adapters/grpc/options/streams/read_options.rb

@@ -7,10 +7,8 @@ module EventStoreClient
     module Options
       module Streams
         class ReadOptions
-          include Configuration
-
-          attr_reader :options, :stream_name
-          private :options, :stream_name
+          attr_reader :options, :stream_name, :config
+          private :options, :stream_name, :config
 
           # @param stream_name [String]
           # @param options [Hash]
@@ -39,9 +37,11 @@ module EventStoreClient
           # @option [Hash] :filter see
           #   {EventStoreClient::GRPC::Shared::Options::FilterOptions#initialize} for available
           #   values
-          def initialize(stream_name, options)
+          # @param config [EventStoreClient::Config]
+          def initialize(stream_name, options, config:)
             @stream_name = stream_name
             @options = options
+            @config = config
           end
 
           # @return [Hash] see event_store.client.streams.ReadReq.Options for available options

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

@@ -6,7 +6,14 @@ module EventStoreClient
       module Streams
         class ProcessResponse
           include Dry::Monads[:result]
-          include Configuration
+
+          attr_reader :config
+          private :config
+
+          # @param config [EventStoreClient::Config]
+          def initialize(config:)
+            @config = config
+          end
 
           # @api private
           # @param response [EventStore::Client::Streams::ReadResp]

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

@@ -6,7 +6,14 @@ module EventStoreClient
       module Streams
         class ProcessResponses
           include Dry::Monads[:result]
-          include Configuration
+
+          attr_reader :config
+          private :config
+
+          # @param config [EventStoreClient::Config]
+          def initialize(config:)
+            @config = config
+          end
 
           # @api private
           # @param responses [Array<EventStore::Client::Streams::ReadResp>]

data/lib/event_store_client/config.rb

@@ -13,7 +13,7 @@ module EventStoreClient
 
     option(:eventstore_url) { 'esdb://localhost:2113' }
     option(:per_page) { 20 }
-    option(:mapper) { Mapper::Default.new }
+    option(:mapper) { Mapper::Default.new(config: self) }
     option(:default_event_class) { DeserializedEvent }
     option(:logger)
     option(:skip_deserialization) { false }
@@ -22,6 +22,7 @@ module EventStoreClient
     # of a Stub class of your request. More GRPC options can be found here
     # https://github.com/grpc/grpc/blob/master/include/grpc/impl/codegen/grpc_types.h
     option(:channel_args) # Hash
+    option(:name) { :default }
 
     def eventstore_url=(value)
       @eventstore_url =

data/lib/event_store_client/data_decryptor.rb

@@ -2,8 +2,6 @@
 
 module EventStoreClient
   class DataDecryptor
-    include Configuration
-
     KeyNotFoundError = Class.new(StandardError)
 
     def call

data/lib/event_store_client/mapper/default.rb

@@ -5,12 +5,14 @@
 module EventStoreClient
   module Mapper
     class Default
-      attr_reader :serializer
-      private :serializer
+      attr_reader :serializer, :config
+      private :serializer, :config
 
+      # @param config [EventStoreClient::Config]
       # @param serializer [#serialize, #deserialize]
-      def initialize(serializer: Serializer::Json)
+      def initialize(config:, serializer: Serializer::Json)
         @serializer = serializer
+        @config = config
       end
 
       # @param event [EventStoreClient::DeserializedEvent]
@@ -24,7 +26,9 @@ module EventStoreClient
       def deserialize(event_or_raw_event, **)
         return event_or_raw_event if event_or_raw_event.is_a?(EventStoreClient::DeserializedEvent)
 
-        Serializer::EventDeserializer.call(event_or_raw_event, serializer: serializer)
+        Serializer::EventDeserializer.call(
+          event_or_raw_event, config: config, serializer: serializer
+        )
       end
     end
   end

data/lib/event_store_client/mapper/encrypted.rb

@@ -8,20 +8,21 @@ require 'event_store_client/data_decryptor'
 
 module EventStoreClient
   module Mapper
-    ##
     # Transforms given event's data and encrypts/decrypts selected subset of data
     # based on encryption schema stored in the event itself.
     class Encrypted
       MissingEncryptionKey = Class.new(StandardError)
 
-      attr_reader :key_repository, :serializer
-      private :key_repository, :serializer
+      attr_reader :key_repository, :serializer, :config
+      private :key_repository, :serializer, :config
 
       # @param key_repository [#find, #create, #encrypt, #decrypt]
       #   See spec/support/dummy_repository.rb for the example of simple in-memory implementation
+      # @param config [EventStoreClient::Config]
       # @param serializer [#serialize, #deserialize]
-      def initialize(key_repository, serializer: Serializer::Json)
+      def initialize(key_repository, config:, serializer: Serializer::Json)
         @key_repository = key_repository
+        @config = config
         @serializer = serializer
       end
 
@@ -29,7 +30,7 @@ module EventStoreClient
       # @return [Hash]
       def serialize(event)
         # Links don't need to be encrypted
-        return Default.new(serializer: serializer).serialize(event) if event.link?
+        return Default.new(serializer: serializer, config: config).serialize(event) if event.link?
 
         serialized = Serializer::EventSerializer.call(event, serializer: serializer)
         encryption_schema =
@@ -54,14 +55,16 @@ module EventStoreClient
       # @return event [EventStoreClient::DeserializedEvent]
       def deserialize(event_or_raw_event, skip_decryption: false)
         if skip_decryption
-          return Default.new(serializer: serializer).deserialize(event_or_raw_event)
+          return Default.new(serializer: serializer, config: config).deserialize(event_or_raw_event)
         end
 
         event =
           if event_or_raw_event.is_a?(EventStoreClient::DeserializedEvent)
             event_or_raw_event
           else
-            Serializer::EventDeserializer.call(event_or_raw_event, serializer: serializer)
+            Serializer::EventDeserializer.call(
+              event_or_raw_event, config: config, serializer: serializer
+            )
           end
 
         decrypted_data =

data/lib/event_store_client/serializer/event_deserializer.rb

@@ -8,18 +8,20 @@ module EventStoreClient
       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]
         # @return [EventStoreClient::DeserializedEvent]
-        def call(raw_event, serializer: Serializer::Json)
-          new(serializer: serializer).call(raw_event)
+        def call(raw_event, config:, serializer: Serializer::Json)
+          new(config: config, serializer: serializer).call(raw_event)
         end
       end
 
-      attr_reader :serializer
-      private :serializer
+      attr_reader :serializer, :config
+      private :serializer, :config
 
       # @param serializer [#serialize, #deserialize]
-      def initialize(serializer:)
+      def initialize(serializer:, config:)
         @serializer = serializer
+        @config = config
       end
 
       # @param raw_event [EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent, EventStore::Client::PersistentSubscriptions::ReadResp::ReadEvent::RecordedEvent]
@@ -64,10 +66,6 @@ module EventStoreClient
 
         raw_data
       end
-
-      def config
-        EventStoreClient.config
-      end
     end
   end
 end

data/lib/event_store_client/version.rb

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

data/lib/event_store_client.rb

@@ -16,7 +16,6 @@ require 'event_store_client/connection/url_parser'
 require 'event_store_client/deserialized_event'
 require 'event_store_client/serialized_event'
 require 'event_store_client/config'
-require 'event_store_client/configuration'
 
 require 'event_store_client/mapper'
 
@@ -24,18 +23,44 @@ require 'event_store_client/adapters/grpc'
 
 module EventStoreClient
   class << self
-    def configure
-      yield(config) if block_given?
+    # @param name [Symbol, String]
+    def configure(name: :default)
+      yield(config(name)) if block_given?
     end
 
+    # @param name [Symbol, String]
     # @return [EventStore::Config]
-    def config
-      @config ||= Config.new
+    def config(name = :default)
+      @config[name] ||= Config.new(name: name)
     end
 
+    # @param config_name [Symbol, String]
     # @return [EventStore::GRPC::Client]
-    def client
-      GRPC::Client.new
+    def client(config_name: :default)
+      GRPC::Client.new(_config(config_name))
+    end
+
+    # @return [void]
+    def init_default_config
+      @config = { default: Config.new }
+    end
+
+    private
+
+    # @param config [Symbol, String]
+    # @return [EventStoreClient::Config]
+    # @raise [RuntimeError]
+    def _config(config)
+      return @config[config] if @config[config]
+
+      error_message = <<~TEXT
+        Could not find #{config.inspect} config. You can define it in next way:
+        EventStoreClient.configure(name: #{config.inspect}) do |config|
+          # your config goes here
+        end
+      TEXT
+      raise error_message
     end
   end
+  init_default_config
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_store_client
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0.pre.beta
 platform: ruby
 authors:
 - Sebastian Wilgosz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-05 00:00:00.000000000 Z
+date: 2022-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-monads
@@ -215,7 +215,6 @@ files:
 - lib/event_store_client/adapters/grpc/shared/streams/process_response.rb
 - lib/event_store_client/adapters/grpc/shared/streams/process_responses.rb
 - lib/event_store_client/config.rb
-- lib/event_store_client/configuration.rb
 - lib/event_store_client/connection/url.rb
 - lib/event_store_client/connection/url_parser.rb
 - lib/event_store_client/data_decryptor.rb
@@ -248,9 +247,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key: 

data/lib/event_store_client/configuration.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module Configuration
-    # @return [EventStoreClient::Config]
-    def config
-      EventStoreClient.config
-    end
-  end
-end