event_store_client 1.4.8 → 2.0.0

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    module Commands
-      module Streams
-        class Tombstone < Command
-          def call(stream_name, options: {}) # rubocop:disable Lint/UnusedMethodArgument
-            headers = { 'ES-HardDelete' => 'true' }
-            connection.call(:delete, "/streams/#{stream_name}", body: {}, headers: headers)
-            Success()
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-require 'event_store_client/adapters/http/request_method'
-
-module EventStoreClient
-  module HTTP
-    class Connection
-      include Configuration
-
-      def call(method_name, path, body: {}, headers: {})
-        method = RequestMethod.new(method_name)
-        connection.send(method.to_s, path) do |req|
-          req.headers = req.headers.merge(headers)
-          req.body = body.is_a?(String) ? body : body.to_json
-          req.params['embed'] = 'body' if method == :get
-        end
-      end
-
-      private
-
-      def initialize(uri, options = {})
-        @connection = set_connection(uri, options)
-      end
-
-      attr_reader :options, :connection
-
-      DEFAULT_HEADERS = {
-        'Content-Type' => 'application/vnd.eventstore.events+json'
-        # 'Accept' => 'application/vnd.eventstore.atom+json',
-      }.freeze
-
-      def set_connection(uri, connection_options)
-        Faraday.new(
-          {
-            url: uri.to_s,
-            headers: DEFAULT_HEADERS
-          }.merge(connection_options)
-        ) do |conn|
-          conn.basic_auth(config.eventstore_user, config.eventstore_password)
-          conn.adapter Faraday.default_adapter
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module HTTP
-    class RequestMethod
-      InvalidMethodError = Class.new(StandardError)
-      def ==(other)
-        name == other.to_s
-      end
-
-      def to_s
-        name
-      end
-
-      private
-
-      attr_reader :name
-
-      SUPPORTED_METHODS = %w[get post put delete].freeze
-
-      def initialize(name)
-        raise InvalidMethodError unless SUPPORTED_METHODS.include?(name.to_s)
-
-        @name = name.to_s
-      end
-    end
-  end
-end

data/lib/event_store_client/adapters/http.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'event_store_client/adapters/http/commands/command'
-
-require 'event_store_client/adapters/http/commands/persistent_subscriptions/create'
-require 'event_store_client/adapters/http/commands/persistent_subscriptions/read'
-
-require 'event_store_client/adapters/http/commands/projections/create'
-require 'event_store_client/adapters/http/commands/projections/update'
-
-require 'event_store_client/adapters/http/commands/streams/append'
-require 'event_store_client/adapters/http/commands/streams/delete'
-require 'event_store_client/adapters/http/commands/streams/link_to'
-require 'event_store_client/adapters/http/commands/streams/read'
-require 'event_store_client/adapters/http/commands/streams/tombstone'
-
-require 'event_store_client/adapters/http/client'

