synapse-core 0.2.0 → 0.4.0

data/lib/synapse/event_store/mongo.rb

@@ -1,8 +0,0 @@
-require 'synapse/event_store/mongo/cursor_event_stream'
-require 'synapse/event_store/mongo/event_store'
-
-require 'synapse/event_store/mongo/storage_strategy'
-require 'synapse/event_store/mongo/per_commit_strategy'
-require 'synapse/event_store/mongo/per_event_strategy'
-
-require 'synapse/event_store/mongo/template'

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

@@ -1,63 +0,0 @@
-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
-          @next.tap do
-            initialize_next_event
-          end
-        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

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

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

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

@@ -1,143 +0,0 @@
-module Synapse
-  module EventStore
-    module Mongo
-      # Storage strategy that stores each event as its own document
-      class DocumentPerEventStrategy < 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)
-          documents = Array.new
-
-          events.each do |event|
-            document = EventDocument.new
-            document.from_event event, type_identifier, @serializer
-
-            documents.push document.to_hash
-          end
-
-          documents
-        end
-
-        # @param [Hash] hash
-        # @param [Object] aggregate_id
-        # @return [Array]
-        def extract_events(hash, aggregate_id)
-          document = EventDocument.new
-          document.from_hash(hash).to_events(aggregate_id, @serializer, @upcaster_chain)
-        end
-
-        # Mongo document that represents a single domain event
-        class EventDocument < Serialization::SerializedDomainEventData
-          # @return [String]
-          attr_reader :id
-
-          # @return [Time]
-          attr_reader :timestamp
-
-          # @return [Object]
-          attr_reader :aggregate_id
-
-          # @return [Integer]
-          attr_reader :sequence_number
-
-          # @param [SerializedObject]
-          def metadata
-            Serialization::SerializedMetadata.new @metadata, @metadata.class
-          end
-
-          # @param [SerializedObject]
-          def payload
-            Serialization::SerializedObject.new @payload, @payload.class,
-              Serialization::SerializedType.new(@payload_type, @payload_revision)
-          end
-
-          # @param [DomainEventMessage] event
-          # @param [String] type_identifier
-          # @param [Serializer] serializer
-          # @return [EventDocument]
-          def from_event(event, type_identifier, 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
-            @aggregate_id = event.aggregate_id
-            @aggregate_type = type_identifier
-            @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
-            @aggregate_id = hash.fetch :aggregate_id
-            @aggregate_type = hash.fetch :aggregate_type
-            @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,
-              aggregate_id: @aggregate_id,
-              aggregate_type: @aggregate_type,
-              sequence_number: @sequence_number }
-          end
-
-          # @param [Object] aggregate_id
-          # @param [Serializer] serializer
-          # @param [UpcasterChain] upcaster_chain
-          # @return [Array]
-          def to_events(aggregate_id, serializer, upcaster_chain)
-            events = Array.new
-
-            context = Upcasting::SerializedDomainEventUpcastingContext.new self, aggregate_id, serializer
-            upcast_objects = upcaster_chain.upcast payload, context
-            upcast_objects.each do |upcast_object|
-              upcast_data = Upcasting::UpcastSerializedDomainEventData.new self, 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
-
-            events
-          end
-        end # EventDocument
-      end # DocumentPerEventStrategy
-    end # Mongo
-  end # EventStore
-end # Synapse