event_store_client 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3deeba909c8bf46f05e7994ae5ebef841e622c17032f0259387871335f80e98
-  data.tar.gz: 0bc3e13528fa696506b3d34ca2b00004a736f30bb62d379f41ef50e4a2b180ab
+  metadata.gz: 7d057f39fbb77d08d7c29b5f56e38e3aee78d6b39578e472afc736ad5bbd9576
+  data.tar.gz: 3fa3ce102d2f8f6866bef59760e76fe21038ded6b1f022e78c79918753d6911b
 SHA512:
-  metadata.gz: 2606efc97b2695dc52d358a9c0bc967d0583c2b58b95b27289c6f9e4dbac04a87bb134dfc8a1e0b251ca11b08c5f0c28841c25f48fdbd4a33db2dd37a0369727
-  data.tar.gz: f1b690148757d9f316127b272c03d70558fc53a8868dbf0058d7669bcdd702b92849d44002dd6eb2367982525fdf25299931d8c8563c5c7ed7d3527f24d9ddc3
+  metadata.gz: 91d278acb0560b2b1e5166a7ef0ecdbd398f9da524dd550edc496ddc41efeb260a056a43e6e4acde752e100321fef9d6120d2eeb50047072c428f374d504a309
+  data.tar.gz: f8e821b0ff1ca1f74bcc9252d31d83f84af2722c596651ca96e923ad701b13a2a97f7537fe57b86ac97a15790987bd762507b61eb707a8c70211e9ae11c54613

data/README.md

@@ -50,29 +50,20 @@ Before you start, add this to the `initializer` or to the top of your script:
 To test out the behavior, you'll need a sample event and handler to work with:
 
 ```ruby
-# Sample Event using dry-struct (recommended)
-require 'dry-struct'
-class SomethingHappened < Dry::Struct
-  attribute :data, EventStoreClient::Types::Strict::Hash
-  attribute :metadata, EventStoreClient::Types::Strict::Hash
-end
-
-# Sample Event without types check (not recommended)
-
-class SomethingHappened < Dry::Struct
-  attr_reader :data, :metadata
 
-  private
+require 'securerandom'
 
-  def initialize(data: {}, metadata: {})
-    @data = data
-    @metadata = metadata
+class SomethingHappened < EventStoreClient::DeserializedEvent
+  def schema
+    Dry::Schema.Params do
+      required(:user_id).value(:string)
+      required(:title).value(:string)
+    end
   end
 end
 
 event = SomethingHappened.new(
   data: { user_id: SecureRandom.uuid, title: "Something happened" },
-  metadata: {}
 )
 ```
 
@@ -113,8 +104,6 @@ events = client.read('newstream', direction: 'backward') #default 'forward'
 
 ### Subscribing to events
 
-# Using automatic pooling
-
 ```ruby
 client.subscribe(DummyHandler, to: [SomethingHappened])
 
@@ -129,12 +118,25 @@ client.publish(stream: 'newstream', events: events)
 # .... wait a little bit ... Your handler should be called for every single event you publish
 ```
 
-### Stop pooling
+### Stop polling for new events
+
+```ruby
+client.stop_polling
+```
+
+### Linking existing events to the streem
+
+Event to be linked properly has to coantians original event id.
+Real events could be mixed with linked events in the same stream.
 
 ```ruby
-client.stop_pooling
+exisiting_event1 = client.read('newstream').last
+client.link_to(stream: 'anotherstream', events: [exisiting_event1, ...])
 ```
 
