synapse-core 0.1.2

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

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

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

@@ -0,0 +1,113 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Represents a mechanism used to structure how events are stored in the database
+      # @abstract
+      class StorageStrategy
+        # @param [MongoTemplate] template
+        # @param [Serializer] serializer
+        # @param [UpcasterChain] upcaster_chain
+        # @return [undefined]
+        def initialize(template, serializer, upcaster_chain)
+          @template = template
+          @serializer = Serialization::MessageSerializer.new serializer
+          @upcaster_chain = upcaster_chain
+        end
+
+        # Creates documents that will represent the events being committed to the event store
+        #
+        # @abstract
+        # @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); end
+
+        # Extracts individual event messages from the given document
+        #
+        # The given aggregate identifier is passed so that event messages can have the actual
+        # identifier object instead of the serialized aggregate identifier.
+        #
+        # @abstract
+        # @param [Hash] document
+        # @param [Object] aggregate_id
+        # @return [Array]
+        def extract_events(document, aggregate_id); end
+
+        # Aliases of the Mongo constants for ascending and descending
+        ASCENDING = ::Mongo::ASCENDING
+        DESCENDING = ::Mongo::DESCENDING
+
+        # Provides a cursor for accessing all events for an aggregate with the given identifier
+        # and type identifier, with a sequence number equal to or greater than the given first
+        # sequence number
+        #
+        # The returned documents should be ordered chronologically, typically by using the
+        # sequence number.
+        #
+        # @param [String] type_identifier
+        # @param [Object] aggregate_id
+        # @param [Integer] first_sequence_number
+        # @return [Mongo::Cursor]
+        def fetch_events(type_identifier, aggregate_id, first_sequence_number)
+          filter = {
+            aggregate_id: aggregate_id,
+            aggregate_type: type_identifier,
+            sequence_number: {
+              '$gte' => first_sequence_number
+            }
+          }
+
+          sort = {
+            sequence_number: ASCENDING
+          }
+
+          @template.event_collection.find(filter).sort(sort)
+        end
+
+        # Finds the document containing the most recent snapshot event for an aggregate with the
+        # given identifier and type identifier
+        #
+        # @param [String] type_identifier
+        # @param [Object] aggregate_id
+        # @return [Mongo::Cursor]
+        def fetch_last_snapshot(type_identifier, aggregate_id)
+          filter = {
+            aggregate_id: aggregate_id,
+            aggregate_type: type_identifier
+          }
+
+          sort = {
+            sequence_number: DESCENDING
+          }
+
+          @template.snapshot_collection.find(filter).sort(sort).limit(1)
+        end
+
+        # Ensures that the correct indexes are in place
+        # @return [undefined]
+        def ensure_indexes
+          options = {
+            name: 'unique_aggregate_index',
+            unique: true
+          }
+
+          spec = {
+            aggregate_id: ASCENDING,
+            aggregate_type: ASCENDING,
+            sequence_number: ASCENDING
+          }
+
+          @template.event_collection.ensure_index spec, options
+
+          spec = {
+            aggregate_id: ASCENDING,
+            aggregate_type: ASCENDING,
+            sequence_number: DESCENDING
+          }
+
+          @template.snapshot_collection.ensure_index spec, options
+        end
+      end # StorageStrategy
+    end # Mongo
+  end # EventStore
+end # Synapse

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

@@ -0,0 +1,73 @@
+module Synapse
+  module EventStore
+    module Mongo
+      # Represents a mechanism for accessing collections required by the Mongo event store
+      # @abstract
+      class MongoTemplate
+        # Returns a reference to the collection containing domain events
+        #
+        # @abstract
+        # @return [Mongo::Collection]
+        def event_collection; end
+
+        # Returns a reference to the collection containing snapshot events
+        #
+        # @abstract
+        # @return [Mongo::Collection]
+        def snapshot_collection; end
+      end
+
+      class DefaultMongoTemplate
+        # @return [String] Name of the database to use
+        attr_accessor :database_name
+
+        # @return [String] Username to authenticate with (optional)
+        attr_accessor :username
+
+        # @return [String] Password to authenticate with (optional)
+        attr_accessor :password
+
+        # @return [String] Name of the collection containing domain events
+        attr_accessor :event_collection
+
+        # @return [String] Name of the collection containing snapshot events
+        attr_accessor :snapshot_collection
+
+        # @param [Mongo::MongoClient] client
+        # @return [undefined]
+        def initialize(client)
+          @client = client
+
+          @database_name = 'synapse'
+          @event_collection_name = 'domain_events'
+          @snapshot_collection_name = 'snapshot_events'
+        end
+
+        # @return [Mongo::Collection]
+        def event_collection
+          database.collection @event_collection_name
+        end
+
+        # @return [Mongo::Collection]
+        def snapshot_collection
+          database.collection @snapshot_collection_name
+        end
+
+      private
+
+        # @return [Mongo::DB]
+        def database
+          unless @database
+            @database = @client.db @database_name
+
+            if @username and @password
+              @database.authenticate @username, @password
+            end
+          end
+
+          @database
+        end
+      end # DefaultMongoTemplate
+    end # Mongo
+  end # EventStore
+end # Synapse