data/lib/event_store_client/adapters/in_memory.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/monads'
-
-module EventStoreClient
-  class InMemory
-    Response = Struct.new(:body, :status) do
-      def success?
-        status == 200
-      end
-    end
-
-    attr_reader :event_store
-
-    def append_to_stream(stream_name, events, options: {}) # rubocop:disable Lint/UnusedMethodArgument,Metrics/LineLength
-      event_store[stream_name] = [] unless event_store.key?(stream_name)
-      [events].flatten.each do |event|
-        event_store[stream_name].unshift(
-          'eventId' => event.id,
-          'data' => event.data,
-          'eventType' => event.type,
-          'metaData' => event.metadata,
-          'positionEventNumber' => event_store[stream_name].length
-        )
-      end
-      Dry::Monads::Success(events)
-    end
-
-    def delete_stream(stream_name, options: {}) # rubocop:disable Lint/UnusedMethodArgument
-      event_store.delete(stream_name)
-    end
-
-    def tombstone_stream(stream_name, options: {}) # rubocop:disable Lint/UnusedMethodArgument
-      event_store.delete(stream_name)
-    end
-
-    def read(stream_name, options: {})
-      start = options[:start] == 'head' ? options[:start] : options[:start].to_i
-      direction = options[:direction] || 'forward'
-      response =
-        if %w[forward forwards].include?(direction)
-          read_stream_forward(stream_name, start: start)
-        else
-          read_stream_backward(stream_name, start: start)
-        end
-
-      res = Response.new(response.to_json, 200)
-
-      return [] if res.body.nil? || res.body.empty?
-      skip_decryption = options[:skip_decryption] || false
-      events = JSON.parse(res.body)['entries'].map do |entry|
-        deserialize_event(entry, skip_decryption: skip_decryption)
-      end.reverse
-      Dry::Monads::Success(events)
-    end
-
-    def read_all_from_stream(stream_name, options: {})
-      read(stream_name, options: options)
-    end
-
-    def subscribe_to_stream(subscription, **)
-      # TODO: implement method body
-    end
-
-    def link_to(stream_name, events, **)
-      append_to_stream(stream_name, events)
-    end
-
-    def listen(subscription, options: {})
-      # TODO: implement method body
-    end
-
-    private
-
-    attr_reader :per_page, :mapper
-
-    def initialize(mapper:, per_page: 20)
-      @per_page = per_page
-      @mapper = mapper
-      @event_store = {}
-    end
-
-    def read_stream_backward(stream_name, start: 0)
-      response = {
-        'entries' => [],
-        'links' => []
-      }
-      return response unless event_store.key?(stream_name)
-
-      start = start == 'head' ? event_store[stream_name].length - 1 : start
-      last_index = (start - per_page)
-      response['entries'] = event_store[stream_name].select do |event|
-        event['positionEventNumber'] > last_index &&
-          event['positionEventNumber'] <= start
-      end
-      response['links'] = links(stream_name, last_index, 'next', response['entries'], per_page)
-
-      response
-    end
-
-    def read_stream_forward(stream_name, start: 0)
-      response = {
-        'entries' => [],
-        'links' => []
-      }
-
-      return response unless event_store.key?(stream_name)
-
-      last_index = start + per_page
-      response['entries'] = event_store[stream_name].select do |event|
-        event['positionEventNumber'] < last_index &&
-          event['positionEventNumber'] >= start
-      end
-      response['links'] =
-        links(stream_name, last_index, 'previous', response['entries'], per_page)
-
-      response
-    end
-
-    def links(stream_name, batch_size, direction, entries, count)
-      if entries.empty? || batch_size.negative?
-        []
-      else
-        [{
-          'uri' =>
-            "/streams/#{stream_name}/#{batch_size}/#{direction}/#{count}",
-          'relation' => direction
-        }]
-      end
-    end
-
-    def deserialize_event(entry, skip_decryption: false)
-      event = EventStoreClient::Event.new(
-        id: entry['eventId'],
-        title: entry['title'],
-        type: entry['eventType'],
-        data: entry['data'].to_json || '{}',
-        metadata: entry['isMetaData'] ? entry['metaData'] : '{}'
-      )
-
-      mapper.deserialize(event, skip_decryption: skip_decryption)
-    end
-  end
-end

data/lib/event_store_client/broker.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class Broker
-    include Configuration
-
-    # Distributes known subscriptions to multiple threads
-    # @param [EventStoreClient::Subscriptions]
-    # @param wait [Boolean] (Optional) Controls if broker should block
-    #   main app process (useful for debugging)
-    #
-    def call(subscriptions, wait: false)
-      Signal.trap('TERM') do
-        Thread.new { logger&.info('Broker: TERM Signal has been received') }
-        threads.each do |thread|
-          thread.thread_variable_set(:terminate, true)
-        end
-        Thread.new { logger&.info('Broker: Terminate variable for subscription threads set') }
-      end
-
-      subscriptions.each do |subscription|
-        threads << Thread.new do
-          subscriptions.listen(subscription)
-        end
-      end
-      threads.each(&:join) if wait
-    end
-
-    private
-
-    attr_reader :connection, :logger
-    attr_accessor :threads
-
-    def initialize(connection:)
-      @connection = connection
-      @threads = []
-      @logger = EventStoreClient.config.logger
-    end
-  end
-end

