synapse-core 0.5.1 → 0.5.2

data/lib/synapse/event_sourcing.rb

@@ -8,6 +8,7 @@ require 'synapse/event_sourcing/member'
 require 'synapse/event_sourcing/aggregate_root'
 require 'synapse/event_sourcing/entity'
 
-require 'synapse/event_sourcing/snapshot/count_stream'
-require 'synapse/event_sourcing/snapshot/count_trigger'
+require 'synapse/event_sourcing/snapshot/policy'
 require 'synapse/event_sourcing/snapshot/taker'
+require 'synapse/event_sourcing/snapshot/aggregate_taker'
+require 'synapse/event_sourcing/snapshot/unit_listener'

data/lib/synapse/event_sourcing/aggregate_factory.rb

@@ -21,7 +21,7 @@ module Synapse
       # @abstract
       # @return [String] Type identifier used to store the aggregate in the event store
       def type_identifier; end
-    end
+    end # AggregateFactory
 
     # Aggregate factory that uses a convention to create instances of aggregates
     class GenericAggregateFactory < AggregateFactory
@@ -46,6 +46,7 @@ module Synapse
 
         if payload.is_a? AggregateRoot
           aggregate = payload
+          aggregate.reset_initial_version
         else
           aggregate = @aggregate_type.allocate
         end
@@ -64,6 +65,6 @@ module Synapse
       def post_process(aggregate)
         aggregate
       end
-    end
-  end
+    end # GenericAggregateFactory
+  end # EventSourcing
 end

data/lib/synapse/event_sourcing/aggregate_root.rb

@@ -19,11 +19,26 @@ module Synapse
         end
       end
 
+      # The sequence number of the first event that the aggregate was initialized from
+      #
+      # If the aggregate was initialized from a snapshot, this should be reset to the sequence
+      # number of the last event in the snapshot. Otherwise, this will be the sequence number
+      # of the first event contained in the event stream used to initialize the aggregate.
+      #
+      # @return [Integer]
+      attr_reader :initial_version
+
       # @return [Integer] The sequence number of the last committed event
       def version
         last_committed_sequence_number
       end
 
+      # Resets the initial version to the current version of the aggregate
+      # @return [undefined]
+      def reset_initial_version
+        @initial_version = last_committed_sequence_number
+      end
+
       # Initializes the state of this aggregate from the given domain event stream
       #
       # @raise [RuntimeError] If aggregate has already been initialized
@@ -36,6 +51,8 @@ module Synapse
 
         pre_initialize
 
+        @initial_version = stream.peek.sequence_number
+
         last_sequence_number = nil
 
         stream.each do |event|

data/lib/synapse/event_sourcing/conflict_resolver.rb

@@ -2,11 +2,14 @@ module Synapse
   module EventSourcing
     # Represents a mechanism that is capable of detecting conflicts between applied changes
     # to the aggregate and unseen changes made to the aggregate.
+    #
+    # @abstract
     class ConflictResolver
       # Checks the list of changes applied to the aggregate and compares it to the list of
       # events already applied to the aggregate. If a conflict is detected, this should throw
       # an exception. Otherwise, the changes will be applied.
       #
+      # @abstract
       # @raise [ConflictingModificationException] If any conflicts were detected
       # @param [Array] applied_changes List of changes applied to the aggregate
       # @param [Array] committed_changes List of events that were unexpected by the command handler

data/lib/synapse/event_sourcing/member.rb

@@ -4,7 +4,17 @@ module Synapse
     # applied to the aggregate
     module Member
       extend ActiveSupport::Concern
-      include Wiring::MessageWiring
+
+      included do
+        # @return [Mapper::Mapping]
+        class_attribute :command_mapper
+
+        # @return [Mapper::Mapping]
+        class_attribute :event_mapper
+
+        self.command_mapper = Mapping::Mapper.new false
+        self.event_mapper = Mapping::Mapper.new true
+      end
 
       module ClassMethods
         # Registers an instance variable as a child entity
@@ -22,6 +32,24 @@ module Synapse
         def child_entities
           @child_entities ||= Set.new
         end
+
+        # @see Mapper#map
+        # @param [Class] type
+        # @param [Object...] args
+        # @param [Proc] block
+        # @return [undefined]
+        def map_command(type, *args, &block)
+          commnad_mapper.map type, *args, &block
+        end
+
+        # @see Mapper#map
+        # @param [Class] type
+        # @param [Object...] args
+        # @param [Proc] block
+        # @return [undefined]
+        def map_event(type, *args, &block)
+          event_mapper.map type, *args, &block
+        end
       end
 
     protected
@@ -57,9 +85,9 @@ module Synapse
       # @param [EventMessage] event
       # @return [undefined]
       def handle_event(event)
-        wire = self.wire_registry.wire_for event.payload_type
-        if wire
-          invoke_wire event, wire
+        mapping = self.event_mapper.mapping_for event.payload_type
+        if mapping
+          mapping.invoke self, event.payload
         end
       end
 
