event_store_client 1.4.9 → 2.0.1

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

@@ -1,44 +0,0 @@
-# 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 Update < Command
-          use_request EventStore::Client::Projections::UpdateReq
-          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,
-                name: name,
-                emit_enabled: true
-              }
-
-            service.update(request.new(options: options), metadata: metadata)
-
-            Success()
-          rescue ::GRPC::AlreadyExists
-            Failure(:conflict)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# 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/configuration'
-require 'event_store_client/adapters/grpc/commands/command'
-require 'event_store_client/adapters/grpc/commands/streams/read'
-
-module EventStoreClient
-  module GRPC
-    module Commands
-      module Streams
-        class ReadAll < Command
-          include Configuration
-
-          use_request EventStore::Client::Streams::ReadReq
-          use_service EventStore::Client::Streams::Streams::Stub
-
-          def call(stream_name, options: {})
-            start ||= options[:start] || 0
-            count ||= options[:count] || 20
-            events = []
-
-            loop do
-              res = Read.new.call(
-                stream_name, options: options.merge(start: start, count: count)
-              )
-              break if res.failure?
-              break if (entries = res.value!).empty?
-
-              events += entries
-              start += count
-            end
-
-            Success(events)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# 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 Streams
-        class Tombstone < Command
-          use_request EventStore::Client::Streams::TombstoneReq
-          use_service EventStore::Client::Streams::Streams::Stub
-
-          def call(name, options: {})
-            opts =
-              {
-                stream_identifier: {
-                  streamName: name
-                },
-                any: {}
-              }
-
-            service.tombstone(request.new(options: opts), metadata: metadata)
-            Success()
-          rescue ::GRPC::FailedPrecondition
-            Failure(:not_found)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/event_store_client/adapters/http/README.md

