synapse-core 0.1.2

data/lib/synapse/event_store/event_store.rb

@@ -0,0 +1,43 @@
+module Synapse
+  module EventStore
+    # Represents a mechanism for reading and appending streams of domain events
+    # @abstract
+    class EventStore
+      # Fetches an event stream for the aggregate identified by the given type identifier and
+      # the given aggregate identifier. This stream can be used to rebuild the state of the
+      # aggregate.
+      #
+      # Implementations may omit or replace events (for example, with snapshot events) from the
+      # stream for performance purposes.
+      #
+      # @abstract
+      # @raise [EventStoreError] If an error occurs while reading the stream from the store
+      # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+      # @param [Object] aggregate_id
+      # @return [DomainEventStream]
+      def read_events(type_identifier, aggregate_id); end
+
+      # Appends the domain events in the given stream to the event store
+      #
+      # @abstract
+      # @raise [EventStoreError] If an error occurs while appending the stream to the store
+      # @param [String] type_identifier Type descriptor of the aggregate to append to
+      # @param [DomainEventStream] stream
+      # @return [undefined]
+      def append_events(type_identifier, stream); end
+    end
+
+    # Represents an event store with the capability to manage aggregate snapshots
+    # @abstract
+    class SnapshotEventStore < EventStore
+      # Appends the given snapshot event to the event store
+      #
+      # @abstract
+      # @raise [EventStoreError] If an error occurs while appending the event to the store
+      # @param [String] type_identifier Type descriptor of the aggregate to append to
+      # @param [DomainEventMessage] snapshot_event
+      # @return [undefined]
+      def append_snapshot_event(type_identifier, snapshot_event); end
+    end
+  end
+end

data/lib/synapse/event_store/in_memory.rb

@@ -0,0 +1,59 @@
+module Synapse
+  module EventStore
+    # Implementation of an event store that stores events in memory; for testing purposes and
+    # not thread safe
+    class InMemoryEventStore < EventStore
+      def initialize
+        @streams = Hash.new
+      end
+
+      # Clears all streams from this event store
+      def clear
+        @streams.clear
+      end
+
+      # @raise [StreamNotFoundError] If the stream for the given aggregate identifier is empty
+      # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+      # @param [Object] aggregate_id
+      # @return [DomainEventStream]
+      def read_events(type_identifier, aggregate_id)
+        events = events_for aggregate_id
+
+        if events.empty?
+          raise StreamNotFoundError.new type_identifier, aggregate_id
+        end
+
+        Domain::SimpleDomainEventStream.new events
+      end
+
+      # Appends any events in the given stream to the end of the aggregate's stream
+      #
+      # @param [String] type_identifier Type descriptor of the aggregate to append to
+      # @param [DomainEventStream] stream
+      # @return [undefined]
+      def append_events(type_identifier, stream)
+        if stream.end?
+          return
+        end
+
+        events = events_for stream.peek.aggregate_id
+
+        until stream.end?
+          events.push stream.next_event
+        end
+      end
+
+      # Creates and/or retrieves an array of events for the given aggregate identifier
+      #
+      # @param [Object] aggregate_id
+      # @return [Array<DomainEventMessage>]
+      def events_for(aggregate_id)
+        if @streams.has_key? aggregate_id
+          return @streams.fetch aggregate_id
+        end
+
+        @streams.store aggregate_id, Array.new
+      end
+    end
+  end
+end

data/lib/synapse/event_store/mongo/cursor_event_stream.rb

