event_store_client 0.2.8 → 1.0.0

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    class Client
+      include Configuration
+      # Appends given events to the stream
+      # @param [String] Stream name to append events to
+      # @param [Array](each: EventStoreClient::DeserializedEvent) list of events to publish
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def append_to_stream(stream_name, events, options: {})
+        Commands::Streams::Append.new.call(
+          stream_name, events, options: {}
+        )
+      end
+
+      # Softly deletes the given stream
+      # @param [String] Stream name to delete
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def delete_stream(stream_name, options: {})
+        Commands::Streams::Delete.new.call(
+          stream_name, options: options
+        )
+      end
+
+      # Completely removes the given stream
+      # @param [String] Stream name to delete
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def tombstone_stream(stream_name, options: {})
+        Commands::Streams::Tombstone.new.call(stream_name, options: options)
+      end
+
+      # Reads a page of events from the given stream
+      # @param [String] Stream name to read events from
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success with returned events or Dry::Monads::Result::Failure
+      #
+      def read(stream_name, options: {})
+        Commands::Streams::Read.new.call(stream_name, options: options)
+      end
+
+      # Reads all events from the given stream
+      # @param [String] Stream name to read events from
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success with returned events or Dry::Monads::Result::Failure
+      #
+      def read_all_from_stream(stream_name, options: {})
+        Commands::Streams::ReadAll.new.call(stream_name, options: options)
+      end
+
+      # Creates the subscription for the given stream
+      # @param [EventStoreClient::Subscription] subscription to observe
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def subscribe_to_stream(subscription, options: {})
+        join_streams(subscription.name, subscription.observed_streams)
+        Commands::PersistentSubscriptions::Create.new.call(
+          subscription.stream,
+          subscription.name,
+          options: options
+        )
+      end
+
+      # Links given events with the given stream
+      # @param [String] Stream name to link events to
+      # @param [Array](each: EventStoreClient::DeserializedEvent) a list of events to link
+      # @param expected_version [Integer] expected number of events in the stream
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def link_to(stream_name, events, options: {})
+        Commands::Streams::LinkTo.new.call(stream_name, events, options: options)
+      end
+
+      # Runs the persistent subscription indeinitely
+      # @param [EventStoreClient::Subscription] subscription to observe
+      # @param options [Hash] additional options to the request
+      # @return - Nothing, it is a blocking operation, yields the given block with event instead
+      #
+      def listen(subscription, options: {})
+        consume_feed(subscription, options: options) do |event|
+          yield event if block_given?
+        end
+      rescue StandardError => e
+        config.error_handler&.call(e)
+      end
+
+      private
+
+      # Joins multiple streams into the new one under the given name
+      # @param [String] Name of the stream containing the ones to join
+      # @param [Array] (each: String) list of streams to join together
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def join_streams(name, streams)
+        Commands::Projections::Create.new.call(name, streams)
+      end
+
+      # @api private
+      # Consumes the new events from the subscription
+      # @param [EventStoreClient::Subscription] subscription to observe
+      # @param options [Hash] additional options to the request
+      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #
+      def consume_feed(subscription, options: {})
+        Commands::PersistentSubscriptions::Read.new.call(
+          subscription.stream, subscription.name, options: options
+        ) do |event|
+          yield event if block_given?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/connection'
+
+module EventStoreClient
+  module GRPC
+    class CommandRegistrar
+      @commands = {}
+
+      def self.register_request(command_klass, request:)
+        @commands[command_klass] ||= {}
+        @commands[command_klass][:request] = request
+      end
+
+      def self.register_service(command_klass, service:)
+        @commands[command_klass] ||= {}
+        @commands[command_klass][:service] = service
+      end
+
+      def self.request(command_klass)
+        @commands[command_klass][:request]
+      end
+
+      def self.service(command_klass)
+        EventStoreClient::GRPC::Connection.new.call(
+          @commands[command_klass][:service]
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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
+
+        def self.inherited(klass)
+          super
+          klass.class_eval do
+            include Dry::Monads[:result]
+
+            def self.use_request(request_klass)
+              CommandRegistrar.register_request(self, request: request_klass)
+            end
+
+            def self.use_service(service_klass)
+              CommandRegistrar.register_service(self, service: service_klass)
+            end
+
+            def request
+              CommandRegistrar.request(self.class)
+            end
+
+            def service
+              CommandRegistrar.service(self.class)
+            end
+          end
+        end
+
+        def metadata
+          credentials =
+            Base64.encode64("#{config.eventstore_user}:#{config.eventstore_password}")
+          { 'authorization' => "Basic #{credentials.delete("\n")}" }
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/commands/persistent_subscriptions/create.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/generated/persistent_pb.rb'
+require 'event_store_client/adapters/grpc/generated/persistent_services_pb.rb'
+
+require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/settings_schema'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module PersistentSubscriptions
+        class Create < Command
+          use_request EventStore::Client::PersistentSubscriptions::CreateReq
+          use_service EventStore::Client::PersistentSubscriptions::PersistentSubscriptions::Stub
+
+          # Creates persistent subscription in a given group
+          # @param [String] name of the stream to subscribe
+          # @param [String] name of the subscription group
+          # @param [Hash] options - additional settings to be set on subscription.
+          #   Refer to SettingsSchema for detailed attributes allowed
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          #
+          def call(stream, group, options: {})
+            schema = SettingsSchema.call(options)
+            return Failure(schema.errors) if schema.failure?
+            opts =
+              {
+                stream_identifier: {
+                  streamName: stream
+                },
+                group_name: group,
+                settings: schema.to_h
+              }
+
+            service.create(request.new(options: opts), metadata: metadata)
+            Success()
+          rescue ::GRPC::AlreadyExists
+            Failure(:conflict)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/generated/persistent_pb.rb'
+require 'event_store_client/adapters/grpc/generated/persistent_services_pb.rb'
+
+require 'event_store_client/adapters/grpc/commands/command'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module PersistentSubscriptions
+        class Delete < Command
+          use_request EventStore::Client::PersistentSubscriptions::DeleteReq
+          use_service EventStore::Client::PersistentSubscriptions::PersistentSubscriptions::Stub
+
+          def call(stream, group)
+            opts =
+              {
+                stream_identifier: {
+                  streamName: stream
+                },
+                group_name: group
+              }
+            service.delete(request.new(options: opts), metadata: metadata)
+            Success()
+          rescue ::GRPC::NotFound
+            Failure(:not_found)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/generated/persistent_pb.rb'
+require 'event_store_client/adapters/grpc/generated/persistent_services_pb.rb'
+
+require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/settings_schema'
+require 'irb'
+module EventStoreClient
+  module GRPC
+    module Commands
+      module PersistentSubscriptions
+        class Read < Command
+          use_request EventStore::Client::PersistentSubscriptions::ReadReq
+          use_service EventStore::Client::PersistentSubscriptions::PersistentSubscriptions::Stub
+
+          # Read given persistent subscription
+          # @param [String] name of the stream to subscribe
+          # @param [String] name of the subscription group
+          # @param [Hash] options - additional settings to be set on subscription.
+          #   Refer to SettingsSchema for detailed attributes allowed
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          #
+          def call(stream, group, options: {})
+            count = options[:count].to_i
+            opts =
+              {
+                stream_identifier: {
+                  streamName: stream
+                },
+                buffer_size: count,
+                group_name: group,
+                uuid_option: {
+                  structured: {}
+                }
+              }
+
+            requests = [request.new(options: opts)] # please notice that it's an array. Should be?
+
+            service.read(requests, metadata: metadata).each do |res|
+              next if res.subscription_confirmation
+              yield deserialize_event(res.event.event) if block_given?
+            end
+            Success()
+          end
+
+          private
+
+          def deserialize_event(entry)
+            binding.irb if event.data.include?('00735ff8-2d12-4bc7-8db2-af432baacdf1')
+            event = EventStoreClient::Event.new(
+              id: entry.id.string,
+              title: "#{entry.stream_revision}@#{entry.stream_identifier.streamName}",
+              type: entry.metadata['type'],
+              data: entry.data || '{}',
+              metadata: (entry.metadata.to_h || {}).to_json
+            )
+
+            config.mapper.deserialize(event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/commands/persistent_subscriptions/settings_schema.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/generated/persistent_pb.rb'
+require 'event_store_client/adapters/grpc/generated/persistent_services_pb.rb'
+
+require 'event_store_client/adapters/grpc/commands/command'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module PersistentSubscriptions
+        # Ensures the proper format of the parameters passed to the subscirption request
+        #
+        SettingsSchema = Dry::Schema.Params do
+          optional(:resolve_links).value(Dry::Types['bool'].default(true))
+          optional(:revision).value(Dry::Types['integer'])
+          optional(:extra_statistics).value(Dry::Types['bool'])
+          optional(:max_retry_count).value(Dry::Types['integer'])
+          optional(:min_checkpoint_count).value(Dry::Types['integer'])
+          optional(:max_checkpoint_count).value(Dry::Types['integer'])
+          optional(:max_subscriber_count).value(Dry::Types['integer'])
+          optional(:live_buffer_size).value(Dry::Types['integer'])
+          optional(:read_batch_size).value(Dry::Types['integer'])
+          optional(:history_buffer_size).value(Dry::Types['integer'].default(500))
+          optional(:message_timeout_ms).value(Dry::Types['integer'].default(10_000))
+          # optional(:message_timeout_ticks).value(Dry::Types['integer'].default(10000))
+
+          optional(:checkpoint_after_ms).value(Dry::Types['integer'].default(1000))
+          optional(:named_consumer_strategy).value(
+            Dry::Types['symbol'].default(:RoundRobin),
+            included_in?: %i[DispatchToSingle RoundRobin Pinned]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/commands/persistent_subscriptions/update.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'grpc'
+require 'event_store_client/adapters/grpc/generated/persistent_pb.rb'
+require 'event_store_client/adapters/grpc/generated/persistent_services_pb.rb'
+
+require 'event_store_client/adapters/grpc/commands/command'
+require 'event_store_client/adapters/grpc/commands/persistent_subscriptions/settings_schema'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module PersistentSubscriptions
+        class Update < Command
+          use_request EventStore::Client::PersistentSubscriptions::UpdateReq
+          use_service EventStore::Client::PersistentSubscriptions::PersistentSubscriptions::Stub
+
+          # Creates persistent subscription in a given group
+          # @param [String] name of the subscription stream to update
+          # @param [String] name of the subscription group
+          # @param [Hash] options - additional settings to be set on subscription.
+          #   Refer to EventStoreClient::GRPC::Commands::SettingsSchema
+          #   for detailed attributes schema
+          # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure]
+          #
+          def call(stream, group, options: {})
+            schema = SettingsSchema.call(options)
+            return Failure(schema.errors) if schema.failure?
+
+            opts =
+              {
+                stream_identifier: {
+                  streamName: stream
+                },
+                group_name: group,
+                settings: schema.to_h
+              }
+            service.update(request.new(options: opts), metadata: metadata)
+            Success()
+          rescue ::GRPC::Unknown => e
+            return Failure(:not_found) if e.message.include?('DoesNotExist')
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/commands/projections/create.rb

@@ -0,0 +1,45 @@
+# 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'
+
+module EventStoreClient
+  module GRPC
+    module Commands
+      module Projections
+        class Create < Command
+          use_request EventStore::Client::Projections::CreateReq
+          use_service EventStore::Client::Projections::Projections::Stub
+
+          def call(name, streams)
+            data = <<~STRING
+              fromStreams(#{streams})
+              .when({
+                $any: function(s,e) {
+                  linkTo("#{name}", e)
+                }
+              })
+            STRING
+
+            options =
+              {
+                query: data,
+                continuous: {
+                  name: name,
+                  track_emitted_streams: true
+                }
+              }
+
+            service.create(request.new(options: options), metadata: metadata)
+            Success()
+          rescue ::GRPC::Unknown => e
+            Failure(:conflict) if e.message.include?('Conflict')
+          end
+        end
+      end
+    end
+  end
+end