@@ -1,16 +0,0 @@
-### HTTP adapter
-
-This adapter targets the EventstoreDB version `>= "20.*"
-
-### Configuration
-
-As by default EventStoreClient uses gRPC adapter, to switch to http you need to configure it first.
-Place the snippet below in your initializer or when you boot your application.
-
-```ruby
-require 'event_store_client/adapters/http'
-
-EventStoreClient.configure do |config|
-  config.adapter = :http
-end
-```

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

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-require 'event_store_client/adapters/http/connection'
-require 'dry/monads/result'
-
-module EventStoreClient
-  module HTTP
-    class Client
-      include Configuration
-      include Dry::Monads[:result]
-      # 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(connection).call(
-          stream_name, events, options: 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(connection).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(connection).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(connection).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: {})
-        start ||= options[:start] || 0
-        count ||= options[:count] || 20
-        events = []
-        failed_requests_count = 0
-
-        while failed_requests_count < 3
-          res = read(stream_name, options: options.merge(start: start, count: count))
-          if res.failure?
-            failed_requests_count += 1
-          else
-            break if res.value!.empty?
-            events += res.value!
-            failed_requests_count = 0
-            start += count
-          end
-        end
-        return Failure(:connection_failed) if failed_requests_count >= 3
-
-        Success(events)
-      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(connection).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(connection).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: {})
-        loop do
-          begin
-            consume_feed(subscription) do |event|
-              yield event if block_given?
-            end
-          rescue StandardError => e
-            config.error_handler&.call(e)
-          end
-          sleep(options[:interval] || 5) # wait for events to be processed
-        end
-      end
-
-      private
-
-      attr_reader :connection
-
-      def initialize
-        @connection =
-          Connection.new(config.eventstore_url, ssl: { verify: config.verify_ssl })
-      end
-
-      # @api 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, options: {})
-        res = Commands::Projections::Create.new(connection).call(name, streams, options: options)
-        return res if res.success?
-
-        Commands::Projections::Update.new(connection).call(name, streams, options: options)
-      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(connection).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/http/commands/command.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-monads'
-require 'event_store_client/adapters/grpc/command_registrar'
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      class Command
-        def self.inherited(klass)
-          super
-          klass.class_eval do
-            include Dry::Monads[:result]
-          end
-        end
-
-        protected
-
-        attr_reader :connection
-
-        def initialize(connection)
-          @connection = connection
-        end
-      end
-    end
-  end
-end

data/lib/event_store_client/adapters/http/commands/persistent_subscriptions/ack.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module PersistentSubscriptions
-        class Ack < Command
-          def call(url)
-            connection.call(:post, url)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module PersistentSubscriptions
-        class Create < Command
-          def call(stream_name, subscription_name, options: {})
-            stats = options[:stats] || true
-            start = options[:start] || 0
-            retries = options[:retries] || 5
-            max_checkpoint_count = options[:max_checkpoint_count] || 0
-            min_checkpoint_count = options[:min_checkpoint_count] || 0
-
-            connection.call(
-              :put,
-              "/subscriptions/#{stream_name}/#{subscription_name}",
-              body: {
-                extraStatistics: stats,
-                startFrom: start,
-                maxRetryCount: retries,
-                maxCheckPointCount: max_checkpoint_count,
-                minCheckPointCount: min_checkpoint_count,
-                resolveLinkTos: true
-              },
-              headers: {
-                'Content-Type' => 'application/json'
-              }
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require 'event_store_client/adapters/http/commands/persistent_subscriptions/ack'
-module EventStoreClient
-  module HTTP
-    module Commands
-      module PersistentSubscriptions
-        class Read < Command
-          include Configuration
-
-          def call(stream_name, subscription_name, options: {})
-            count = options[:count] || 20
-            long_poll = options[:long_poll].to_i
-            headers = long_poll.positive? ? { 'ES-LongPoll' => long_poll.to_s } : {}
-            headers['Content-Type'] = 'application/vnd.eventstore.competingatom+json'
-            headers['Accept'] = 'application/vnd.eventstore.competingatom+json'
-            headers['ES-ResolveLinktos'] = (options[:resolve_links] || true).to_s
-
-            response = connection.call(
-              :get,
-              "/subscriptions/#{stream_name}/#{subscription_name}/#{count}",
-              headers: headers
-            )
-
-            return { events: [] } if response.body.nil? || response.body.empty?
-
-            body = JSON.parse(response.body)
-
-            ack_info = body['links'].find { |link| link['relation'] == 'ackAll' }
-            return { events: [] } unless ack_info
-
-            skip_decryption = options[:skip_decryption] || false
-            body['entries'].map do |entry|
-              yield deserialize_event(entry, skip_decryption: skip_decryption)
-            end
-
-            Ack.new(connection).call(ack_info['uri'])
-            Success()
-          end
-
-          private
-
-          def deserialize_event(entry, skip_decryption: false)
-            event = EventStoreClient::Event.new(
-              id: entry['eventId'],
-              title: entry['title'],
-              type: entry['eventType'],
-              data: entry['data'] || '{}',
-              metadata: entry['isMetaData'] ? entry['metaData'] : '{}'
-            )
-
-            config.mapper.deserialize(event, skip_decryption: skip_decryption)
-          rescue EventStoreClient::DeserializedEvent::InvalidDataError
-            event
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Projections
-        class Create < Command
-          def call(name, streams, options: {})
-            data =
-              <<~STRING
-                fromStreams(#{streams})
-                .when({
-                  $any: function(s,e) {
-                    linkTo("#{name}", e)
-                  }
-                })
-              STRING
-
-
-            res = connection.call(
-              :post,
-              "/projections/continuous?name=#{name}&type=js&enabled=yes&emit=true&trackemittedstreams=true", # rubocop:disable Metrics/LineLength
-              body: data,
-              headers: {}
-            )
-
-            (200...300).cover?(res.status) ? Success() : Failure(res)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/event_store_client/adapters/http/commands/projections/update.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Projections
-        class Update < Command
-          def call(name, streams, options: {})
-            data =
-              <<~STRING
-                fromStreams(#{streams})
-                .when({
-                  $any: function(s,e) {
-                    linkTo("#{name}", e)
-                  }
-                })
-              STRING
-            res = connection.call(
-              :put,
-              "/projection/#{name}/query?type=js&enabled=yes&emit=true&trackemittedstreams=true", # rubocop:disable Metrics/LineLength
-              body: data,
-              headers: {}
-            )
-
-            (200...300).cover?(res.status) ? Success() : Failure(res)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Streams
-        class Append < Command
-          include Configuration
-
-          def call(stream_name, events, options: {})
-            expected_version = options[:expected_version]
-            serialized_events = events.map { |event| config.mapper.serialize(event) }
-            headers = {
-              'ES-ExpectedVersion' => expected_version&.to_s
-            }.reject { |_key, val| val.nil? || val.empty? }
-
-            data = build_events_data(serialized_events)
-            response =
-              connection.call(:post, "/streams/#{stream_name}", body: data, headers: headers)
-            validate_response(response, expected_version)
-          end
-
-          private
-
-          def build_events_data(events)
-            [events].flatten.map do |event|
-              {
-                eventId: event.id,
-                eventType: event.type,
-                data: event.data,
-                metadata: event.metadata
-              }
-            end
-          end
-
-          def validate_response(resp, expected_version)
-            wrong_version = resp.status == 400 && resp.reason_phrase == 'Wrong expected EventNumber'
-            return Success() unless wrong_version
-
-            Failure(
-              "current version: #{resp.headers.fetch('es-currentversion')} | "\
-              "expected: #{expected_version}"
-            )
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Streams
-        class Delete < Command
-          def call(stream_name, options: {}) # rubocop:disable Lint/UnusedMethodArgument
-            connection.call(:delete, "/streams/#{stream_name}", body: {})
-            Success()
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Streams
-        class LinkTo < Command
-          def call(stream_name, events, options: {})
-            expected_version = options[:expected_version]
-            data = build_linking_data(events)
-            headers = {
-              'ES-ExpectedVersion' => expected_version&.to_s
-            }.reject { |_key, val| val.nil? || val.empty? }
-
-            response = connection.call(
-              :post,
-              "/streams/#{stream_name}",
-              body: data,
-              headers: headers
-            )
-            validate_response(response, expected_version)
-          end
-
-          private
-
-          def validate_response(resp, expected_version)
-            wrong_version = resp.status == 400 && resp.reason_phrase == 'Wrong expected EventNumber'
-            return Success() unless wrong_version
-
-            Failure(
-              "current version: #{resp.headers.fetch('es-currentversion')} | "\
-              "expected: #{expected_version}"
-            )
-          end
-
-          def build_linking_data(events)
-            [events].flatten.map do |event|
-              {
-                eventId: event.id,
-                eventType: '$>',
-                data: event.title
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Streams
-        class Read < Command
-          include Configuration
-
-          def call(stream_name, options: {})
-            count = options[:count] || config.per_page
-            start = options[:start].to_i
-            direction = options[:direction] || 'forward'
-            headers = { 'Accept' => 'application/vnd.eventstore.atom+json' }
-            headers['ES-ResolveLinkTos'] = true if options.key?(:resolve_links)
-
-            response =
-              connection.call(
-                :get,
-                "/streams/#{stream_name}/#{start}/#{direction}/#{count}",
-                headers: headers
-              )
-
-            return Failure(:stream_not_found) unless response.success? || response.status == 404
-            return Failure(:connection_failed) if response.body.nil? || response.body.empty?
-            skip_decryption = options[:skip_decryption] || false
-            entries = JSON.parse(response.body)['entries'].map do |entry|
-              deserialize_event(entry, skip_decryption: skip_decryption)
-            end.reverse
-            Success(entries)
-          rescue Faraday::ConnectionFailed
-            Failure(:connection_failed)
-          end
-
-          private
-
-          def deserialize_event(entry, skip_decryption: false)
-            event = EventStoreClient::Event.new(
-              id: entry['eventId'],
-              title: entry['title'],
-              type: entry['eventType'],
-              data: entry['data'] || '{}',
-              metadata: entry['isMetaData'] ? entry['metaData'] : '{}'
-            )
-
-            config.mapper.deserialize(event, skip_decryption: skip_decryption)
-          end
-        end
-      end
-    end
-  end
-end