@@ -0,0 +1,63 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # TODO Document me
+      class CursorDomainEventStream < Domain::DomainEventStream
+        # @param [StorageStrategy] storage_strategy
+        # @param [Mongo::Cursor] cursor
+        # @param [Array] last_snapshot_commit
+        # @param [Object] aggregate_id
+        # @return [undefined]
+        def initialize(storage_strategy, cursor, last_snapshot_commit, aggregate_id)
+          @storage_strategy = storage_strategy
+          @cursor = cursor
+          @aggregate_id = aggregate_id
+
+          if last_snapshot_commit
+            # Current batch is an enumerator
+            @current_batch = last_snapshot_commit.each
+          else
+            @current_batch = [].each
+          end
+
+          initialize_next_event
+        end
+
+        # @return [Boolean]
+        def end?
+          @next.nil?
+        end
+
+        # @return [DomainEventMessage]
+        def next_event
+          current = @next
+          initialize_next_event
+          current
+        end
+
+        # @return [DomainEventMessage]
+        def peek
+          @next
+        end
+
+      private
+
+        # @return [undefined]
+        def initialize_next_event
+          begin
+            @next = @current_batch.next
+          rescue StopIteration
+            if @cursor.has_next?
+              document = @cursor.next
+              @current_batch = @storage_strategy.extract_events(document, @aggregate_id).each
+
+              retry
+            else
+              @next = nil
+            end
+          end
+        end
+      end # CursorDomainEventStream
+    end
+  end
+end

data/lib/synapse/event_store/mongo/event_store.rb

@@ -0,0 +1,86 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Implementation of an event store backed by a Mongo database
+      class MongoEventStore < SnapshotEventStore
+        # @param [MongoTemplate] template
+        # @param [StorageStrategy] storage_strategy
+        # @return [undefined]
+        def initialize(template, storage_strategy)
+          @storage_strategy = storage_strategy
+          @template = template
+        end
+
+        # @return [undefined]
+        def ensure_indexes
+          @storage_strategy.ensure_indexes
+        end
+
+        # @raise [EventStoreError] If an error occurs while reading the stream from the store
+        # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+        # @param [Object] aggregate_id
+        # @return [DomainEventStream]
+        def read_events(type_identifier, aggregate_id)
+          first_sequence_number = -1
+
+          last_snapshot_commit = load_last_snapshot type_identifier, aggregate_id
+          if last_snapshot_commit and last_snapshot_commit.size > 0
+            first_sequence_number = last_snapshot_commit[0].sequence_number
+          end
+
+          cursor = @storage_strategy.fetch_events type_identifier, aggregate_id, first_sequence_number
+
+          unless last_snapshot_commit or cursor.has_next?
+            raise StreamNotFoundError.new type_identifier, aggregate_id
+          end
+
+          CursorDomainEventStream.new @storage_strategy, cursor, last_snapshot_commit, aggregate_id
+        end
+
+        # @raise [EventStoreError] If an error occurs while appending the stream to the store
+        # @param [String] type_identifier Type descriptor of the aggregate to append to
+        # @param [DomainEventStream] stream
+        # @return [undefined]
+        def append_events(type_identifier, stream)
+          events = stream.to_a
+          documents = @storage_strategy.create_documents type_identifier, events
+
+          begin
+            @template.event_collection.insert documents
+          rescue Mongo::OperationFailure => ex
+            if e.error_code == 11000
+              raise Repository::ConcurrencyException,
+                'Event for this aggregate and sequence number already present'
+            end
+
+            raise ex
+          end
+        end
+
+        # @raise [EventStoreError] If an error occurs while appending the event to the store
+        # @param [String] type_identifier Type descriptor of the aggregate to append to
+        # @param [DomainEventMessage] snapshot_event
+        # @return [undefined]
+        def append_snapshot_event(type_identifier, snapshot_event)
+          documents = @storage_strategy.create_documents type_identifier, [snapshot_event]
+          @template.snapshot_collection.insert documents
+        end
+
+      private
+
+        # @param [String] type_identifier Type descriptor of the aggregate to retrieve
+        # @param [Object] aggregate_id
+        def load_last_snapshot(type_identifier, aggregate_id)
+          cursor = @storage_strategy.fetch_last_snapshot type_identifier, aggregate_id
+
+          unless cursor.has_next?
+            return
+          end
+
+          first = cursor.next_document
+          @storage_strategy.extract_events first, aggregate_id
+        end
+      end # MongoEventStore
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/event_store/mongo/per_commit_strategy.rb

