sequent 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 06ef0bc6b614da70a42d8318cd2c4e135f263dc9
-  data.tar.gz: 00e06d5d6126eaef0a31a191b36872553be04e19
+  metadata.gz: 814f54e9a769f6f73fc7c0cab26eebc4b9a191e1
+  data.tar.gz: c346224df919223cba73db9fe74097c235bacd32
 SHA512:
-  metadata.gz: d399fbc756aabc8ea5e8a81629c59b5fbe322c36e6597f8bd30112941dfd1185e7621b6ea9b90d8fef64756fb05f0f06c03b9b383ec89ec727a0ef5eaa20fec6
-  data.tar.gz: c4820f86874017e0f8c44e634d81de5bdf7c5e0f983bdba5173502104180c7351a9d4e8ee567ac79261b7451c4ad4e5003f21b0f0f5a22ef38c30480401f0c64
+  metadata.gz: 4e39adc404ed14163bd5b54b4ebdc558a12d4d56be8b60ad54140ee1cbc9102d89e17359a08d7a37eeeb299b99788359777d9f6cf778362969cb45b3182d493a
+  data.tar.gz: 667ab8ca0e0b5255184f162210d33a6775b26e952e8868a42a6a8a8ef408b24cec46f118c6fa9400b71a01632a0fb32388e2e23a6ab9362301f2247c2730726a

data/db/sequent_schema.rb

@@ -0,0 +1,53 @@
+ActiveRecord::Schema.define do
+
+  create_table "event_records", :force => true do |t|
+    t.string "aggregate_id", :null => false
+    t.string "organization_id"
+    t.integer "sequence_number", :null => false
+    t.datetime "created_at", :null => false
+    t.string "event_type", :null => false
+    t.text "event_json", :null => false
+    t.integer "command_record_id", :null => false
+    t.integer "stream_record_id", :null => false
+  end
+
+  create_table "command_records", :force => true do |t|
+    t.string "organization_id"
+    t.string "user_id"
+    t.string "aggregate_id"
+    t.string "command_type", :null => false
+    t.text "command_json", :null => false
+    t.datetime "created_at", :null => false
+  end
+
+  execute %Q{
+CREATE UNIQUE INDEX unique_event_per_aggregate ON event_records (
+  aggregate_id,
+  sequence_number,
+  (CASE event_type WHEN 'Sequent::Core::SnapshotEvent' THEN 0 ELSE 1 END)
+)
+}
+  execute %Q{
+CREATE INDEX snapshot_events ON event_records (aggregate_id, sequence_number DESC) WHERE event_type = 'Sequent::Core::SnapshotEvent'
+}
+  add_index "event_records", ["command_record_id"], :name => "index_event_records_on_command_record_id"
+  add_index "event_records", ["organization_id"], :name => "index_event_records_on_organization_id"
+  add_index "event_records", ["event_type"], :name => "index_event_records_on_event_type"
+  add_index "event_records", ["created_at"], :name => "index_event_records_on_created_at"
+
+  create_table "stream_records", :force => true do |t|
+    t.datetime "created_at", :null => false
+    t.string "aggregate_type", :null => false
+    t.string "aggregate_id", :null => false
+    t.integer "snapshot_threshold"
+  end
+
+  add_index "stream_records", ["aggregate_id"], :name => "index_stream_records_on_aggregate_id", :unique => true
+  execute %q{
+ALTER TABLE event_records ADD CONSTRAINT command_fkey FOREIGN KEY (command_record_id) REFERENCES command_records (id)
+}
+  execute %q{
+ALTER TABLE event_records ADD CONSTRAINT stream_fkey FOREIGN KEY (stream_record_id) REFERENCES stream_records (id)
+}
+
+end

data/lib/sequent/configuration.rb

@@ -0,0 +1,49 @@
+require_relative 'core/event_store'
+require_relative 'core/command_service'
+require_relative 'core/transactions/no_transactions'
+require_relative 'core/aggregate_repository'
+
+module Sequent
+  class Configuration
+    attr_reader :aggregate_repository
+
+    attr_accessor :event_store,
+                  :command_service,
+                  :event_record_class,
+                  :stream_record_class,
+                  :snapshot_event_class,
+                  :transaction_provider
+
+    attr_accessor :command_handlers,
+                  :command_filters
+
+    attr_accessor :event_handlers
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.reset
+      @instance = new
+    end
+
+    def initialize
+      self.command_handlers = []
+      self.command_filters = []
+      self.event_handlers = []
+
+      self.event_store = Sequent::Core::EventStore.new(self)
+      self.command_service = Sequent::Core::CommandService.new(self)
+      self.event_record_class = Sequent::Core::EventRecord
+      self.stream_record_class = Sequent::Core::StreamRecord
+      self.snapshot_event_class = Sequent::Core::SnapshotEvent
+      self.transaction_provider = Sequent::Core::Transactions::NoTransactions.new
+    end
+
+    def event_store=(event_store)
+      @event_store = event_store
+      @aggregate_repository = Sequent::Core::AggregateRepository.new(event_store)
+      self.command_handlers.each { |c| c.repository = @aggregate_repository }
+    end
+  end
+end