data/lib/event_store_client/catch_up_subscription.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class CatchUpSubscription
-    attr_reader :subscriber, :filter
-    attr_accessor :position
-
-    def options
-      {
-        filter: @filter,
-        without_system_events: @without_system_events,
-        all: {
-          position: {
-            commit_position: position[:commit_position],
-            prepare_position: position[:prepare_position]
-          }
-        }
-      }.compact
-    end
-
-    def name
-      self.class.name(subscriber)
-    end
-
-    def self.name(subscriber)
-      subscriber.class.to_s
-    end
-
-    private
-
-    def initialize(subscriber, filter: nil, position: nil)
-      @filter = filter
-      @subscriber = subscriber
-      @position = position
-      @position ||= {
-        commit_position: 0,
-        prepare_position: 0
-      }
-      @without_system_events = true
-    end
-  end
-end

data/lib/event_store_client/catch_up_subscriptions.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class CatchUpSubscriptions
-    FILTER_DEFAULT_MAX = 32
-    FILTER_DEFAULT_CHECKPOINT_INTERVAL_MULTIPLIER = 10000
-
-    include Configuration
-
-    def create_or_load(subscriber, filter: {})
-      filter_options = prepare_filter_options(filter)
-      position = subscription_store.load_all_position(CatchUpSubscription.name(subscriber))
-
-      subscription = CatchUpSubscription.new(subscriber, position: position, filter: filter_options)
-      subscription_store.add(subscription) unless position
-
-      subscriptions << subscription unless @subscriptions.find { |s| s.name == subscription.name }
-      subscription
-    end
-
-    def each
-      subscriptions.each { |subscription| yield(subscription) }
-    end
-
-    def listen(subscription)
-      connection.subscribe(subscription.options) do |event_data|
-        next if recorded_event?(event_data)
-        next if confirmation?(event_data)
-
-        new_position = event_data[0]
-        event = event_data[1]
-
-        old_position = subscription.position
-        subscription.position = new_position
-        subscription_store.update_position(subscription)
-        next unless event
-
-        subscription.subscriber.call(event)
-
-        if Thread.current.thread_variable_get(:terminate)
-          msg =
-            "CatchUpSubscriptions: Terminating subscription listener for #{subscription.subscriber}"
-          logger&.info(msg)
-          break
-        end
-      rescue StandardError => e
-        subscription.position = old_position
-        subscription_store.update_position(subscription)
-        config.error_handler&.call(e)
-      end
-    end
-
-    def clean_unused
-      subscription_store.clean_unused(subscriptions.map(&:name))
-    end
-
-    def reset
-      subscription_store.reset(subscriptions)
-    end
-
-    private
-
-    attr_reader :connection, :subscriptions, :subscription_store, :logger
-
-    def initialize(connection:, subscription_store:)
-      @connection = connection
-      @subscription_store = subscription_store
-      @subscriptions = []
-      @logger = EventStoreClient.config.logger
-    end
-
-    def confirmation?(event_data)
-      event_data.is_a? EventStore::Client::Streams::ReadResp::SubscriptionConfirmation
-    end
-
-    def recorded_event?(event_data)
-      event_data.is_a? EventStore::Client::Streams::ReadResp::ReadEvent::RecordedEvent
-    end
-
-    def prepare_filter_options(filter)
-      return if filter.nil? || filter.empty?
-
-      {
-        event_type: filter[:event_type],
-        stream_identifier: filter[:stream_identifier],
-        max: FILTER_DEFAULT_MAX,
-        checkpointIntervalMultiplier: FILTER_DEFAULT_CHECKPOINT_INTERVAL_MULTIPLIER
-      }.compact
-    end
-  end
-end