@@ -72,6 +100,6 @@ module Synapse
           entity.is_a? Member
         end
       end
-    end
-  end
+    end # Member
+  end # EventSourcing
 end

data/lib/synapse/event_sourcing/repository.rb

@@ -12,6 +12,12 @@ module Synapse
       # @return [EventStore]
       attr_reader :event_store
 
+      # @return [SnapshotPolicy]
+      attr_accessor :snapshot_policy
+
+      # @return [SnapshotTaker]
+      attr_accessor :snapshot_taker
+
       # @return [Array<EventStreamDecorator>]
       attr_reader :stream_decorators
 
@@ -76,6 +82,17 @@ module Synapse
         aggregate
       end
 
+      # @param [AggregateRoot] aggregate
+      # @return [undefined]
+      def post_registration(aggregate)
+        if @snapshot_policy and @snapshot_taker
+          listener =
+            SnapshotUnitOfWorkListener.new type_identifier, aggregate, @snapshot_policy, @snapshot_taker
+
+          register_listener listener
+        end
+      end
+
       # @return [Class]
       def aggregate_type
         @aggregate_factory.aggregate_type

data/lib/synapse/event_sourcing/snapshot/aggregate_taker.rb

@@ -0,0 +1,38 @@
+module Synapse
+  module EventSourcing
+    # Snapshot taker that uses the actual aggregate and its state to create a snapshot event
+    class AggregateSnapshotTaker < SnapshotTaker
+      # @param [SnapshotEventStore] event_store
+      # @return [undefined]
+      def initialize(event_store)
+        @aggregate_factories = Hash.new
+        @event_store = event_store
+      end
+
+      # @param [AggregateFactory] factory
+      # @return [undefined]
+      def register_factory(factory)
+        @aggregate_factories.store factory.type_identifier, factory
+      end
+
+      # @param [String] type_identifier
+      # @param [Object] aggregate_id
+      # @return [undefined]
+      def schedule_snapshot(type_identifier, aggregate_id)
+        stream = @event_store.read_events type_identifier, aggregate_id
+        factory = @aggregate_factories.fetch type_identifier
+
+        aggregate = factory.create_aggregate aggregate_id, stream.peek
+        aggregate.initialize_from_stream stream
+
+        snapshot = Domain::DomainEventMessage.build do |builder|
+          builder.payload = aggregate
+          builder.aggregate_id = aggregate.id
+          builder.sequence_number = aggregate.version
+        end
+
+        @event_store.append_snapshot_event type_identifier, snapshot
+      end
+    end # AggregateSnapshotTaker
+  end # EventSourcing
+end

data/lib/synapse/event_sourcing/snapshot/policy.rb

@@ -0,0 +1,27 @@
+module Synapse
+  module EventSourcing
+    # Represents a mechanism for determining if an aggregate should have a snapshot taken
+    class SnapshotPolicy
+      # Returns true if a snapshot should be scheduled for the given aggregate
+      #
+      # @param [AggregateRoot] aggregate
+      # @return [Boolean]
+      def should_snapshot?(aggregate); end
+    end # SnapshotPolicy
+
+    # Snapshot policy that takes a snapshot if the number of events committed in an aggregate since
+    # the last snapshot goes over the configured threshold
+    class IntervalSnapshotPolicy < SnapshotPolicy
+      # @return [undefined]
+      def initialize(threshold)
+        @threshold = threshold
+      end
+
+      # @param [AggregateRoot] aggregate
+      # @return [Boolean]
+      def should_snapshot?(aggregate)
+        (aggregate.version - (aggregate.initial_version or 0)) >= @threshold
+      end
+    end # IntervalSnapshotPolicy
+  end # EventSourcing
+end

data/lib/synapse/event_sourcing/snapshot/taker.rb

@@ -15,41 +15,6 @@ module Synapse
       # @param [Object] aggregate_id
       # @return [undefined]
       def schedule_snapshot(type_identifier, aggregate_id); end
-    end
-
-    # Snapshot taker that uses the actual aggregate and its state to create a snapshot event
-    class AggregateSnapshotTaker < SnapshotTaker
-      # @param [SnapshotEventStore] event_store
-      # @return [undefined]
-      def initialize(event_store)
-        @aggregate_factories = Hash.new
-        @event_store = event_store
-      end
-
-      # @param [AggregateFactory] factory
-      # @return [undefined]
-      def register_factory(factory)
-        @aggregate_factories.store factory.type_identifier, factory
-      end
-
-      # @param [String] type_identifier
-      # @param [Object] aggregate_id
-      # @return [undefined]
-      def schedule_snapshot(type_identifier, aggregate_id)
-        stream = @event_store.read_events type_identifier, aggregate_id
-        factory = @aggregate_factories.fetch type_identifier
-
-        aggregate = factory.create_aggregate aggregate_id, stream.peek
-        aggregate.initialize_from_stream stream
-
-        snapshot = Domain::DomainEventMessage.build do |builder|
-          builder.payload = aggregate
-          builder.aggregate_id = aggregate.id
-          builder.sequence_number = aggregate.version
-        end
-
-        @event_store.append_snapshot_event type_identifier, snapshot
-      end
-    end
-  end
+    end # SnapshotTaker
+  end # EventSourcing
 end