data/lib/sequent/core/aggregate_repository.rb

@@ -16,12 +16,20 @@ module Sequent
       # Key used in thread local
       AGGREGATES_KEY = 'Sequent::Core::AggregateRepository::aggregates'.to_sym
 
+      attr_reader :event_store
+
       class NonUniqueAggregateId < Exception
         def initialize(existing, new)
           super "Duplicate aggregate #{new} with same key as existing #{existing}"
         end
       end
 
+      class AggregateNotFound < Exception
+        def initialize(id)
+          super "Aggregate with id #{id} not found"
+        end
+      end
+
       def initialize(event_store)
         @event_store = event_store
         clear
@@ -33,8 +41,9 @@ module Sequent
       # and all uncammited_events are stored in the +event_store+
       #
       def add_aggregate(aggregate)
-        if aggregates.has_key?(aggregate.id)
-          raise NonUniqueAggregateId.new(aggregate, aggregates[aggregate.id]) unless aggregates[aggregate.id].equal?(aggregate)
+        existing = aggregates[aggregate.id]
+        if existing && !existing.equal?(aggregate)
+          raise NonUniqueAggregateId.new(aggregate, aggregates[aggregate.id])
         else
           aggregates[aggregate.id] = aggregate
         end
@@ -47,17 +56,17 @@ module Sequent
 
       # Loads aggregate by given id and class
       # Returns the one in the current Unit Of Work otherwise loads it from history.
-      #
-      # If we implement snapshotting this is the place.
-      def load_aggregate(aggregate_id, clazz)
-        if aggregates.has_key?(aggregate_id)
-          result = aggregates[aggregate_id]
-          raise TypeError, "#{result.class} is not a #{clazz}" unless result.is_a?(clazz)
-          result
-        else
-          events = @event_store.load_events(aggregate_id)
-          aggregates[aggregate_id] = clazz.load_from_history(events)
+      def load_aggregate(aggregate_id, clazz = nil)
+        result = aggregates.fetch(aggregate_id) do |aggregate_id|
+          stream, events = @event_store.load_events(aggregate_id)
+          raise AggregateNotFound.new(aggregate_id) unless stream
+          aggregate_class = Class.const_get(stream.aggregate_type)
+          aggregates[aggregate_id] = aggregate_class.load_from_history(stream, events)
         end
+
+        raise TypeError, "#{result.class} is not a #{clazz}" if result && clazz && !(result.class <= clazz)
+
+        result
       end
 
       # Gets all uncommitted_events from the 'registered' aggregates
@@ -68,11 +77,13 @@ module Sequent
       # This is all abstracted away if you use the Sequent::Core::CommandService
       #
       def commit(command)
-        all_events = []
-        aggregates.each_value { |aggregate| all_events += aggregate.uncommitted_events }
-        return if all_events.empty?
-        aggregates.each_value { |aggregate| aggregate.clear_events }
-        store_events command, all_events
+        updated_aggregates = aggregates.values.reject {|x| x.uncommitted_events.empty?}
+        return if updated_aggregates.empty?
+        streams_with_events = updated_aggregates.map do |aggregate|
+          [ aggregate.event_stream, aggregate.uncommitted_events ]
+        end
+        updated_aggregates.each(&:clear_events)
+        store_events command, streams_with_events
       end
 
       # Clears the Unit of Work.
@@ -86,8 +97,8 @@ module Sequent
         Thread.current[AGGREGATES_KEY]
       end
 
-      def store_events(command, events)
-        @event_store.commit_events(command, events)
+      def store_events(command, streams_with_events)
+        @event_store.commit_events(command, streams_with_events)
       end
     end
   end

data/lib/sequent/core/aggregate_root.rb

@@ -1,19 +1,51 @@
+require 'base64'
 require_relative 'helpers/self_applier'
+require_relative 'stream_record'
 
 module Sequent
   module Core
+    module SnapshotConfiguration
+      module ClassMethods
+        ##
+        # Enable snapshots for this aggregate. The aggregate instance
+        # must define the *load_from_snapshot* and *save_to_snapshot*
+        # methods.
+        #
+        def enable_snapshots(default_threshold: 20)
+          @snapshot_default_threshold = default_threshold
+        end
+
+        def snapshots_enabled?
+          !snapshot_default_threshold.nil?
+        end
+
+        attr_reader :snapshot_default_threshold
+      end
+
+      def self.included(host_class)
+        host_class.extend(ClassMethods)
+      end
+    end
+
     # Base class for all your domain classes.
     #
     # +load_from_history+ functionality to be loaded_from_history, meaning a stream of events.
     #
     class AggregateRoot
       include Helpers::SelfApplier
