event_store_client 0.2.8 → 1.0.0

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

@@ -0,0 +1,57 @@
+# 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
+            body['entries'].map do |entry|
+              yield deserialize_event(entry)
+            end
+            Ack.new(connection).call(ack_info['uri'])
+            Success()
+          end
+
+          private
+
+          def deserialize_event(entry)
+            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)
+          rescue EventStoreClient::DeserializedEvent::InvalidDataError
+            event
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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
+
+            connection.call(
+              :post,
+              "/projections/continuous?name=#{name}&type=js&enabled=yes&emit=true&trackemittedstreams=true", # rubocop:disable Metrics/LineLength
+              body: data,
+              headers: {}
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,16 @@
+# 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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,53 @@
+# 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 = {
+              'ES-ResolveLinkTos' => options[:resolve_links].to_s,
+              'Accept' => 'application/vnd.eventstore.atom+json'
+            }
+
+            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?
+            entries = JSON.parse(response.body)['entries'].map do |entry|
+              deserialize_event(entry)
+            end.reverse
+            Success(entries)
+          rescue Faraday::ConnectionFailed
+            Failure(:connection_failed)
+          end
+
+          private
+
+          def deserialize_event(entry)
+            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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,28 @@
+# 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/in_memory.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+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
+    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?
+      JSON.parse(res.body)['entries'].map do |entry|
+        deserialize_event(entry)
+      end.reverse
+    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)
+      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)
+    end
+  end
+end