@@ -0,0 +1,253 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Storage strategy that stores all events in a commit operation in a single document
+      #
+      # Since Mongo doesn't support transactions, this can be used as a substitute to guarantee
+      # atomic storage of events. The only downside is that it may be harder to query events
+      # from the event store.
+      #
+      # Performance also seems to be better using this strategy
+      class DocumentPerCommitStrategy < StorageStrategy
+        # @param [String] type_identifier Type identifier for the aggregate
+        # @param [Array] events Domain events to be committed
+        # @return [Array]
+        def create_documents(type_identifier, events)
+          document = CommitDocument.new
+          document.from_events(type_identifier, events, @serializer).to_hash
+        end
+
+        # @param [Hash] hash
+        # @param [Object] aggregate_id
+        # @return [Array]
+        def extract_events(hash, aggregate_id)
+          document = CommitDocument.new
+          document.from_hash(hash).to_events(aggregate_id, @serializer, @upcaster_chain)
+        end
+
+        # Mongo document that represents a commit containing one or more events
+        class CommitDocument
+          # @return [Object]
+          attr_reader :aggregate_id
+
+          # @param [String] type_identifier
+          # @param [Array] events
+          # @param [Serializer] serializer
+          # @return [CommitDocument]
+          def from_events(type_identifier, events, serializer)
+            first_event = events.first
+            last_event = events.last
+
+            @aggregate_type = type_identifier
+            @aggregate_id = first_event.aggregate_id.to_s
+            @first_sequence_number = first_event.sequence_number
+            @last_sequence_number = last_event.sequence_number
+            @first_timestamp = first_event.timestamp
+            @last_timestamp = last_event.timestamp
+
+            @events = Array.new
+            events.each do |event|
+              event_document = EventDocument.new
+              event_document.from_event event, serializer
+
+              @events.push event_document
+            end
+
+            self
+          end
+
+          # @param [Hash] hash
+          # @return [CommitDocument]
+          def from_hash(hash)
+            hash.symbolize_keys!
+
+            @aggregate_id = hash.fetch :aggregate_id
+            @aggregate_type = hash.fetch :aggregate_type
+            @first_sequence_number = hash.fetch :first_sequence_number
+            @last_sequence_number = hash.fetch :last_sequence_number
+            @first_timestamp = hash.fetch :first_timestamp
+            @last_timestamp = hash.fetch :last_timestamp
+
+            @events = Array.new
+
+            event_hashes = hash.fetch :events
+            event_hashes.each do |event_hash|
+              event_document = EventDocument.new
+              event_document.from_hash event_hash
+
+              @events.push event_document
+            end
+
+            self
+          end
+
+          # @return [Hash]
+          def to_hash
+            events = Array.new
+            @events.each do |event|
+              events.push event.to_hash
+            end
+
+            { aggregate_id: @aggregate_id,
+              aggregate_type: @aggregate_type,
+              # Allows us to use the same query to filter events as DocumentPerEvent
+              sequence_number: @first_sequence_number,
+              first_sequence_number: @first_sequence_number,
+              last_sequence_number: @last_sequence_number,
+              # Allows us to use the same query to filter events as DocumentPerEvent
+              timestamp: @first_timestamp,
+              first_timestamp: @first_timestamp,
+              last_timestamp: @last_timestamp,
+              events: events }
+          end
+
+          # @param [Object] aggregate_id The actual aggregate identifier used to query the evnet store
+          # @param [Serializer] serializer
+          # @param [UpcasterChain] upcaster_chain
+          # @return [Array]
+          def to_events(aggregate_id, serializer, upcaster_chain)
+            events = Array.new
+
+            @events.each do |event_document|
+              event_data = DocumentDomainEventData.new aggregate_id, event_document
+              context = Upcasting::SerializedDomainEventUpcastingContext.new event_data, aggregate_id, serializer
+
+              upcast_objects = upcaster_chain.upcast event_document.payload, context
+              upcast_objects.each do |upcast_object|
+                upcast_data = Upcasting::UpcastSerializedDomainEventData.new event_data, aggregate_id, upcast_object
+
+                builder = Serialization::SerializedDomainEventMessageBuilder.new
+
+                # Prevent duplicate serialization of metadata if it was accessed during upcasting
+                metadata = context.serialized_metadata
+                if metadata.deserialized?
+                  builder.metadata = Serialization::DeserializedObject.new metadata.deserialized
+                end
+
+                builder.from_data upcast_data, serializer
+
+                events.push builder.build
+              end
+            end
+
+            events
+          end
+        end # CommitDocument
+
+        # Mongo document that represents a single event as part of a commit document
+        class EventDocument
+          # @return [String]
+          attr_reader :id
+
+          # @return [Time]
+          attr_reader :timestamp
+
+          # @return [Integer]
+          attr_reader :sequence_number
+
+          # @return [SerializedObject]
+          def metadata
+            Serialization::SerializedMetadata.new @metadata, @metadata.class
+          end
+
+          # @return [SerializedObject]
+          def payload
+            Serialization::SerializedObject.new @payload, @payload.class,
+              Serialization::SerializedType.new(@payload_type, @payload_revision)
+          end
+
+          # @param [EventMessage] event
+          # @param [Serializer] serializer
+          # @return [EventDocument]
+          def from_event(event, serializer)
+            serialization_target = String
+            if serializer.can_serialize_to? Hash
+              serialization_target = Hash
+            end
+
+            serialized_metadata = serializer.serialize_metadata event, serialization_target
+            serialized_payload = serializer.serialize_payload event, serialization_target
+
+            @id = event.id
+            @metadata = serialized_metadata.content
+            @payload = serialized_payload.content
+            @payload_type = serialized_payload.type.name
+            @payload_revision = serialized_payload.type.revision
+            @timestamp = event.timestamp
+            @sequence_number = event.sequence_number
+
+            self
+          end
+
+          # @param [Hash] hash
+          # @return [EventDocument]
+          def from_hash(hash)
+            hash.symbolize_keys!
+
+            @id = hash.fetch :id
+            @metadata = hash.fetch :metadata
+            @payload = hash.fetch :payload
+            @payload_type = hash.fetch :payload_type
+            @payload_revision = hash.fetch :payload_revision
+            @timestamp = hash.fetch :timestamp
+            @sequence_number = hash.fetch :sequence_number
+
+            self
+          end
+
+          # @return [Hash]
+          def to_hash
+            { id: @id,
+              metadata: @metadata,
+              payload: @payload,
+              payload_type: @payload_type,
+              payload_revision: @payload_revision,
+              timestamp: @timestamp,
+              sequence_number: @sequence_number }
+          end
+        end # EventDocument
+
+        # Serialized domain event data from an event document
+        class DocumentDomainEventData < Serialization::SerializedDomainEventData
+          # @param [Object] aggregate_id
+          # @param [EventDocument] event_document
+          # @return [undefined]
+          def initialize(aggregate_id, event_document)
+            @aggregate_id = aggregate_id
+            @event_document = event_document
+          end
+
+          # @return [String]
+          def id
+            @event_document.id
+          end
+
+          # @return [SerializedObject]
+          def metadata
+            @event_document.metadata
+          end
+
+          # @return [SerializedObject]
+          def payload
+            @event_document.payload
+          end
+
+          # @return [Time]
+          def timestamp
+            @event_document.timestamp
+          end
+
+          # @return [Object]
+          def aggregate_id
+            @aggregate_id
+          end
+
+          # @return [Integer]
+          def sequence_number
+            @event_document.sequence_number
+          end
+        end # DocumentDomainEventData
+      end # DocumentPerCommitStrategy
+    end # Mongo
+  end # EventStore
+end # Synapse