-
-      attr_reader :id, :uncommitted_events, :sequence_number
-
-      def self.load_from_history(events)
-        aggregate_root = allocate() # allocate without calling new
-        aggregate_root.load_from_history(events)
+      include SnapshotConfiguration
+
+      attr_reader :id, :uncommitted_events, :sequence_number, :event_stream
+
+      def self.load_from_history(stream, events)
+        first, *rest = events
+        if first.is_a? SnapshotEvent
+          aggregate_root = Marshal.load(Base64.decode64(first.data))
+          rest.each { |x| aggregate_root.apply_event(x) }
+        else
+          aggregate_root = allocate() # allocate without calling new
+          aggregate_root.load_from_history(stream, events)
+        end
         aggregate_root
       end
 
@@ -21,23 +53,36 @@ module Sequent
         @id = id
         @uncommitted_events = []
         @sequence_number = 1
+        @event_stream = EventStream.new aggregate_type: self.class.name,
+                                        aggregate_id: id,
+                                        snapshot_threshold: self.class.snapshot_default_threshold
       end
 
-      def load_from_history(events)
+      def load_from_history(stream, events)
         raise "Empty history" if events.empty?
         @id = events.first.aggregate_id
         @uncommitted_events = []
-        @sequence_number = events.size + 1
-        events.each { |event| handle_message(event) }
+        @sequence_number = 1
+        @event_stream = stream
+        events.each { |event| apply_event(event) }
       end
 
       def to_s
         "#{self.class.name}: #{@id}"
       end
 
-
       def clear_events
-        uncommitted_events.clear
+        @uncommitted_events = []
+      end
+
+      def take_snapshot!
+        snapshot = build_event SnapshotEvent, data: Base64.encode64(Marshal.dump(self))
+        @uncommitted_events << snapshot
+      end
+
+      def apply_event(event)
+        handle_message(event)
+        @sequence_number = event.sequence_number + 1
       end
 
       protected
@@ -54,9 +99,8 @@ module Sequent
       #
       def apply(event, params={})
         event = build_event(event, params) if event.is_a?(Class)
-        handle_message(event)
+        apply_event(event)
         @uncommitted_events << event
-        @sequence_number += 1
       end
     end
 
@@ -71,10 +115,10 @@ module Sequent
         @organization_id = organization_id
       end
 
-      def load_from_history(events)
+      def load_from_history(stream, events)
         raise "Empty history" if events.empty?
         @organization_id = events.first.organization_id
-        super(events)
+        super
       end
 
       protected

data/lib/sequent/core/aggregate_snapshotter.rb

@@ -0,0 +1,34 @@
+module Sequent
+  module Core
+    class SnapshotCommand <  Sequent::Core::BaseCommand
+      attrs limit: Integer
+    end
+
+    class AggregateSnapshotter < BaseCommandHandler
+
+      def handles_message?(message)
+        message.is_a? SnapshotCommand
+      end
+
+      ##
+      # Take up to `limit` snapshots when needed. Throws `:done` when done.
+      #
+      on SnapshotCommand do |command|
+        aggregate_ids = repository.event_store.aggregates_that_need_snapshots(@last_aggregate_id, command.limit)
+        aggregate_ids.each do |aggregate_id|
+          take_snapshot!(aggregate_id)
+        end
+        @last_aggregate_id = aggregate_ids.last
+        throw :done if @last_aggregate_id.nil?
+      end
+
+      def take_snapshot!(aggregate_id)
+        aggregate = @repository.load_aggregate(aggregate_id)
+        Sequent.logger.info "Taking snapshot for aggregate #{aggregate}"
+        aggregate.take_snapshot!
+      rescue => e
+        Sequent.logger.warn "Failed to take snapshot for aggregate #{aggregate_id}: #{e}", e.inspect
+      end
+    end
+  end
+end

data/lib/sequent/core/base_command_handler.rb

@@ -12,7 +12,7 @@ module Sequent
     #       repository.add_aggregate Invoice.new(command.aggregate_id)
     #     end
     #
-    #     on PayInvoiceCommanddo |command|
+    #     on PayInvoiceCommand do |command|
     #       do_with_aggregate(command, Invoice) {|invoice|invoice.pay(command.pay_date)}
     #     end
     #   end
@@ -20,7 +20,9 @@ module Sequent
       include Sequent::Core::Helpers::SelfApplier,
               Sequent::Core::Helpers::UuidHelper
 
-      def initialize(repository)
+      attr_accessor :repository
+
+      def initialize(repository = Sequent.configuration.aggregate_repository)
         @repository = repository
       end
 
@@ -30,10 +32,6 @@ module Sequent
         yield aggregate if block_given?
       end
 
-      protected
-      def repository
-        @repository
-      end
     end
   end
 end

data/lib/sequent/core/command_service.rb

@@ -2,21 +2,6 @@ require_relative 'transactions/no_transactions'
 
 module Sequent
   module Core