data/lib/event_store_client/client.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry-struct'
-
-module EventStoreClient
-  class Client
-    include Configuration
-
-    NoCallMethodOnSubscriber = Class.new(StandardError)
-    WrongExpectedEventVersion = Class.new(StandardError)
-
-    def publish(stream:, events:, options: {})
-      res = connection.append_to_stream(stream, events, options: options)
-      raise WrongExpectedEventVersion.new(res.failure) if res.failure?
-      res
-    end
-
-    def read(stream, options: {})
-      if options[:all]
-        connection.read_all_from_stream(stream, options: options)
-      else
-        connection.read(stream, options: options)
-      end
-    end
-
-    def subscribe(subscriber, to: [], options: {})
-      raise NoCallMethodOnSubscriber unless subscriber.respond_to?(:call)
-      @subscriptions.create(subscriber, to, options: options)
-    end
-
-    def subscribe_to_all(subscriber, filter=nil)
-      raise NoCallMethodOnSubscriber unless subscriber.respond_to?(:call)
-
-      @subscriptions.create_or_load(subscriber, filter: filter)
-    end
-
-    def reset_subscriptions
-      return unless @subscriptions.respond_to?(:reset)
-
-      @subscriptions.reset
-    end
-
-    def listen(wait: false)
-      broker.call(@subscriptions, wait: wait)
-    end
-
-    # rubocop:disable Metrics/CyclomaticComplexity
-    def link_to(stream:, events:, options: {})
-      raise ArgumentError if !stream || stream == ''
-      raise ArgumentError if events.nil? || (events.is_a?(Array) && events.empty?)
-      res = connection.link_to(stream, events, options: options)
-      raise WrongExpectedEventVersion.new(e.message) if res.failure?
-
-      res.success?
-    end
-    # rubocop:enable Metrics/CyclomaticComplexity
-
-    attr_accessor :connection
-
-    private
-
-    attr_reader :subscriptions, :broker, :error_handler
-
-    def initialize
-      @threads = []
-      @connection = EventStoreClient.adapter
-      @error_handler = config.error_handler
-      @broker = Broker.new(connection: connection)
-      @subscriptions = config.subscriptions_repo
-      @subscriptions ||= Subscriptions.new(connection: connection, service: config.service_name)
-    end
-  end
-end

data/lib/event_store_client/error_handler.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class ErrorHandler
-    def call(error)
-      puts error
-      puts error.backtrace
-    end
-  end
-end

data/lib/event_store_client/subscription.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class Subscription
-    attr_reader :stream, :subscriber, :name, :observed_streams
-
-    private
-
-    def initialize(subscriber, service:, event_types:)
-      subscriber_class =
-        if subscriber.class.name == 'Class'
-          subscriber.name
-        else
-          subscriber.class.name
-        end
-      @name = subscriber_class.to_s
-      @name = "#{service}-" + @name if service != ''
-      @subscriber = subscriber
-      @stream = name
-      @observed_streams = event_types.reduce([]) { |r, type| r << "$et-#{type}" }
-    end
-  end
-end

data/lib/event_store_client/subscriptions.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class Subscriptions
-    def create(subscriber, event_types, options: {})
-      subscription = Subscription.new(subscriber, event_types: event_types, service: service)
-
-      unless @subscriptions.detect { |sub| sub.name == subscription.name }
-        connection.subscribe_to_stream(subscription, options: options)
-        subscriptions << subscription
-      end
-
-      subscription
-    end
-
-    def each
-      subscriptions.each do |subscription|
-        yield(subscription)
-      end
-    end
-
-    def listen(subscription)
-      connection.listen(subscription, options: { interval: 1, count: 10 }) do |event|
-        subscription.subscriber.call(event)
-      end
-    end
-
-    private
-
-    attr_reader :connection, :subscriptions, :service
-
-    def initialize(connection:, service: 'default')
-      @connection = connection
-      @service = service
-      @subscriptions = []
-    end
-  end
-end

data/lib/event_store_client/value_objects/read_direction.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  class ReadDirection
-    Invalid = Class.new(StandardError)
-
-    def to_sym
-      value
-    end
-
-    def to_s
-      value.to_s
-    end
-
-    private
-
-    attr_reader :value
-
-    def initialize(str)
-      schema = Schema.new(direction: str)
-
-      unless %w[forwards backwards].include?(schema.direction)
-        raise Invalid.new('Allowed values: "forwards", "backwards"')
-      end
-
-      @value = schema.direction.capitalize.to_sym
-    end
-
-
-    class Schema < Dry::Struct
-      schema schema.strict
-
-      # resolve default types on nil
-      transform_types do |type|
-        type.constructor do |value|
-          value.is_a?(String) ? value.downcase : value
-        end
-      end
-
-      attribute :direction, Dry::Types['string']
-    end
-  end
-end