data/lib/synapse/identifier.rb

@@ -0,0 +1,23 @@
+require 'securerandom'
+
+module Synapse
+  # Represents a mechanism for generating a unique identifier for domain objects
+  class IdentifierFactory
+    class_attribute :instance
+  end
+
+  # Implementation of an identifier factory that generates pseudo-random GUIDs
+  #
+  # @example The identifier format produced by this factory
+  #   factory = GuidIdentifierFactory.new
+  #   factory.generate # => "8f0c580b-5a0f-4fc7-9025-c39072ae073d"
+  class GuidIdentifierFactory
+    # Generates a pseudo-random GUID
+    # @return [String] The newly generated unique identifier
+    def generate
+      SecureRandom.uuid
+    end
+  end
+
+  ActiveSupport.run_load_hooks :identifier_factory, IdentifierFactory
+end

data/lib/synapse/message.rb

@@ -0,0 +1,101 @@
+module Synapse
+  # Representation of a message containing a payload and metadata
+  #
+  # Instead of using this class directly, it is recommended to use a subclass specifically
+  # for commands, events or domain events.
+  #
+  # Two messages with the same identifier should be interpreted as different representations
+  # of the same conceptual message. In such case, the metadata may be different for both
+  # representations. The payload *may* be identical.
+  class Message
+    # Unique identifier of this message
+    # @return [String]
+    attr_reader :id
+
+    # Metadata attached to this message by the application
+    # @return [Hash]
+    attr_reader :metadata
+
+    # Payload of this message; examples include commands and events. A payload is expected to
+    # be immutable to provide thread safety.
+    #
+    # @return [Object]
+    attr_reader :payload
+
+    # @param [String] id
+    # @param [Hash] metadata
+    # @param [Object] payload
+    # @return [undefined]
+    def initialize(id, metadata, payload)
+      @id = id
+      @metadata = metadata
+      @payload = payload
+
+      @metadata.freeze
+    end
+
+    # Returns the class of the payload of this message; use this instead of calling payload
+    # and class, in case of lazily deserializing messages.
+    #
+    # @return [Class]
+    def payload_type
+      @payload.class
+    end
+
+    # Returns a copy of this message with the given metadata merged in
+    #
+    # @param [Hash] additional_metadata
+    # @return [Message]
+    def and_metadata(additional_metadata)
+      if additional_metadata.empty?
+        return self
+      end
+
+      builder = self.class.builder.new
+      build_duplicate builder, @metadata.merge(additional_metadata)
+      builder.build
+    end
+
+    # Returns a copy of this message with the metadata replaced with the given metadata
+    #
+    # @param [Hash] replacement_metadata
+    # @return [Message]
+    def with_metadata(replacement_metadata)
+      if @metadata == replacement_metadata
+        return self
+      end
+
+      builder = self.class.builder.new
+      build_duplicate builder, replacement_metadata
+      builder.build
+    end
+
+    # Yields a message builder that can be used to produce a message
+    #
+    # @see MessageBuilder#build
+    # @yield [MessageBuilder]
+    # @return [Message]
+    def self.build(&block)
+      builder.build(&block)
+    end
+
+    # Returns the type of builder that can be used to build this type of message
+    # @return [Class]
+    def self.builder
+      MessageBuilder
+    end
+
+  protected
+
+    # Populates a duplicated message with attributes from this message
+    #
+    # @param [MessageBuilder] builder
+    # @param [Hash] metadata
+    # @return [undefined]
+    def build_duplicate(builder, metadata)
+      builder.id = @id
+      builder.metadata = metadata
+      builder.payload = @payload
+    end
+  end
+end