-
-    class CommandServiceConfiguration
-      attr_accessor :event_store,
-                    :command_handler_classes,
-                    :transaction_provider,
-                    :filters
-
-      def initialize
-        @command_handler_classes = []
-        @transaction_provider = Sequent::Core::Transactions::NoTransactions.new
-        @filters = []
-      end
-
-    end
-
     #
     # Single point in the application where subclasses of Sequent::Core::BaseCommand
     # are executed. This will initiate the entire flow of:
@@ -28,21 +13,7 @@ module Sequent
     # * Unit of Work is cleared
     #
     class CommandService
-
-      class << self
-        attr_accessor :configuration,
-                      :instance
-      end
-
-      # Creates a new CommandService and overwrites all existing config.
-      # The new CommandService can be retrieved via the +CommandService.instance+ method.
-      #
-      # If you don't want a singleton you can always instantiate it yourself using the +CommandService.new+.
-      def self.configure
-        self.configuration = CommandServiceConfiguration.new
-        yield(configuration) if block_given?
-        self.instance = CommandService.new(configuration)
-      end
+      attr_accessor :configuration
 
       # +DefaultCommandServiceConfiguration+ Configuration class for the CommandService containing:
       #
@@ -51,11 +22,7 @@ module Sequent
       #   +transaction_provider+ How to do transaction management. Defaults to Sequent::Core::Transactions::NoTransactions
       #   +filters+ List of filter that respond_to :execute(command). Can be useful to do extra checks (security and such).
       def initialize(configuration = CommandServiceConfiguration.new)
-        @event_store = configuration.event_store
-        @repository = AggregateRepository.new(configuration.event_store)
-        @filters = configuration.filters
-        @transaction_provider = configuration.transaction_provider
-        @command_handlers = configuration.command_handler_classes.map { |handler| handler.new(@repository) }
+        self.configuration = configuration
       end
 
       # Executes the given commands in a single transactional block as implemented by the +transaction_provider+
@@ -67,26 +34,47 @@ module Sequent
       # * The +repository+ commits the command and all uncommitted_events resulting from the command
       def execute_commands(*commands)
         begin
-          @transaction_provider.transactional do
+          transaction_provider.transactional do
             commands.each do |command|
-              @filters.each { |filter| filter.execute(command) }
+              filters.each { |filter| filter.execute(command) }
 
               raise CommandNotValid.new(command) unless command.valid?
               parsed_command = command.parse_attrs_to_correct_types
