event_sourcery 0.13.0

data/lib/event_sourcery/event_store/poll_waiter.rb

@@ -0,0 +1,18 @@
+module EventSourcery
+  module EventStore
+    class PollWaiter
+      def initialize(interval: 0.5)
+        @interval = interval
+      end
+
+      def poll(&block)
+        catch(:stop) do
+          loop do
+            block.call
+            sleep @interval
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/signal_handling_subscription_master.rb

@@ -0,0 +1,22 @@
+module EventSourcery
+  module EventStore
+    class SignalHandlingSubscriptionMaster
+      def initialize
+        @shutdown_requested = false
+        setup_graceful_shutdown
+      end
+
+      def shutdown_if_requested
+        throw :stop if @shutdown_requested
+      end
+
+      private
+
+      def setup_graceful_shutdown
+        %i(TERM INT).each do |signal|
+          Signal.trap(signal) { @shutdown_requested = true }
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/event_store/subscription.rb

@@ -0,0 +1,43 @@
+module EventSourcery
+  module EventStore
+    class Subscription
+      def initialize(event_store:,
+                     poll_waiter:,
+                     from_event_id:,
+                     event_types: nil,
+                     on_new_events:,
+                     subscription_master:,
+                     events_table_name: :events)
+        @event_store = event_store
+        @from_event_id = from_event_id
+        @poll_waiter = poll_waiter
+        @event_types = event_types
+        @on_new_events = on_new_events
+        @subscription_master = subscription_master
+        @current_event_id = from_event_id - 1
+      end
+
+      def start
+        catch(:stop) do
+          @poll_waiter.poll do
+            read_events
+          end
+        end
+      end
+
+      private
+
+      def read_events
+        loop do
+          @subscription_master.shutdown_if_requested
+          events = @event_store.get_next_from(@current_event_id + 1, event_types: @event_types)
+          break if events.empty?
+          EventSourcery.logger.debug { "New events in subscription: #{events.inspect}" }
+          @on_new_events.call(events)
+          @current_event_id = events.last.id
+          EventSourcery.logger.debug { "Position in stream: #{@current_event_id}" }
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/memory/event_store.rb

@@ -0,0 +1,76 @@
+module EventSourcery
+  module Memory
+    class EventStore
+      include EventSourcery::EventStore::EachByRange
+
+      def initialize(events = [], event_builder: EventSourcery.config.event_builder)
+        @events = events
+        @event_builder = event_builder
+      end
+
+      def sink(event_or_events, expected_version: nil)
+        events = Array(event_or_events)
+        ensure_one_aggregate(events)
+
+        if expected_version && version_for(events.first.aggregate_id) != expected_version
+          raise ConcurrencyError
+        end
+
+        events.each do |event|
+          @events << @event_builder.build(
+            id: @events.size + 1,
+            aggregate_id: event.aggregate_id,
+            type: event.type,
+            version: next_version(event.aggregate_id),
+            body: EventBodySerializer.serialize(event.body),
+            created_at: event.created_at || Time.now.utc,
+            uuid: event.uuid,
+            correlation_id: event.correlation_id,
+            causation_id: event.causation_id,
+          )
+        end
+
+        true
+      end
+
+      def get_next_from(id, event_types: nil, limit: 1000)
+        events = if event_types.nil?
+          @events
+        else
+          @events.select { |e| event_types.include?(e.type) }
+        end
+
+        events.select { |event| event.id >= id }.first(limit)
+      end
+
+      def latest_event_id(event_types: nil)
+        events = if event_types.nil?
+          @events
+        else
+          @events.select { |e| event_types.include?(e.type) }
+        end
+
+        events.empty? ? 0 : events.last.id
+      end
+
+      def get_events_for_aggregate_id(id)
+        stringified_id = id.to_str
+        @events.select { |event| event.aggregate_id == stringified_id }
+      end
+
+      def next_version(aggregate_id)
+        version_for(aggregate_id) + 1
+      end
+
+      def version_for(aggregate_id)
+        get_events_for_aggregate_id(aggregate_id).count
+      end
+
+      def ensure_one_aggregate(events)
+        unless events.map(&:aggregate_id).uniq.one?
+          raise AtomicWriteToMultipleAggregatesNotSupported
+        end
+      end
+    end
+  end
+end

data/lib/event_sourcery/memory/tracker.rb

@@ -0,0 +1,27 @@
+module EventSourcery
+  module Memory
+    class Tracker
+      def initialize
+        @state = Hash.new(0)
+      end
+
+      def setup(processor_name)
+        @state[processor_name.to_s] = 0
+      end
+
+      def processed_event(processor_name, event_id)
+        @state[processor_name.to_s] = event_id
+      end
+
+      alias :reset_last_processed_event_id :setup
+
+      def last_processed_event_id(processor_name)
+        @state[processor_name.to_s]
+      end
+
+      def tracked_processors
+        @state.keys
+      end
+    end
+  end
+end