data/lib/synapse/event_sourcing/snapshot/unit_listener.rb

@@ -0,0 +1,26 @@
+module Synapse
+  module EventSourcing
+    # Unit of work listener that schedules snapshots
+    class SnapshotUnitOfWorkListener < UnitOfWork::UnitOfWorkListener
+      # @param [String] type_identifier
+      # @param [AggregateRoot] aggregate
+      # @param [SnapshotPolicy] policy
+      # @param [SnapshotTaker] taker
+      # @return [undefined]
+      def initialize(type_identifier, aggregate, policy, taker)
+        @type_identifier = type_identifier
+        @aggregate = aggregate
+        @policy = policy
+        @taker = taker
+      end
+
+      # @param [UnitOfWork] unit
+      # @return [undefined]
+      def on_cleanup(unit)
+        if @policy.should_snapshot? @aggregate
+          @taker.schedule_snapshot @type_identifier, @aggregate.id
+        end
+      end
+    end # SnapshotUnitOfWorkListener
+  end # EventSourcing
+end

data/lib/synapse/event_sourcing/stream_decorator.rb

@@ -5,21 +5,23 @@ module Synapse
     class EventStreamDecorator
       # Decorates an event stream when it is read from the event store
       #
-      # @abstract
       # @param [String] type_identifier
       # @param [Object] aggregate_id
       # @param [DomainEventStream] stream
       # @return [DomainEventStream]
-      def decorate_for_read(type_identifier, aggregate_id, stream); end
+      def decorate_for_read(type_identifier, aggregate_id, stream)
+        stream
+      end
 
       # Decorates an event stream when it is appended to the event store
       #
-      # @abstract
       # @param [String] type_identifier
       # @param [AggregateRoot] aggregate
       # @param [DomainEventStream] stream
       # @return [DomainEventStream]
-      def decorate_for_append(type_identifier, aggregate, stream); end
-    end
-  end
+      def decorate_for_append(type_identifier, aggregate, stream)
+        stream
+      end
+    end # EventStreamDecorator
+  end # EventSourcing
 end

data/lib/synapse/event_store/errors.rb

@@ -11,6 +11,6 @@ module Synapse
       def initialize(type_identifier, aggregate_id)
         super 'Stream not found for [%s] [%s]' % [type_identifier, aggregate_id]
       end
-    end
-  end
+    end # StreamNotFoundError
+  end # EventStore
 end

data/lib/synapse/mapping.rb

@@ -0,0 +1,2 @@
+require 'synapse/mapping/mapper'
+require 'synapse/mapping/mapping'

data/lib/synapse/mapping/mapper.rb

@@ -0,0 +1,75 @@
+module Synapse
+  module Mapping
+    class Mapper
+      # @param [Boolean] duplicates_allowed
+      # @return [undefined]
+      def initialize(duplicates_allowed)
+        @duplicates_allowed = duplicates_allowed
+        @mappings = Array.new
+      end
+
+      # Yields the type that each mapping is registered for
+      #
+      # @yield [Class]
+      # @return [undefined]
+      def each_type
+        @mappings.each do |mapping|
+          yield mapping.type
+        end
+      end
+
+      # @raise [DuplicateMappingError] If duplicates aren't allowed and another mapping exists that
+      #   maps the exact same type as the given mapping
+      # @param [Class] type
+      # @param [Object...] args
+      # @param [Proc] block
+      # @return [undefined]
+      def map(type, *args, &block)
+        options = args.extract_options!
+        mapping = create_from type, options, &block
+
+        unless @duplicates_allowed
+          if @mappings.include? mapping
+            raise DuplicateMappingError
+          end
+        end
+
+        @mappings.push mapping
+        @mappings.sort!
+      end
+
+      # Retrieves the most specific mapping for a given type, if any
+      #
+      # @param [Class] target_type
+      # @return [Mapping]
+      def mapping_for(target_type)
+        @mappings.find do |mapping|
+          mapping.type >= target_type
+        end
+      end
+
+    private
+
+      # @param [Class] type
+      # @param [Hash] options
+      # @param [Proc] block
+      # @return [Mapping]
+      def create_from(type, options, &block)
+        to = options.delete :to
+        unless to
+          unless block
+            raise ArgumentError, 'Expected block or option :to'
+          end
+
+          to = block
+        end
+
+        Mapping.new type, options, to
+      end
+    end
+
+    # Raised if a mapping registry doesn't allow duplicates and an attempt is made to map the same
+    # type to multiple handlers
+    class DuplicateMappingError < NonTransientError; end
+  end
+end