-              @command_handlers.select { |h| h.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
-              @repository.commit(parsed_command)
+              command_handlers.select { |h| h.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
+              repository.commit(parsed_command)
             end
           end
         ensure
-          @repository.clear
+          repository.clear
         end
 
       end
 
       def remove_event_handler(clazz)
-        @event_store.remove_event_handler(clazz)
+        event_store.remove_event_handler(clazz)
       end
 
+      private
+
+      def event_store
+        configuration.event_store
+      end
+
+      def repository
+        configuration.aggregate_repository
+      end
+
+      def filters
+        configuration.command_filters
+      end
+
+      def transaction_provider
+        configuration.transaction_provider
+      end
+
+      def command_handlers
+        configuration.command_handlers
+      end
     end
 
     # Raised when BaseCommand.valid? returns false
@@ -106,9 +94,5 @@ module Sequent
         errors(@command.class.to_s.underscore)
       end
     end
-
   end
 end
-
-
-

data/lib/sequent/core/core.rb

@@ -2,15 +2,16 @@ require_relative 'sequent_oj'
 require_relative 'helpers/helpers'
 require_relative 'record_sessions/record_sessions'
 require_relative 'transactions/transactions'
+require_relative 'event'
 require_relative 'aggregate_repository'
 require_relative 'aggregate_root'
 require_relative 'base_command_handler'
 require_relative 'command'
 require_relative 'command_service'
-require_relative 'event'
 require_relative 'value_object'
 require_relative 'base_event_handler'
 require_relative 'event_store'
 require_relative 'tenant_event_store'
 require_relative 'event_record'
 require_relative 'command_record'
+require_relative 'aggregate_snapshotter'

data/lib/sequent/core/event.rb

@@ -62,7 +62,9 @@ module Sequent
 
     end
 
+    class SnapshotEvent < Event
+      attrs data: String
+    end
+
   end
 end
-
-

data/lib/sequent/core/event_record.rb

@@ -5,10 +5,9 @@ module Sequent
   module Core
 
     module SerializesEvent
-
       def event
         payload = Sequent::Core::Oj.strict_load(self.event_json)
-        Class.const_get(self.event_type.to_sym).deserialize_from_json(payload)
+        Class.const_get(self.event_type).deserialize_from_json(payload)
       end
 
       def event=(event)
@@ -19,7 +18,6 @@ module Sequent
         self.created_at = event.created_at
         self.event_json = Sequent::Core::Oj.dump(event.attributes)
       end
-
     end
 
     class EventRecord < ActiveRecord::Base
@@ -27,15 +25,12 @@ module Sequent
 
       self.table_name = "event_records"
 
+      belongs_to :stream_record
       belongs_to :command_record
 
-      validates_presence_of :aggregate_id, :sequence_number, :event_type, :event_json
-      validates_numericality_of :sequence_number
-
-
-
+      validates_presence_of :aggregate_id, :sequence_number, :event_type, :event_json, :stream_record, :command_record
+      validates_numericality_of :sequence_number, only_integer: true, greater_than: 0
     end
 
   end
 end
-

data/lib/sequent/core/event_store.rb

@@ -1,90 +1,105 @@
+require 'forwardable'
 require_relative 'event_record'
 require_relative 'sequent_oj'
 
 module Sequent
   module Core
-    class EventStoreConfiguration
-      attr_accessor :record_class, :event_handlers
-
-      def initialize(record_class = Sequent::Core::EventRecord, event_handlers = [])
-        @record_class = record_class
-        @event_handlers = event_handlers
-      end
-    end
 
     class EventStore
+      include ActiveRecord::ConnectionAdapters::Quoting
+      extend Forwardable
 
-      class << self
-        attr_accessor :configuration,
-                      :instance
-      end
-
-      # Creates a new EventStore and overwrites all existing config.
-      # The new EventStore can be retrieved via the +EventStore.instance+ method.
-      #
-      # If you don't want a singleton you can always instantiate it yourself using the +EventStore.new+.
-      def self.configure
-        self.configuration = EventStoreConfiguration.new
-        yield(configuration) if block_given?
-        EventStore.instance = EventStore.new(configuration)
-      end
+      attr_accessor :configuration
+      def_delegators :@configuration, :stream_record_class, :event_record_class, :snapshot_event_class, :event_handlers
 
-      def initialize(configuration = EventStoreConfiguration.new)
-        @record_class = configuration.record_class
-        @event_handlers = configuration.event_handlers
+      def initialize(configuration = Sequent.configuration)
+        self.configuration = configuration
+        @event_types = ThreadSafe::Cache.new
       end
 
       ##
       # Stores the events in the EventStore and publishes the events
       # to the registered event_handlers.
       #
-      def commit_events(command, events)
-        store_events(command, events)
-        publish_events(events, @event_handlers)
+      # Streams_with_Events is an enumerable of pairs from
+      # `StreamRecord` to arrays of uncommitted `Event`s.
+      #
+      def commit_events(command, streams_with_events)
+        store_events(command, streams_with_events)
+        publish_events(streams_with_events.flat_map {|_, events| events}, event_handlers)
       end
 
       ##
       # Returns all events for the aggregate ordered by sequence_number
       #
       def load_events(aggregate_id)
-        event_types = {}
-        @record_class.connection.select_all("select event_type, event_json from #{@record_class.table_name} where aggregate_id = '#{aggregate_id}' order by sequence_number asc").map! do |event_hash|
-          event_type = event_hash["event_type"]
-          event_json = Sequent::Core::Oj.strict_load(event_hash["event_json"])
-          unless event_types.has_key?(event_type)
-            event_types[event_type] = Class.const_get(event_type.to_sym)
-          end
-          event_types[event_type].deserialize_from_json(event_json)
+        stream = stream_record_class.where(aggregate_id: aggregate_id).first!
+        events = event_record_class.connection.select_all(%Q{
+SELECT event_type, event_json
+  FROM #{quote_table_name event_record_class.table_name}
+ WHERE aggregate_id = #{quote aggregate_id}
+   AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
+                                      FROM #{quote_table_name event_record_class.table_name}
+                                     WHERE event_type = #{quote snapshot_event_class.name}
+                                       AND aggregate_id = #{quote aggregate_id}), 0)
+ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
+}).map! do |event_hash|
+          deserialize_event(event_hash)
         end
+        [stream.event_stream, events]
       end
 
       ##
       # Replays all events in the event store to the registered event_handlers.
       #
-      # @param block that returns the event stream.
+      # @param block that returns the events.
       def replay_events
-        event_stream = yield
-        event_types = {}
-        event_stream.each do |event_hash|
-          event_type = event_hash["event_type"]
-          payload = Sequent::Core::Oj.strict_load(event_hash["event_json"])
-          unless event_types.has_key?(event_type)
-            event_types[event_type] = Class.const_get(event_type.to_sym)
-          end
-          event = event_types[event_type].deserialize_from_json(payload)
-          @event_handlers.each do |handler|
-            handler.handle_message event
-          end
-        end
+        events = yield.map {|event_hash| deserialize_event(event_hash)}
+        publish_events(events, event_handlers)
+      end
+
+      ##
+      # Returns the ids of aggregates that need a new snapshot.
+      #
+      def aggregates_that_need_snapshots(last_aggregate_id, limit = 10)
+        stream_table = quote_table_name stream_record_class.table_name
+        event_table = quote_table_name event_record_class.table_name
+        query = %Q{
+SELECT aggregate_id
+  FROM #{stream_table} stream
+ WHERE aggregate_id > COALESCE(#{quote last_aggregate_id}, '')
+   AND snapshot_threshold IS NOT NULL
+   AND snapshot_threshold <= (
+         (SELECT MAX(events.sequence_number) FROM #{event_table} events WHERE events.event_type <> #{quote snapshot_event_class.name} AND stream.aggregate_id = events.aggregate_id) -
+         COALESCE((SELECT MAX(snapshots.sequence_number) FROM #{event_table} snapshots WHERE snapshots.event_type = #{quote snapshot_event_class.name} AND stream.aggregate_id = snapshots.aggregate_id), 0))
+ ORDER BY aggregate_id
+ LIMIT #{quote limit}
+ FOR UPDATE
+}
+        event_record_class.connection.select_all(query).map {|x| x['aggregate_id']}
       end
 
-      protected
-      def record_class
-        @record_class
+      def find_event_stream(aggregate_id)
+        record = stream_record_class.where(aggregate_id: aggregate_id).first
+        if record
+          record.event_stream
+        else
+          nil
+        end
       end
 
       private
 
+      def deserialize_event(event_hash)
+        event_type = event_hash.fetch("event_type")
+        event_json = Sequent::Core::Oj.strict_load(event_hash.fetch("event_json"))
+        resolve_event_type(event_type).deserialize_from_json(event_json)
+      end
+
+      def resolve_event_type(event_type)
+        @event_types.fetch_or_store(event_type) { |k| Class.const_get(k) }
+      end
+
       def publish_events(events, event_handlers)
         events.each do |event|
           event_handlers.each do |handler|
@@ -93,17 +108,20 @@ module Sequent
         end
       end
 
-      def to_events(event_records)
-        event_records.map(&:event)
-      end
-
-      def store_events(command, events = [])
-        command_record = Sequent::Core::CommandRecord.create!(:command => command)
-        events.each do |event|
-          @record_class.create!(:command_record => command_record, :event => event)
+      def store_events(command, streams_with_events = [])
+        command_record = CommandRecord.create!(command: command)
+        streams_with_events.each do |event_stream, uncommitted_events|
+          unless event_stream.stream_record_id
+            stream_record = stream_record_class.new
+            stream_record.event_stream = event_stream
+            stream_record.save!
+            event_stream.stream_record_id = stream_record.id
+          end
+          uncommitted_events.each do |event|
+            event_record_class.create!(command_record: command_record, stream_record_id: event_stream.stream_record_id, event: event)
+          end
         end
       end
-
     end
 
   end

data/lib/sequent/core/ext/ext.rb

@@ -51,4 +51,13 @@ class Array
   def self.deserialize_from_json(value)
     value
   end
+
+end
+
+class Hash
+
+  def self.deserialize_from_json(value)
+    value
+  end
+
 end

data/lib/sequent/core/helpers/attribute_support.rb

@@ -139,5 +139,3 @@ EOS
     end
   end
 end
-
-

data/lib/sequent/core/helpers/param_support.rb

@@ -12,28 +12,30 @@ module Sequent
       module ParamSupport
         module ClassMethods
           def from_params(params = {})
-            result = allocate
-            params = HashWithIndifferentAccess.new(params)
-            result.class.types.each do |attribute, type|
-              value = params[attribute]
-
-              next if value.blank?
-              if type.respond_to? :from_params
-                value = type.from_params(value)
-              elsif type.is_a? Sequent::Core::Helpers::ArrayWithType
-                value = value.map { |v| type.item_type.from_params(v) }
-              end
-              result.instance_variable_set(:"@#{attribute}", value)
-            end
-            result
+            allocate.tap { |x| x.from_params(params) }
           end
-
         end
+
         # extend host class with class methods when we're included
         def self.included(host_class)
           host_class.extend(ClassMethods)
         end
 
+        def from_params(params)
+          params = HashWithIndifferentAccess.new(params)
+          self.class.types.each do |attribute, type|
+            value = params[attribute]
+
+            next if value.blank?
+            if type.respond_to? :from_params
+              value = type.from_params(value)
+            elsif type.is_a? Sequent::Core::Helpers::ArrayWithType
+              value = value.map { |v| type.item_type.from_params(v) }
+            end
+            instance_variable_set(:"@#{attribute}", value)
+          end
+        end
+
         def to_params(root)
           make_params root, as_params
         end

data/lib/sequent/core/helpers/self_applier.rb

@@ -19,12 +19,11 @@ module Sequent
         module ClassMethods
 
           def on(*message_classes, &block)
-            @message_mapping ||= {}
-            message_classes.each { |message_class| @message_mapping[message_class] = block }
+            message_classes.each { |message_class| message_mapping[message_class] = block }
           end
 
           def message_mapping
-            @message_mapping || {}
+            @message_mapping ||= {}
           end
         end
 
@@ -42,4 +41,3 @@ module Sequent
     end
   end
 end
-

data/lib/sequent/core/snapshots.rb

@@ -0,0 +1,23 @@
+module Sequent
+  module Core
+    class Snapshots
+
+      def aggregates_that_need_snapshots(events_since_last_snapshot: 20, limit: 10, last_aggregate_id: nil)
+        query = %Q{
+SELECT aggregate_id
+  FROM event_records events
+ WHERE aggregate_id > '#{last_aggregate_id}'
+ GROUP BY aggregate_id
+HAVING MAX(sequence_number) - (COALESCE((SELECT MAX(sequence_number)
+                                           FROM event_records snapshots
+                                          WHERE event_type = 'Sequent::Core::SnapshotEvent'
+                                            AND snapshots.aggregate_id = events.aggregate_id), 0)) > #{events_since_last_snapshot}
+ ORDER BY aggregate_id
+ LIMIT #{limit};
+}
+        @record_class.connection.select_all(query).to_a
+      end
+
+    end
+  end
+end

data/lib/sequent/core/stream_record.rb

@@ -0,0 +1,36 @@
+require 'active_record'
+
+module Sequent
+  module Core
+    class EventStream
+      attr_accessor :aggregate_type, :aggregate_id, :snapshot_threshold, :stream_record_id
+
+      def initialize(aggregate_type:, aggregate_id:, snapshot_threshold: nil, stream_record_id: nil)
+        @aggregate_type = aggregate_type
+        @aggregate_id = aggregate_id
+        @snapshot_threshold = snapshot_threshold
+        @stream_record_id = stream_record_id
+      end
+    end
+
+    class StreamRecord < ActiveRecord::Base
+
+      self.table_name = "stream_records"
+
+      validates_presence_of :aggregate_type, :aggregate_id
+      validates_numericality_of :snapshot_threshold, only_integer: true, greater_than: 0, allow_nil: true
+
+      has_many :events
+
+      def event_stream
+        EventStream.new(aggregate_type: aggregate_type, aggregate_id: aggregate_id, snapshot_threshold: snapshot_threshold, stream_record_id: id)
+      end
+
+      def event_stream=(data)
+        self.aggregate_type = data.aggregate_type
+        self.aggregate_id = data.aggregate_id
+        self.snapshot_threshold = data.snapshot_threshold
+      end
+    end
+  end
+end

data/lib/sequent/core/tenant_event_store.rb

@@ -4,15 +4,21 @@
 module Sequent
   module Core
     class TenantEventStore < EventStore
-
       def replay_events_for(organization_id)
         replay_events do
-          aggregate_ids = @record_class.connection.select_all("select distinct aggregate_id from #{@record_class.table_name} where organization_id = '#{organization_id}'").map { |hash| hash["aggregate_id"] }
-          @record_class.connection.select_all("select id, event_type, event_json from #{@record_class.table_name} where aggregate_id in (#{aggregate_ids.map { |id| %Q{'#{id}'} }.join(",")}) order by id")
+          event_record_class.connection.select_all(%Q{
+SELECT events.event_type, events.event_json
+  FROM #{quote_table_name event_record_class.table_name} events
+ WHERE events.aggregate_id IN (SELECT aggregates.aggregate_id
+                                 FROM #{quote_table_name event_record_class.table_name} aggregates
+                                WHERE aggregates.organization_id = #{quote organization_id}
+                                  AND aggregates.sequence_number = 1
+                                  AND aggregates.event_type <> #{quote snapshot_event_class.name})
+   AND events.event_type <> #{quote snapshot_event_class.name}
+ ORDER BY events.id
+})
         end
       end
-
     end
-
   end
 end

data/lib/sequent/migrations/migrate_events.rb

@@ -36,10 +36,14 @@ module Sequent
       def execute_migrations(current_version, new_version, &after_migration_block)
         if current_version != new_version and current_version > 0
           ((current_version + 1)..new_version).each do |upgrade_to_version|
-            migration_class = "MigrateToVersion#{upgrade_to_version}".to_sym
-            if Kernel.const_defined?(migration_class)
+            migration_class = begin
+                                Class.const_get("Database::MigrateToVersion#{upgrade_to_version}")
+                              rescue NameError
+                                nil
+                              end
+            if migration_class
               begin
-                Kernel.const_get(migration_class).new(@env).migrate
+                migration_class.new(@env).migrate
               ensure
                 after_migration_block.call if after_migration_block
               end
@@ -47,7 +51,6 @@ module Sequent
           end
         end
       end
-
     end
   end
 end

data/lib/sequent/sequent.rb

@@ -1,3 +1,29 @@
 require_relative 'core/core'
 require_relative 'migrations/migrations'
 require_relative 'test/test'
+require_relative 'configuration'
+
+require 'logger'
+
+module Sequent
+  def self.logger
+    @logger ||= Logger.new(STDOUT).tap {|l| l.level = Logger::INFO }
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.configure
+    yield Configuration.instance
+  end
+
+  def self.configuration
+    Configuration.instance
+  end
+
+  # Short hand for Sequent.configuration.command_service
+  def self.command_service
+    configuration.command_service
+  end
+end

data/lib/sequent/test/command_handler_helpers.rb

@@ -1,3 +1,5 @@
+require 'thread_safe'
+
 module Sequent
   module Test
     ##
@@ -36,32 +38,68 @@ module Sequent
 
       class FakeEventStore
         def initialize
-          @all_events = []
+          @event_streams = {}
+          @all_events = {}
           @stored_events = []
         end
 
         def load_events(aggregate_id)
-          deserialize_events(@all_events).select { |event| aggregate_id == event.aggregate_id }
+          event_stream = @event_streams[aggregate_id]
+          return nil unless event_stream
+          [event_stream, deserialize_events(@all_events[aggregate_id])]
+        end
+
+        def find_event_stream(aggregate_id)
+          @event_streams[aggregate_id]
         end
 
         def stored_events
           deserialize_events(@stored_events)
         end
 
-        def commit_events(_, events)
-          serialized = serialize_events(events)
-          @all_events += serialized
-          @stored_events += serialized
+        def commit_events(_, streams_with_events)
+          streams_with_events.each do |event_stream, events|
+            serialized = serialize_events(events)
+            @event_streams[event_stream.aggregate_id] = event_stream
+            @all_events[event_stream.aggregate_id] ||= []
+            @all_events[event_stream.aggregate_id] += serialized
+            @stored_events += serialized
+          end
         end
 
         def given_events(events)
-          @all_events += serialize_events(events)
+          commit_events(nil, to_event_streams(events))
           @stored_events = []
         end
 
         private
+
+        def to_event_streams(events)
+          # Specs use a simple list of given events. We need a mapping from StreamRecord to the associated events for the event store.
+          streams_by_aggregate_id = {}
+          events.map do |event|
+            event_stream = streams_by_aggregate_id.fetch(event.aggregate_id) do |aggregate_id|
+              streams_by_aggregate_id[aggregate_id] =
+                find_event_stream(aggregate_id) ||
+                begin
+                  aggregate_type = FakeEventStore.aggregate_type_for_event(event)
+                  raise "cannot find aggregate type associated with creation event #{event}, did you include an event handler in your aggregate for this event?" unless aggregate_type
+                  Sequent::Core::EventStream.new(aggregate_type: aggregate_type.name, aggregate_id: aggregate_id)
+                end
+            end
+            [event_stream, [event]]
+          end
+        end
+
+        def self.aggregate_type_for_event(event)
+          @event_to_aggregate_type ||= ThreadSafe::Cache.new
+          @event_to_aggregate_type.fetch_or_store(event.class) do |klass|
+            Sequent::Core::AggregateRoot.descendants.find { |x| x.message_mapping.has_key?(klass) }
+          end
+        end
+
         def serialize_events(events)
-          events.map { |event| [event.class.name.to_sym, Sequent::Core::Oj.dump(event)] }
+          events.map { |event| [event.class.name, Sequent::Core::Oj.dump(event)] }
         end
 
         def deserialize_events(events)
@@ -73,7 +111,6 @@ module Sequent
       end
 
       def given_events *events
-        raise ArgumentError.new("events can not be nil") if events.compact.empty?
         @event_store.given_events(events)
       end
 
@@ -85,9 +122,9 @@ module Sequent
       end
 
       def then_events *events
-        @event_store.stored_events.map(&:class).should == events.map(&:class)
+        expect(@event_store.stored_events.map(&:class)).to eq(events.map(&:class))
         @event_store.stored_events.zip(events).each do |actual, expected|
-          Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload)).should == Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload)) if expected
+          expect(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))) if expected
         end
       end
 

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Lars Vonk
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-24 00:00:00.000000000 Z
+date: 2015-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -68,6 +68,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.5
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +138,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 description: Sequent is a CQRS and event sourcing framework for Ruby.
 email:
 - lars.vonk@gmail.com
@@ -133,9 +161,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- db/sequent_schema.rb
 - lib/sequent.rb
+- lib/sequent/configuration.rb
 - lib/sequent/core/aggregate_repository.rb
 - lib/sequent/core/aggregate_root.rb
+- lib/sequent/core/aggregate_snapshotter.rb
 - lib/sequent/core/base_command_handler.rb
 - lib/sequent/core/base_event_handler.rb
 - lib/sequent/core/command.rb
@@ -167,6 +198,8 @@ files:
 - lib/sequent/core/record_sessions/record_sessions.rb
 - lib/sequent/core/record_sessions/replay_events_session.rb
 - lib/sequent/core/sequent_oj.rb
+- lib/sequent/core/snapshots.rb
+- lib/sequent/core/stream_record.rb
 - lib/sequent/core/tenant_event_store.rb
 - lib/sequent/core/transactions/active_record_transaction_provider.rb
 - lib/sequent/core/transactions/no_transactions.rb