data/lib/event_sourcery/repository.rb

@@ -0,0 +1,31 @@
+module EventSourcery
+  class Repository
+    def self.load(aggregate_class, aggregate_id, event_source:, event_sink:)
+      new(event_source: event_source, event_sink: event_sink)
+        .load(aggregate_class, aggregate_id)
+    end
+
+    def initialize(event_source:, event_sink:)
+      @event_source = event_source
+      @event_sink = event_sink
+    end
+
+    def load(aggregate_class, aggregate_id)
+      events = event_source.get_events_for_aggregate_id(aggregate_id)
+      aggregate_class.new(aggregate_id, events)
+    end
+
+    def save(aggregate)
+      new_events = aggregate.changes
+      if new_events.any?
+        event_sink.sink(new_events,
+                        expected_version: aggregate.version - new_events.count)
+      end
+      aggregate.clear_changes
+    end
+
+    private
+
+    attr_reader :event_source, :event_sink
+  end
+end

data/lib/event_sourcery/rspec/event_store_shared_examples.rb

@@ -0,0 +1,352 @@
+RSpec.shared_examples 'an event store' do
+  let(:aggregate_id) { SecureRandom.uuid }
+
+  def new_event(aggregate_id: SecureRandom.uuid, type: 'test_event', body: {},
+                id: nil, version: 1, created_at: nil, uuid: SecureRandom.uuid,
+                correlation_id: SecureRandom.uuid, causation_id: SecureRandom.uuid)
+    EventSourcery::Event.new(id: id,
+                             aggregate_id: aggregate_id,
+                             type: type,
+                             body: body,
+                             version: version,
+                             created_at: created_at,
+                             uuid: uuid,
+                             correlation_id: correlation_id,
+                             causation_id: causation_id)
+  end
+
+  describe '#sink' do
+    it 'assigns auto incrementing event IDs' do
+      event_store.sink(new_event)
+      event_store.sink(new_event)
+      event_store.sink(new_event)
+      events = event_store.get_next_from(1)
+      expect(events.count).to eq 3
+      expect(events.map(&:id)).to eq [1, 2, 3]
+    end
+
+    it 'assigns UUIDs' do
+      uuid = SecureRandom.uuid
+      event_store.sink(new_event(uuid: uuid))
+      event = event_store.get_next_from(1).first
+      expect(event.uuid).to eq uuid
+    end
+
+    it 'returns true' do
+      expect(event_store.sink(new_event)).to eq true
+    end
+
+    it 'serializes the event body' do
+      time = Time.now
+      event = new_event(body: { 'time' => time })
+      expect(event_store.sink(event)).to eq true
+      expect(event_store.get_next_from(1, limit: 1).first.body).to eq('time' => time.iso8601)
+    end
+
+    it 'saves the causation_id' do
+      causation_id = SecureRandom.uuid
+      event = new_event(causation_id: causation_id)
+      event_store.sink(event)
+      expect(event_store.get_next_from(1, limit: 1).first.causation_id).to eq(causation_id)
+    end
+
+    it 'saves the correlation_id' do
+      correlation_id = SecureRandom.uuid
+      event = new_event(correlation_id: correlation_id)
+      event_store.sink(event)
+      expect(event_store.get_next_from(1, limit: 1).first.correlation_id).to eq(correlation_id)
+    end
+
+    it 'writes multiple events' do
+      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
+                        new_event(aggregate_id: aggregate_id, body: {e: 2}),
+                        new_event(aggregate_id: aggregate_id, body: {e: 3})])
+      events = event_store.get_next_from(1)
+      expect(events.count).to eq 3
+      expect(events.map(&:id)).to eq [1, 2, 3]
+      expect(events.map(&:body)).to eq [{'e' => 1}, {'e' => 2}, {'e' => 3}]
+      expect(events.map(&:version)).to eq [1, 2, 3]
+    end
+
+    it 'sets the correct aggregates version' do
+      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
+                        new_event(aggregate_id: aggregate_id, body: {e: 2})])
+      # this will throw a unique constrain error if the aggregate version was not set correctly ^
+      event_store.sink([new_event(aggregate_id: aggregate_id, body: {e: 1}),
+                        new_event(aggregate_id: aggregate_id, body: {e: 2})])
+      events = event_store.get_next_from(1)
+      expect(events.count).to eq 4
+      expect(events.map(&:id)).to eq [1, 2, 3, 4]
+    end
+
+    context 'with no existing aggregate stream' do
+      it 'saves an event' do
+        event = new_event(aggregate_id: aggregate_id,
+                          type: :test_event_2,
+                          body: { 'my' => 'data' })
+        event_store.sink(event)
+        events = event_store.get_next_from(1)
+        expect(events.count).to eq 1
+        expect(events.first.id).to eq 1
+        expect(events.first.aggregate_id).to eq aggregate_id
+        expect(events.first.type).to eq 'test_event_2'
+        expect(events.first.body).to eq({ 'my' => 'data' }) # should we symbolize keys when hydrating events?
+      end
+    end
+
+    context 'with an existing aggregate stream' do
+      before do
+        event_store.sink(new_event(aggregate_id: aggregate_id))
+      end
+
+      it 'saves an event' do
+        event = new_event(aggregate_id: aggregate_id,
+                         type: :test_event_2,
+                         body: { 'my' => 'data' })
+        event_store.sink(event)
+        events = event_store.get_next_from(1)
+        expect(events.count).to eq 2
+        expect(events.last.id).to eq 2
+        expect(events.last.aggregate_id).to eq aggregate_id
+        expect(events.last.type).to eq :test_event_2.to_s # shouldn't you get back what you put in, a symbol?
+        expect(events.last.body).to eq({ 'my' => 'data' }) # should we symbolize keys when hydrating events?
+      end
+    end
+
+    it 'correctly inserts created at times when inserting multiple events atomically' do
+      time = Time.parse('2016-10-14T00:00:00.646191Z')
+      event_store.sink([new_event(aggregate_id: aggregate_id, created_at: nil), new_event(aggregate_id: aggregate_id, created_at: time)])
+      created_ats = event_store.get_next_from(0).map(&:created_at)
+      expect(created_ats.map(&:class)).to eq [Time, Time]
+      expect(created_ats.last).to eq time
+    end
+
+    it 'raises an error if the events given are for more than one aggregate' do
+      expect {
+        event_store.sink([new_event(aggregate_id: aggregate_id), new_event(aggregate_id: SecureRandom.uuid)])
+      }.to raise_error(EventSourcery::AtomicWriteToMultipleAggregatesNotSupported)
+    end
+  end
+
+  describe '#get_next_from' do
+    it 'gets a subset of events' do
+      event_store.sink(new_event(aggregate_id: aggregate_id))
+      event_store.sink(new_event(aggregate_id: aggregate_id))
+      expect(event_store.get_next_from(1, limit: 1).map(&:id)).to eq [1]
+      expect(event_store.get_next_from(2, limit: 1).map(&:id)).to eq [2]
+      expect(event_store.get_next_from(1, limit: 2).map(&:id)).to eq [1, 2]
+    end
+
+    it 'returns the event as expected' do
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added', body: { 'my' => 'data' }))
+      event = event_store.get_next_from(1, limit: 1).first
+      expect(event.aggregate_id).to eq aggregate_id
+      expect(event.type).to eq 'item_added'
+      expect(event.body).to eq({ 'my' => 'data' })
+      expect(event.created_at).to be_instance_of(Time)
+    end
+
+    it 'filters by event type' do
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'user_signed_up'))
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added'))
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added'))
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_rejected'))
+      event_store.sink(new_event(aggregate_id: aggregate_id, type: 'user_signed_up'))
+      events = event_store.get_next_from(1, event_types: ['user_signed_up'])
+      expect(events.count).to eq 2
+      expect(events.map(&:id)).to eq [1, 5]
+    end
+  end
+
+  describe '#latest_event_id' do
+    it 'returns the latest event id' do
+      event_store.sink(new_event(aggregate_id: aggregate_id))
+      event_store.sink(new_event(aggregate_id: aggregate_id))
+      expect(event_store.latest_event_id).to eq 2
+    end
+
+    context 'with no events' do
+      it 'returns 0' do
+        expect(event_store.latest_event_id).to eq 0
+      end
+    end
+
+    context 'with event type filtering' do
+      it 'gets the latest event ID for a set of event types' do
+        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_1'))
+        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_1'))
+        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'type_2'))
+
+        expect(event_store.latest_event_id(event_types: ['type_1'])).to eq 2
+        expect(event_store.latest_event_id(event_types: ['type_2'])).to eq 3
+        expect(event_store.latest_event_id(event_types: ['type_1', 'type_2'])).to eq 3
+      end
+    end
+  end
+
+  describe '#get_events_for_aggregate_id' do
+    RSpec.shared_examples 'gets events for a specific aggregate id' do
+      before do
+        event_store.sink(new_event(aggregate_id: aggregate_id, type: 'item_added', body: { 'my' => 'body' }))
+        event_store.sink(new_event(aggregate_id: aggregate_id))
+        event_store.sink(new_event(aggregate_id: SecureRandom.uuid))
+      end
+
+      subject(:events) { event_store.get_events_for_aggregate_id(uuid) }
+
+      specify do
+        expect(events.map(&:id)).to eq([1, 2])
+        expect(events.first.aggregate_id).to eq aggregate_id
+        expect(events.first.type).to eq 'item_added'
+        expect(events.first.body).to eq({ 'my' => 'body' })
+        expect(events.first.created_at).to be_instance_of(Time)
+      end
+    end
+
+    context 'when aggregate_id is a string' do
+      include_examples 'gets events for a specific aggregate id' do
+        let(:uuid) { aggregate_id }
+      end
+    end
+
+    context 'when aggregate_id is convertible to a string' do
+      include_examples 'gets events for a specific aggregate id' do
+        let(:uuid) { double(to_str: aggregate_id) }
+      end
+    end
+  end
+
+  describe '#each_by_range' do
+    before do
+      (1..21).each do |i|
+        event_store.sink(new_event(aggregate_id: aggregate_id,
+                                   type: 'item_added',
+                                   body: {}))
+      end
+    end
+
+    def events_by_range(*args)
+      [].tap do |events|
+        event_store.each_by_range(*args) do |event|
+          events << event
+        end
+      end
+    end
+
+    context "the range doesn't include the latest event ID" do
+      it 'returns only the events in the range' do
+        events = events_by_range(1, 20)
+        expect(events.count).to eq 20
+        expect(events.map(&:id)).to eq((1..20).to_a)
+      end
+    end
+
+    context 'the range includes the latest event ID' do
+      it 'returns all the events' do
+        events = events_by_range(1, 21)
+        expect(events.count).to eq 21
+        expect(events.map(&:id)).to eq((1..21).to_a)
+      end
+    end
+
+    context 'the range exceeds the latest event ID' do
+      it 'returns all the events' do
+        events = events_by_range(1, 25)
+        expect(events.count).to eq 21
+        expect(events.map(&:id)).to eq((1..21).to_a)
+      end
+    end
+
+    context 'the range filters by event type' do
+      it 'returns only events of the given type' do
+        expect(events_by_range(1, 21, event_types: ['user_signed_up']).count).to eq 0
+        expect(events_by_range(1, 21, event_types: ['item_added']).count).to eq 21
+      end
+    end
+  end
+
+  def save_event(expected_version: nil)
+    event_store.sink(new_event(aggregate_id: aggregate_id,
+                     type: :billing_details_provided,
+                     body: { my_event: 'data' }),
+                     expected_version: expected_version)
+  end
+
+  def add_event
+    event_store.sink(new_event(aggregate_id: aggregate_id))
+  end
+
+  def last_event
+    event_store.get_next_from(0).last
+  end
+
+  context 'optimistic concurrency control' do
+    context "when the aggregate doesn't exist" do
+      context 'and the expected version is correct - 0' do
+        it 'saves the event with and sets the aggregate version to version 1' do
+          save_event(expected_version: 0)
+          expect(last_event.version).to eq 1
+        end
+      end
+
+      context 'and the expected version is incorrect - 1' do
+        it 'raises a ConcurrencyError' do
+          expect {
+            save_event(expected_version: 1)
+          }.to raise_error(EventSourcery::ConcurrencyError)
+        end
+      end
+
+      context 'with no expected version' do
+        it 'saves the event with and sets the aggregate version to version 1' do
+          save_event
+          expect(last_event.version).to eq 1
+        end
+      end
+    end
+
+    context 'when the aggregate exists' do
+      before do
+        add_event
+      end
+
+      context 'with an incorrect expected version - 0' do
+        it 'raises a ConcurrencyError' do
+          expect {
+            save_event(expected_version: 0)
+          }.to raise_error(EventSourcery::ConcurrencyError)
+        end
+      end
+
+      context 'with a correct expected version - 1' do
+        it 'saves the event with and sets the aggregate version to version 2' do
+          save_event
+          expect(last_event.version).to eq 2
+        end
+      end
+
+      context 'with no aggregate version' do
+        it 'automatically sets the version on the event and aggregate' do
+          save_event
+          expect(last_event.version).to eq 2
+        end
+      end
+    end
+
+    it 'allows overriding the created_at timestamp for events' do
+      time = Time.parse('2016-10-14T00:00:00.646191Z')
+      event_store.sink(new_event(aggregate_id: aggregate_id,
+                                 type: :billing_details_provided,
+                                 body: { my_event: 'data' },
+                                 created_at: time))
+      expect(last_event.created_at).to eq time
+    end
+
+    it "sets a created_at time when one isn't provided in the event" do
+      event_store.sink(new_event(aggregate_id: aggregate_id,
+                                 type: :billing_details_provided,
+                                 body: { my_event: 'data' }))
+      expect(last_event.created_at).to be_instance_of(Time)
+    end
+  end
+end