event_store_client 0.2.8 → 1.0.0

data/lib/event_store_client/store_adapter.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module StoreAdapter
-  end
-end
-
-require 'event_store_client/store_adapter/api/request_method'
-require 'event_store_client/store_adapter/api/connection'
-require 'event_store_client/store_adapter/api/client'

data/lib/event_store_client/store_adapter/api/client.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module StoreAdapter
-    module Api
-      class Client
-        WrongExpectedEventVersion = Class.new(StandardError)
-
-        def append_to_stream(stream_name, events, expected_version: nil)
-          serialized_events = events.map { |event| mapper.serialize(event) }
-          headers = {
-            'ES-ExpectedVersion' => expected_version&.to_s
-          }.reject { |_key, val| val.nil? || val.empty? }
-
-          data = build_events_data(serialized_events)
-          response = make_request(:post, "/streams/#{stream_name}", body: data, headers: headers)
-          validate_response(response, expected_version)
-          response
-          serialized_events
-        end
-
-        def delete_stream(stream_name, hard_delete: false)
-          headers = {
-            'ES-HardDelete' => hard_delete.to_s
-          }.reject { |_key, val| val.empty? }
-
-          make_request(:delete, "/streams/#{stream_name}", body: {}, headers: headers)
-        end
-
-        def read(stream_name, direction: 'forward', start: 0, count: per_page, resolve_links: true)
-          headers = {
-            'ES-ResolveLinkTos' => resolve_links.to_s,
-            'Accept' => 'application/vnd.eventstore.atom+json'
-          }
-
-          response = make_request(
-            :get,
-            "/streams/#{stream_name}/#{start}/#{direction}/#{count}",
-            headers: headers
-          )
-          return [] if response.body.nil? || response.body.empty?
-          JSON.parse(response.body)['entries'].map do |entry|
-            deserialize_event(entry)
-          end.reverse
-        end
-
-        def read_all_from_stream(stream, direction: 'forward', start: 0, resolve_links: true)
-          count = per_page
-          events = []
-          entries = []
-          failed_requests_count = 0
-
-          while failed_requests_count < 3
-            begin
-              entries =
-                read(stream, start: start, direction: direction, resolve_links: resolve_links)
-            rescue Faraday::ConnectionFailed
-              failed_requests_count += 1
-              next
-            end
-            failed_requests_count = 0
-            break if entries.empty?
-            events += entries.reverse
-            start += count
-          end
-          events
-        end
-
-        def join_streams(name, streams)
-          data = <<~STRING
-            fromStreams(#{streams})
-            .when({
-              $any: function(s,e) {
-                linkTo("#{name}", e)
-              }
-            })
-          STRING
-
-          make_request(
-            :post,
-            "/projections/continuous?name=#{name}&type=js&enabled=true&emit=true%26trackemittedstreams=true", # rubocop:disable Metrics/LineLength
-            body: data,
-            headers: {}
-          )
-        end
-
-        def subscribe_to_stream(
-          stream_name, subscription_name, stats: true, start_from: 0, retries: 5
-        )
-          make_request(
-            :put,
-            "/subscriptions/#{stream_name}/#{subscription_name}",
-            body: {
-              extraStatistics: stats,
-              startFrom: start_from,
-              maxRetryCount: retries,
-              resolveLinkTos: true
-            },
-            headers: {
-              'Content-Type' => 'application/json'
-            }
-          )
-        end
-
-        def consume_feed(
-          stream_name,
-          subscription_name,
-          count: 1,
-          long_poll: 0,
-          resolve_links: true,
-          per_page: 20
-        )
-          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'] = resolve_links.to_s
-
-          response = make_request(
-            :get,
-            "/subscriptions/#{stream_name}/#{subscription_name}/#{count}",
-            headers: headers
-          )
-
-          return { events: [] } if response.body || response.body.empty?
-
-          body = JSON.parse(response.body)
-
-          ack_info = body['links'].find { |link| link['relation'] == 'ackAll' }
-          return unless ack_info
-          ack_uri = ack_info['uri']
-          events = body['entries'].map do |entry|
-            deserialize_event(entry)
-          end
-          { ack_uri: ack_uri, events: events }
-        end
-
-        def link_to(stream_name, events, expected_version: nil)
-          data = build_linkig_data(events)
-          headers = {
-            'ES-ExpectedVersion' => expected_version&.to_s
-          }.reject { |_key, val| val.nil? || val.empty? }
-
-          response = make_request(
-            :post,
-            "/streams/#{stream_name}",
-            body: data,
-            headers: headers
-          )
-          validate_response(response, expected_version)
-          true
-        end
-
-        def ack(url)
-          make_request(:post, url)
-        end
-
-        private
-
-        attr_reader :uri, :per_page, :connection_options, :mapper
-
-        def initialize(uri, per_page: 20, mapper:, connection_options: {})
-          @uri = uri
-          @per_page = per_page
-          @mapper = mapper
-          @connection_options = connection_options
-        end
-
-        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 build_linkig_data(events)
-          [events].flatten.map do |event|
-            {
-              eventId: event.id,
-              eventType: '$>',
-              data: event.title,
-            }
-          end
-        end
-
-        def make_request(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
-
-        def connection
-          @connection ||= Api::Connection.new(uri, connection_options).call
-        end
-
-        def validate_response(resp, expected_version)
-          return unless resp.status == 400 && resp.reason_phrase == 'Wrong expected EventNumber'
-          raise WrongExpectedEventVersion.new(
-            "current version: #{resp.headers.fetch('es-currentversion')} | "\
-            "expected: #{expected_version}"
-          )
-        end
-
-        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'] : '{}'
-          )
-
-          mapper.deserialize(event)
-        end
-      end
-    end
-  end
-end

data/lib/event_store_client/store_adapter/api/connection.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'faraday'
-
-module EventStoreClient
-  module StoreAdapter
-    module Api
-      class Connection
-        def call
-          Faraday.new(
-            {
-              url: uri.to_s,
-              headers: DEFAULT_HEADERS
-            }.merge(options)
-          ) do |conn|
-            conn.basic_auth(config.eventstore_user, config.eventstore_password)
-            conn.adapter Faraday.default_adapter
-          end
-        end
-
-        private
-
-        def config
-          EventStoreClient.config
-        end
-
-        def initialize(uri, options = {})
-          @uri = uri
-          @options = options
-        end
-
-        attr_reader :uri, :options
-
-        DEFAULT_HEADERS = {
-          'Content-Type' => 'application/vnd.eventstore.events+json'
-          # 'Accept' => 'application/vnd.eventstore.atom+json',
-          # 'ES-EventType' => 'UserRegistered',
-          # 'ES-EventId' => SecureRandom.uuid
-        }.freeze
-      end
-    end
-  end
-end

data/lib/event_store_client/store_adapter/api/request_method.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module StoreAdapter
-    module Api
-      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
-end

data/lib/event_store_client/store_adapter/in_memory.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-module EventStoreClient
-  module StoreAdapter
-    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, expected_version: nil) # 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 read(stream_name, direction: 'forward', start: 0, resolve_links: nil)
-        response =
-          if direction == 'forward'
-            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, direction: 'forward', start: 0, resolve_links: true)
-        response =
-          if direction == 'forward'
-            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 subscribe_to_stream(stream_name, subscription_name, **)
-        # TODO: implement method body
-      end
-
-      def consume_feed(
-        stream_name,
-        subscription_name,
-        **
-      )
-        # TODO: implement method body
-      end
-
-      def delete_stream(stream_name, hard_delete: false) # rubocop:disable Lint/UnusedMethodArgument
-        event_store.delete(stream_name)
-      end
-
-      def link_to(stream_name, events, **)
-        append_to_stream(stream_name, events)
-        events
-      end
-
-      def ack(url)
-        # TODO: implement method body
-      end
-
-      def join_streams(name, streams); 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
-
-      private
-
-      def deserialize_event(entry)
-        data = (entry['data'].is_a?(Hash) ? entry['data'].to_json.presence : entry['data']) || '{}'
-        event = EventStoreClient::Event.new(
-          id: entry['eventId'],
-          title: entry['title'],
-          type: entry['eventType'],
-          data: data,
-          metadata: entry['isMetaData'] ? entry['metaData'] : '{}'
-        )
-
-        mapper.deserialize(event)
-      end
-    end
-  end
-end