+When you read from stream where links are placed. By default Event Store Client always resolve links for you returning the event that points to the link. You can use the ES-ResolveLinkTos: false HTTP header during readin stream to tell Event Store Client to return you the actual link and to not resolve it.
+More info: [ES-ResolveLinkTos](https://eventstore.org/docs/http-api/optional-http-headers/resolve-linkto/index.html?tabs=tabid-1%2Ctabid-3).
+
 ## Contributing
 
 Do you want to contribute? Welcome!

data/lib/event_store_client.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
 module EventStoreClient
+  def self.configure(&block)
+    config = Configuration.instance
+    config.configure(&block)
+  end
 end
 
 require 'event_store_client/configuration'
 require 'event_store_client/types'
 require 'event_store_client/event'
+require 'event_store_client/deserialized_event'
 
 require 'event_store_client/serializer/json'
 

data/lib/event_store_client/client.rb

@@ -10,55 +10,64 @@ module EventStoreClient
       connection.publish(stream: stream, events: events, expected_version: expected_version)
     end
 
-    def read(stream, direction: 'forward')
-      connection.read(stream, direction: direction)
+    def read(stream, direction: 'forward', start: 0, all: false)
+      connection.read(stream, direction: direction, start: start, all: all)
     end
 
-    def subscribe(subscriber, to: [], pooling: true)
+    def subscribe(subscriber, to: [], polling: true)
       raise NoCallMethodOnSubscriber unless subscriber.respond_to?(:call)
       @subscriptions.create(subscriber, to)
-      pool if pooling
+      poll if polling
     end
 
-    def pool(interval: 5)
-      return if @pooling_started
-      @pooling_started = true
+    def poll(interval: 5)
+      return if @polling_started
+      @polling_started = true
       thread1 = Thread.new do
         loop do
           create_pid_file
-          Thread.handle_interrupt(Interrupt => :never) {
-            begin
-              Thread.handle_interrupt(Interrupt => :immediate) {
+          Thread.handle_interrupt(Interrupt => :never) do
+            begin # rubocop:disable Style/RedundantBegin
+              Thread.handle_interrupt(Interrupt => :immediate) do
                 broker.call(subscriptions)
-              }
-            rescue Exception => e
+              end
+            rescue Exception => e # rubocop:disable Lint/RescueException
               # When the thread had been interrupted or broker.call returned an error
               sleep(interval) # wait for events to be processed
               delete_pid_file
-              error_handler.call(e) if error_handler
+              error_handler&.call(e)
             ensure
               # this code is run always
               Thread.stop
             end
-          }
+          end
         end
       end
       thread2 = Thread.new do
-        loop { sleep 1; break unless thread1.alive?; thread1.run }
+        loop do
+          sleep 1
+          break unless thread1.alive?
+          thread1.run
+        end
       end
       @threads = [thread1, thread2]
       nil
     end
 
-    def stop_pooling
+    def stop_polling
       return if @threads.none?
-      @threads.each do |thread|
-        thread.kill
-      end
-      @pooling_started = false
+      @threads.each(&:kill)
+      @polling_started = false
       nil
     end
 
+    def link_to(stream:, events:)
+      raise ArgumentError if !stream || stream == ''
+      raise ArgumentError if events.nil? || (events.is_a?(Array) && events.empty?)
+
+      connection.link_to(stream, events)
+    end
+
     attr_accessor :connection, :service_name
 
     private
@@ -79,12 +88,12 @@ module EventStoreClient
     end
 
     def create_pid_file
-      return unless File.exists?(config.pid_path)
-      File.open(config.pid_path, 'w') { |file| file.write(SecureRandom.uuid) }
+      Dir.mkdir('tmp') unless File.exist?('tmp')
+      File.open(config.pid_path, 'w') { |file| file.write(Process.pid) }
     end
 
     def delete_pid_file
-      File.delete(config.pid_path)
+      File.delete(config.pid_path) if File.exist?(config.pid_path)
     end
   end
 end

data/lib/event_store_client/configuration.rb

@@ -19,7 +19,7 @@ module EventStoreClient
       @host = 'http://localhost'
       @port = 2113
       @per_page = 20
-      @pid_path = 'tmp/pool.pid'
+      @pid_path = 'tmp/poll.pid'
       @mapper = Mapper::Default.new
       @service_name = 'default'
       @error_handler = nil

data/lib/event_store_client/connection.rb

@@ -10,19 +10,11 @@ module EventStoreClient
       serialized_events
     end
 
-    def read(stream, direction: 'forward')
-      response =
-        client.read(stream, start: 0, direction: direction)
-      return [] unless response.body&.present?
-      JSON.parse(response.body)['entries'].map do |entry|
-        event = EventStoreClient::Event.new(
-          id: entry['eventId'],
-          type: entry['eventType'],
-          data: entry['data'],
-          metadata: entry['metaData']
-        )
-        mapper.deserialize(event)
-      end
+    def read(stream, direction:, start:, all:, resolve_links: true)
+      return read_all_from_stream(stream, start: start, resolve_links: resolve_links) if all
+      read_from_stream(
+        stream, direction: direction, start: start, resolve_links: resolve_links
+      )
     end
 
     def delete_stream(stream); end
@@ -51,6 +43,12 @@ module EventStoreClient
       events
     end
 
+    def link_to(stream, events)
+      client.link_to(stream, events)
+
+      true
+    end
+
     private
 
     attr_reader :host, :port, :mapper, :per_page
@@ -72,5 +70,51 @@ module EventStoreClient
           host: host, port: port, per_page: per_page
         )
     end
+
+    def read_from_stream(stream, direction:, start:, resolve_links:)
+      response =
+        client.read(
+          stream, start: start, direction: direction, resolve_links: resolve_links
+        )
+      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, start:, resolve_links:)
+      count = per_page
+      events = []
+      failed_requests_count = 0
+
+      while failed_requests_count < 3
+        begin
+          response =
+            client.read(stream, start: start, direction: 'forward', resolve_links: resolve_links)
+          failed_requests_count += 1 && next unless response.success?
+        rescue Faraday::ConnectionFailed
+          failed_requests_count += 1
+          next
+        end
+        failed_requests_count = 0
+        break if response.body.nil? || response.body.empty?
+        entries = JSON.parse(response.body)['entries']
+        break if entries.empty?
+        events += entries.map { |entry| deserialize_event(entry) }.reverse
+        start += count
+      end
+      events
+    end
+
+    def deserialize_event(entry)
+      event = EventStoreClient::Event.new(
+        id: entry['eventId'],
+        title: entry['title'],
+        type: entry['eventType'],
+        data: entry['data'],
+        metadata: entry['metaData']
+      )
+      mapper.deserialize(event)
+    end
   end
 end

data/lib/event_store_client/deserialized_event.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry/schema'
+
+module EventStoreClient
+  class DeserializedEvent
+    InvalidDataError = Class.new(StandardError)
+
+    attr_reader :id
+    attr_reader :type
+    attr_reader :title
+    attr_reader :data
+    attr_reader :metadata
+
+    def schema
+      Dry::Schema.Params do
+      end
+    end
+
+    def initialize(**args)
+      validation = schema.call(args[:data] || {})
+      raise InvalidDataError.new(message: validation.errors.to_h) if validation.errors.any?
+
+      @data = args.fetch(:data) { {} }
+      @metadata = args.fetch(:metadata) { {} }
+      @type = args[:type] || self.class.name
+      @title = args[:title]
+      @id = args[:id]
+    end
+  end
+end

data/lib/event_store_client/endpoint.rb

@@ -4,13 +4,11 @@ require 'dry-struct'
 
 module EventStoreClient
   class Endpoint < Dry::Struct
+    attribute :host, Types::String
+    attribute :port, Types::Coercible::Integer
+
     def url
       "#{host}:#{port}"
     end
-
-    private
-
-    attribute :host, Types::String
-    attribute :port, Types::Coercible::Integer
   end
 end

data/lib/event_store_client/event.rb

@@ -8,16 +8,17 @@ module EventStoreClient
   class Event < Dry::Struct
     attr_reader :id
 
+    attribute :type, Types::Strict::String
+    attribute :title, Types::Strict::String.optional.default(nil)
     attribute :data, Types::Strict::String.default('{}')
     attribute :metadata, Types::Strict::String.default('{}')
-    attribute :type, Types::Strict::String
 
     private
 
     def initialize(**args)
       @id = SecureRandom.uuid
-      hash_meta =
-        JSON.parse(args[:metadata] || '{}').merge(created_at: Time.now)
+      hash_meta = JSON.parse(args[:metadata] || '{}')
+      hash_meta['created_at'] ||= Time.now
       args[:metadata] = JSON.generate(hash_meta)
       super(args)
     end

data/lib/event_store_client/mapper/default.rb

@@ -5,9 +5,9 @@ module EventStoreClient
     class Default
       def serialize(event)
         Event.new(
-          metadata: serializer.serialize(event.metadata),
+          type: event.class.to_s,
           data: serializer.serialize(event.data),
-          type: event.class.to_s
+          metadata: serializer.serialize(event.metadata)
         )
       end
 
@@ -15,9 +15,19 @@ module EventStoreClient
         metadata = serializer.deserialize(event.metadata)
         data = serializer.deserialize(event.data)
 
-        Object.const_get(event.type).new(
-          metadata: metadata,
-          data: data
+        event_class =
+          begin
+            Object.const_get(event.type)
+          rescue NameError
+            EventStoreClient::DeserializedEvent
+          end
+
+        event_class.new(
+          id: event.id,
+          type: event.type,
+          title: event.title,
+          data: data,
+          metadata: metadata
         )
       end
 

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

@@ -9,25 +9,30 @@ module EventStoreClient
             'ES-ExpectedVersion' => expected_version.to_s
           }.reject { |_key, val| val.empty? }
 
-          data = [events].flatten.map do |event|
-            {
-              eventId: event.id,
-              eventType: event.type,
-              data: event.data,
-              metadata: event.metadata
-            }
-          end
+          data = build_events_data(events)
 
           make_request(:post, "/streams/#{stream_name}", body: data, headers: headers)
         end
 
         def delete_stream(stream_name, hard_delete)
-          headers = JSON_HEADERS.merge('ES-HardDelete' => hard_delete.to_s)
-          make_request(:delete, "/streams/#{stream_name}", {}, headers)
+          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)
-          make_request(:get, "/streams/#{stream_name}/#{start}/#{direction}/#{count}")
+        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'
+          }
+
+          make_request(
+            :get,
+            "/streams/#{stream_name}/#{start}/#{direction}/#{count}",
+            headers: headers
+          )
         end
 
         def subscribe_to_stream(
@@ -43,7 +48,7 @@ module EventStoreClient
               resolveLinkTos: true
             },
             headers: {
-              "Content-Type" => "application/json"
+              'Content-Type' => 'application/json'
             }
           )
         end
@@ -51,20 +56,29 @@ module EventStoreClient
         def consume_feed(
           stream_name,
           subscription_name,
-          start: 0,
           count: 1,
-          long_pool: 0
+          long_poll: 0
         )
-          headers = long_pool > 0 ? { "ES-LongPoll" => "#{long_pool}" } : {}
+          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'
           make_request(
-          :get,
+            :get,
             "/subscriptions/#{stream_name}/#{subscription_name}/#{count}",
             headers: headers
           )
         end
 
+        def link_to(stream_name, events)
+          data = build_linkig_data(events)
+
+          make_request(
+            :post,
+            "/streams/#{stream_name}",
+            body: data
+          )
+        end
+
         def ack(url)
           make_request(:post, url)
         end
@@ -78,6 +92,27 @@ module EventStoreClient
           @per_page = per_page
         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|

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

@@ -17,13 +17,13 @@ module EventStoreClient
 
         attr_reader :name
 
+        SUPPORTED_METHODS = %w[get post put delete].freeze
+
         def initialize(name)
-          raise InvalidMethodError unless name.to_s.in?(SUPPORTED_METHODS)
+          raise InvalidMethodError unless SUPPORTED_METHODS.include?(name.to_s)
 
           @name = name.to_s
         end
-
-        SUPPORTED_METHODS = %w[get post put].freeze
       end
     end
   end

data/lib/event_store_client/store_adapter/in_memory.rb

@@ -3,9 +3,15 @@
 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)
+      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|
@@ -13,61 +19,77 @@ module EventStoreClient
             'eventId' => event.id,
             'data' => event.data,
             'eventType' => event.type,
-            'metadata' => event.metadata,
+            'metaData' => event.metadata,
             'positionEventNumber' => event_store[stream_name].length
           )
         end
       end
 
-      def delete_stream(stream_name, hard_delete: false)
+      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
+
+        Response.new(response.to_json, 200)
+      end
+
+      def delete_stream(stream_name, hard_delete: false) # rubocop:disable Lint/UnusedMethodArgument
         event_store.delete(stream_name)
       end
 
-      def read_stream_backward(stream_name, start: 0, count: per_page)
+      def link_to(stream_name, events)
+        append_to_stream(stream_name, events)
+      end
+
+      private
+
+      attr_reader :endpoint, :per_page
+
+      def initialize(host:, port:, per_page: 20)
+        @endpoint = Endpoint.new(host: host, port: port)
+        @per_page = per_page
+        @event_store = {}
+      end
+
+      def read_stream_backward(stream_name, start: 0)
         return [] unless event_store.key?(stream_name)
 
-        start = start == 0 ? event_store[stream_name].length - 1 : start
-        last_index = start - count
+        start = start == 'head' ? event_store[stream_name].length - 1 : start
+        last_index = start - per_page
         entries = event_store[stream_name].select do |event|
           event['positionEventNumber'] > last_index &&
             event['positionEventNumber'] <= start
         end
         {
           'entries' => entries,
-          'links' => links(stream_name, last_index, 'next', entries, count)
+          'links' => links(stream_name, last_index, 'next', entries, per_page)
         }
       end
 
-      def read_stream_forward(stream_name, start: 0, count: per_page)
+      def read_stream_forward(stream_name, start: 0)
         return [] unless event_store.key?(stream_name)
 
-        last_index = start + count
-        entries = event_store[stream_name].reverse.select do |event|
+        last_index = start + per_page
+        entries = event_store[stream_name].select do |event|
           event['positionEventNumber'] < last_index &&
             event['positionEventNumber'] >= start
         end
         {
           'entries' => entries,
-          'links' => links(stream_name, last_index, 'previous', entries, count)
+          'links' => links(stream_name, last_index, 'previous', entries, per_page)
         }
       end
 
-      private
-
-      attr_reader :endpoint, :per_page
-
-      def initialize(host:, port:, per_page: 20)
-        @endpoint = Endpoint.new(host: host, port: port)
-        @per_page = per_page
-        @event_store = {}
-      end
-
       def links(stream_name, batch_size, direction, entries, count)
-        if entries.empty? || batch_size < 0
+        if entries.empty? || batch_size.negative?
           []
         else
           [{
-            'uri' => "http://#{endpoint.url}/streams/#{stream_name}/#{batch_size}/#{direction}/#{count}",
+            'uri' =>
+              "http://#{endpoint.url}/streams/#{stream_name}/#{batch_size}/#{direction}/#{count}",
             'relation' => direction
           }]
         end

data/lib/event_store_client/subscription.rb

@@ -6,6 +6,7 @@ module EventStoreClient
     attr_reader :stream, :name
 
     private
+
     def initialize(type:, name:)
       @name = name
       @subscribers = []

data/lib/event_store_client/types.rb

@@ -4,6 +4,12 @@ require 'dry-types'
 
 module EventStoreClient
   module Types
+    UUID_REGEXP = /\A[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}\z/i
+
     include Dry.Types()
+
+    UUID = Types::Strict::String.constrained(
+      format: UUID_REGEXP
+    )
   end
 end

data/lib/event_store_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EventStoreClient
-  VERSION = '0.1.0'
+  VERSION = '0.1.5'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: event_store_client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Sebastian Wilgosz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-02 00:00:00.000000000 Z
+date: 2020-02-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.1
 - !ruby/object:Gem::Dependency
   name: dry-struct
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Easy to use client for event-sources applications written in ruby
 email:
 - sebastian@driggl.com
@@ -81,6 +109,7 @@ files:
 - lib/event_store_client/client.rb
 - lib/event_store_client/configuration.rb
 - lib/event_store_client/connection.rb
+- lib/event_store_client/deserialized_event.rb
 - lib/event_store_client/endpoint.rb
 - lib/event_store_client/event.rb
 - lib/event_store_client/mapper.rb
@@ -115,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ruby integration for https://eventstore.org