sequent 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1c376e79b2afb9c653058f4cb38e7d24bb7d742
-  data.tar.gz: 751c997c10407d7dd073b70b268ed69d16d1b459
+  metadata.gz: 2f3c785214713fa790ec8e000314e79730913df4
+  data.tar.gz: 0da86f6f53cacc4c007020e021cb849931154a67
 SHA512:
-  metadata.gz: 042064fb131306a5197e035330dceb3e467c2031f73932777286ec72219545ef7fcc5bbd3b0322177801d994e87adf66735be07e4b03fbf2e725d209b11e8b09
-  data.tar.gz: 777558493270ceeb8e80038e6b2336bfebbdbb103e74c341f676e53599971e8723862b3b6aa424d008f294ff78108a580652f31a90600fa90a275387696ba5f2
+  metadata.gz: a422b778b039fdb34d9b6782dc06861a6c17472c15773de773d79e5a902854d9792eec2d9463cc93d6ac2fec1bd4b2ec2b54efcb2a4f3adb0d1e2798dddb7ab0
+  data.tar.gz: 46c9c7acae7f5148fffbe715d49cf80f245569ac77e0824dfae22fb42949a8e14684f22a850519803b3be42f2364f50a39fb387e68ae7b7c13a0a10ed55b176f

data/lib/sequent/configuration.rb

@@ -5,14 +5,15 @@ require_relative 'core/aggregate_repository'
 
 module Sequent
   class Configuration
-    attr_reader :aggregate_repository
+    attr_accessor :aggregate_repository
 
     attr_accessor :event_store,
                   :command_service,
                   :event_record_class,
                   :stream_record_class,
                   :snapshot_event_class,
-                  :transaction_provider
+                  :transaction_provider,
+                  :event_publisher
 
     attr_accessor :command_handlers,
                   :command_filters
@@ -40,20 +41,16 @@ module Sequent
       self.command_filters = []
       self.event_handlers = []
 
-      self.event_store = Sequent::Core::EventStore.new(self)
-      self.command_service = Sequent::Core::CommandService.new(self)
+      self.aggregate_repository = Sequent::Core::AggregateRepository.new
+      self.event_store = Sequent::Core::EventStore.new
+      self.command_service = Sequent::Core::CommandService.new
       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
       self.uuid_generator = Sequent::Core::RandomUuidGenerator
+      self.event_publisher = Sequent::Core::EventPublisher.new
       self.disable_event_handlers = false
     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,8 +16,6 @@ module Sequent
       # Key used in thread local
       AGGREGATES_KEY = 'Sequent::Core::AggregateRepository::aggregates'.to_sym
 
-      attr_reader :event_store
-
       class NonUniqueAggregateId < StandardError
         def initialize(existing, new)
           super "Duplicate aggregate #{new} with same key as existing #{existing}"
@@ -30,10 +28,6 @@ module Sequent
         end
       end
 
-      def initialize(event_store)
-        @event_store = event_store
-      end
-
       # Adds the given aggregate to the repository (or unit of work).
       #
       # Only when +commit+ is called all aggregates in the unit of work are 'processed'
@@ -80,7 +74,7 @@ module Sequent
         _aggregates = aggregates.values_at(*_aggregate_ids).compact
         _query_ids = _aggregate_ids - _aggregates.map(&:id)
 
-        _aggregates += @event_store.load_events_for_aggregates(_query_ids).map do |stream, events|
+        _aggregates += Sequent.configuration.event_store.load_events_for_aggregates(_query_ids).map do |stream, events|
           aggregate_class = Class.const_get(stream.aggregate_type)
           aggregate_class.load_from_history(stream, events)
         end
@@ -104,7 +98,7 @@ module Sequent
       ##
       # Returns whether the event store has an aggregate with the given id
       def contains_aggregate?(aggregate_id)
-        @event_store.stream_exists?(aggregate_id)
+        Sequent.configuration.event_store.stream_exists?(aggregate_id)
       end
 
       # Gets all uncommitted_events from the 'registered' aggregates
@@ -136,7 +130,7 @@ module Sequent
       end
 
       def store_events(command, streams_with_events)
-        @event_store.commit_events(command, streams_with_events)
+        Sequent.configuration.event_store.commit_events(command, streams_with_events)
       end
     end
   end

data/lib/sequent/core/aggregate_snapshotter.rb

@@ -1,18 +1,20 @@
 module Sequent
   module Core
+
+    ##
+    # Take up to `limit` snapshots when needed. Throws `:done` when done.
+    #
     class SnapshotCommand <  Sequent::Core::BaseCommand
       attrs limit: Integer
     end
 
-    class AggregateSnapshotter < BaseCommandHandler
+    ##
+    # Take snapshot of given aggregate
+    class TakeSnapshot < Sequent::Core::Command
+    end
 
-      def self.handles_message?(message)
-        message.is_a? SnapshotCommand
-      end
+    class AggregateSnapshotter < BaseCommandHandler
 
-      ##
-      # 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|
@@ -22,8 +24,12 @@ module Sequent
         throw :done if @last_aggregate_id.nil?
       end
 
+      on TakeSnapshot do |command|
+        take_snapshot!(command.aggregate_id)
+      end
+
       def take_snapshot!(aggregate_id)
-        aggregate = @repository.load_aggregate(aggregate_id)
+        aggregate = repository.load_aggregate(aggregate_id)
         Sequent.logger.info "Taking snapshot for aggregate #{aggregate}"
         aggregate.take_snapshot!
       rescue => e

data/lib/sequent/core/base_command_handler.rb

@@ -20,16 +20,14 @@ module Sequent
       include Sequent::Core::Helpers::SelfApplier,
               Sequent::Core::Helpers::UuidHelper
 
-      attr_accessor :repository
+      protected
 
-      def initialize(repository = Sequent.configuration.aggregate_repository)
-        @repository = repository
+      def repository
+        Sequent.configuration.aggregate_repository
       end
 
-      protected
-
       def do_with_aggregate(command, clazz = nil, aggregate_id = nil)
-        aggregate = @repository.load_aggregate(aggregate_id.nil? ? command.aggregate_id : aggregate_id, clazz)
+        aggregate = repository.load_aggregate(aggregate_id.nil? ? command.aggregate_id : aggregate_id, clazz)
         yield aggregate if block_given?
       end
     end

data/lib/sequent/core/base_event_handler.rb

@@ -42,7 +42,7 @@ module Sequent
         @record_session = record_session
       end
 
-      def_delegators :@record_session, :update_record, :create_record, :create_or_update_record, :get_record!, :get_record,
+      def_delegators :@record_session, :update_record, :create_record, :create_records, :create_or_update_record, :get_record!, :get_record,
                      :delete_all_records, :update_all_records, :do_with_records, :do_with_record, :delete_record,
                      :find_records, :last_record, :execute
 

data/lib/sequent/core/command_service.rb

@@ -13,19 +13,6 @@ module Sequent
     # * Unit of Work is cleared
     #
     class CommandService
-      attr_accessor :configuration
-
-      # Create a command service with the given configuration.
-      #
-      #   +event_store+ The Sequent::Core::EventStore
-      #   +aggregate_repository+ The Sequent::Core::AggregateRepository
-      #   +transaction_provider+ How to do transaction management.
-      #   +command_handlers+ List of command handlers that need to handle commands
-      #   +command_filters+ List of filter that respond_to :execute(command). Can be useful to do extra checks (security and such).
-      def initialize(configuration)
-        self.configuration = configuration
-      end
-
       # Executes the given commands in a single transactional block as implemented by the +transaction_provider+
       #
       # For each command:
@@ -34,21 +21,8 @@ module Sequent
       # * If the command is valid all +command_handlers+ that +handles_message?+ is invoked
       # * The +repository+ commits the command and all uncommitted_events resulting from the command
       def execute_commands(*commands)
-        begin
-          transaction_provider.transactional do
-            commands.each do |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.class.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
-              repository.commit(parsed_command)
-            end
-          end
-        ensure
-          repository.clear
-        end
-
+        commands.each { |command| command_queue.push(command) }
+        process_commands
       end
 
       def remove_event_handler(clazz)
@@ -57,24 +31,52 @@ module Sequent
 
       private
 
+      def process_commands
+        Sequent::Util.skip_if_already_processing(:command_service_process_commands) do
+          begin
+            transaction_provider.transactional do
+              while(!command_queue.empty?) do
+                process_command(command_queue.pop)
+              end
+            end
+          ensure
+            command_queue.clear
+            repository.clear
+          end
+        end
+      end
+
+      def process_command(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.class.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
+        repository.commit(parsed_command)
+      end
+
+      def command_queue
+        Thread.current[:command_service_commands] ||= Queue.new
+      end
+
       def event_store
-        configuration.event_store
+        Sequent.configuration.event_store
       end
 
       def repository
-        configuration.aggregate_repository
+        Sequent.configuration.aggregate_repository
       end
 
       def filters
-        configuration.command_filters
+        Sequent.configuration.command_filters
       end
 
       def transaction_provider
-        configuration.transaction_provider
+        Sequent.configuration.transaction_provider
       end
 
       def command_handlers
-        configuration.command_handlers
+        Sequent.configuration.command_handlers
       end
     end
 

data/lib/sequent/core/core.rb

@@ -16,3 +16,4 @@ require_relative 'command_record'
 require_relative 'aggregate_snapshotter'
 require_relative 'workflow'
 require_relative 'random_uuid_generator'
+require_relative 'event_publisher'

data/lib/sequent/core/event_publisher.rb

@@ -0,0 +1,63 @@
+module Sequent
+  module Core
+    #
+    # EventPublisher ensures that, for every thread, events will be published in the order in which they are queued for publishing.
+    #
+    # This potentially introduces a wrinkle into your plans: You therefore should not split a "unit of work" across multiple threads.
+    #
+    # If you want other behaviour, you are free to implement your own version of EventPublisher and configure Sequent to use it.
+    #
+    class EventPublisher
+      class PublishEventError < RuntimeError
+        attr_reader :event_handler_class, :event
+
+        def initialize(event_handler_class, event)
+          @event_handler_class = event_handler_class
+          @event = event
+        end
+
+        def message
+          "Event Handler: #{@event_handler_class.inspect}\nEvent: #{@event.inspect}\nCause: #{cause.inspect}"
+        end
+      end
+
+      def publish_events(events)
+        return if configuration.disable_event_handlers
+        events.each { |event| events_queue.push(event) }
+        process_events
+      end
+
+      private
+
+      def events_queue
+        Thread.current[:events_queue] ||= Queue.new
+      end
+
+      def process_events
+        Sequent::Util.skip_if_already_processing(:events_queue_lock) do
+          begin
+            while(!events_queue.empty?) do
+              process_event(events_queue.pop)
+            end
+          ensure
+            events_queue.clear
+          end
+        end
+      end
+
+      def process_event(event)
+        configuration.event_handlers.each do |handler|
+          begin
+            handler.handle_message event
+          rescue
+            raise PublishEventError.new(handler.class, event)
+          end
+        end
+      end
+
+      def configuration
+        Sequent.configuration
+      end
+    end
+  end
+end

data/lib/sequent/core/event_store.rb

@@ -9,19 +9,6 @@ module Sequent
       include ActiveRecord::ConnectionAdapters::Quoting
       extend Forwardable
 
-      class PublishEventError < RuntimeError
-        attr_reader :event_handler_class, :event
-
-        def initialize(event_handler_class, event)
-          @event_handler_class = event_handler_class
-          @event = event
-        end
-
-        def message
-          "Event Handler: #{@event_handler_class.inspect}\nEvent: #{@event.inspect}\nCause: #{cause.inspect}"
-        end
-      end
-
       class OptimisticLockingError < RuntimeError
       end
 
@@ -38,11 +25,7 @@ module Sequent
 
       end
 
-      attr_accessor :configuration
-      def_delegators :@configuration, :stream_record_class, :event_record_class, :snapshot_event_class, :event_handlers
-
-      def initialize(configuration = Sequent.configuration)
-        self.configuration = configuration
+      def initialize
         @event_types = ThreadSafe::Cache.new
       end
 
@@ -55,7 +38,7 @@ module Sequent
       #
       def commit_events(command, streams_with_events)
         store_events(command, streams_with_events)
-        publish_events(streams_with_events.flat_map { |_, events| events }, event_handlers)
+        publish_events(streams_with_events.flat_map { |_, events| events })
       end
 
       ##
@@ -68,18 +51,10 @@ module Sequent
       def load_events_for_aggregates(aggregate_ids)
         return [] if aggregate_ids.none?
 
-        streams = stream_record_class.where(aggregate_id: aggregate_ids)
+        streams = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_ids)
 
-        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 in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.join(",")})
-  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 in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.join(",")})), 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|
+        query = aggregate_ids.uniq.map { |aggregate_id| aggregate_query(aggregate_id) }.join(" UNION ALL ")
+        events = Sequent.configuration.event_record_class.connection.select_all(query).map! do |event_hash|
           deserialize_event(event_hash)
         end
 
@@ -88,8 +63,21 @@ WHERE aggregate_id in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.
           .map { |aggregate_id, _events| [streams.find { |stream_record| stream_record.aggregate_id == aggregate_id }.event_stream, _events] }
       end
 
+      def aggregate_query(aggregate_id)
+        %Q{(
+SELECT event_type, event_json
+  FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS o
+WHERE aggregate_id = #{quote(aggregate_id)}
+AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
+                                 FROM #{quote_table_name Sequent.configuration.event_record_class.table_name} AS i
+                                 WHERE event_type = #{quote Sequent.configuration.snapshot_event_class.name}
+                                   AND i.aggregate_id = #{quote(aggregate_id)}), 0)
+ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuration.snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
+)}
+      end
+
       def stream_exists?(aggregate_id)
-        stream_record_class.exists?(aggregate_id: aggregate_id)
+        Sequent.configuration.stream_record_class.exists?(aggregate_id: aggregate_id)
       end
 
       ##
@@ -100,7 +88,7 @@ WHERE aggregate_id in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.
       def replay_events
         warn "[DEPRECATION] `replay_events` is deprecated in favor of `replay_events_from_cursor`"
         events = yield.map { |event_hash| deserialize_event(event_hash) }
-        publish_events(events, event_handlers)
+        publish_events(events)
       end
 
       ##
@@ -118,7 +106,7 @@ WHERE aggregate_id in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.
         ids_replayed = []
         cursor.each_row(block_size: block_size).each do |record|
           event = deserialize_event(record)
-          publish_events([event], event_handlers)
+          publish_events([event])
           progress += 1
           ids_replayed << record['id']
           if progress % block_size == 0
@@ -141,25 +129,25 @@ WHERE aggregate_id in (#{aggregate_ids.map{ |aggregate_id| quote(aggregate_id)}.
       # 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
+        stream_table = quote_table_name Sequent.configuration.stream_record_class.table_name
+        event_table = quote_table_name Sequent.configuration.event_record_class.table_name
         query = %Q{
 SELECT aggregate_id
   FROM #{stream_table} stream
  WHERE aggregate_id::varchar > 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))
+         (SELECT MAX(events.sequence_number) FROM #{event_table} events WHERE events.event_type <> #{quote Sequent.configuration.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 Sequent.configuration.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'] }
+        Sequent.configuration.event_record_class.connection.select_all(query).map { |x| x['aggregate_id'] }
       end
 
       def find_event_stream(aggregate_id)
-        record = stream_record_class.where(aggregate_id: aggregate_id).first
+        record = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_id).first
         if record
           record.event_stream
         else
@@ -170,7 +158,7 @@ SELECT aggregate_id
       private
 
       def column_names
-        @column_names ||= event_record_class.column_names.reject { |c| c == 'id' }
+        @column_names ||= Sequent.configuration.event_record_class.column_names.reject { |c| c == 'id' }
       end
 
       def deserialize_event(event_hash)
@@ -185,24 +173,15 @@ SELECT aggregate_id
         @event_types.fetch_or_store(event_type) { |k| Class.const_get(k) }
       end
 
-      def publish_events(events, event_handlers)
-        return if configuration.disable_event_handlers
-        event_handlers.each do |handler|
-          events.each do |event|
-            begin
-              handler.handle_message event
-            rescue
-              raise PublishEventError.new(handler.class, event)
-            end
-          end
-        end
+      def publish_events(events)
+        Sequent.configuration.event_publisher.publish_events(events)
       end
 
       def store_events(command, streams_with_events = [])
         command_record = CommandRecord.create!(command: command)
         event_records = streams_with_events.flat_map do |event_stream, uncommitted_events|
           unless event_stream.stream_record_id
-            stream_record = stream_record_class.new
+            stream_record = Sequent.configuration.stream_record_class.new
             stream_record.event_stream = event_stream
             stream_record.save!
             event_stream.stream_record_id = stream_record.id
@@ -214,21 +193,21 @@ SELECT aggregate_id
               aggregate_id: event.aggregate_id,
               sequence_number: event.sequence_number,
               event_type: event.class.name,
-              event_json: event_record_class.serialize_to_json(event),
+              event_json: Sequent.configuration.event_record_class.serialize_to_json(event),
               created_at: event.created_at
             }
             values = values.merge(organization_id: event.organization_id) if event.respond_to?(:organization_id)
 
-            event_record_class.new(values)
+            Sequent.configuration.event_record_class.new(values)
           end
         end
-        connection = event_record_class.connection
+        connection = Sequent.configuration.event_record_class.connection
         values = event_records
                    .map { |r| "(#{column_names.map { |c| connection.quote(r[c.to_sym]) }.join(',')})" }
                    .join(',')
         columns = column_names.map { |c| connection.quote_column_name(c) }.join(',')
-        sql = %Q{insert into #{connection.quote_table_name(event_record_class.table_name)} (#{columns}) values #{values}}
-        event_record_class.connection.insert(sql)
+        sql = %Q{insert into #{connection.quote_table_name(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}}
+        Sequent.configuration.event_record_class.connection.insert(sql)
       rescue ActiveRecord::RecordNotUnique
         fail OptimisticLockingError.new
       end

data/lib/sequent/core/record_sessions/active_record_session.rb

@@ -3,6 +3,7 @@ require 'active_record'
 module Sequent
   module Core
     module RecordSessions
+
       #
       # Session objects are used to update view state
       #
@@ -33,6 +34,21 @@ module Sequent
           record
         end
 
+        def create_records(record_class, array_of_value_hashes)
+          table = record_class.arel_table
+
+          query = array_of_value_hashes.map do |values|
+            insert_manager = new_insert_manager
+            insert_manager.into(table)
+            insert_manager.insert(values.map do |key, value|
+              convert_to_values(key, table, value)
+            end)
+            insert_manager.to_sql
+          end.join(";")
+
+          execute(query)
+        end
+
         def create_or_update_record(record_class, values, created_at = Time.now)
           record = get_record(record_class, values)
           unless record
@@ -91,8 +107,22 @@ module Sequent
           record_class.unscoped.new(values)
         end
 
-      end
+        def new_insert_manager
+          if ActiveRecord::VERSION::MAJOR <= 4
+            Arel::InsertManager.new(ActiveRecord::Base)
+          else
+            Arel::InsertManager.new
+          end
+        end
 
+        def convert_to_values(key, table, value)
+          if ActiveRecord::VERSION::MAJOR <= 4
+            [table[key], value]
+          else
+            [table[key], table.type_cast_for_database(key, value)]
+          end
+        end
+      end
     end
   end
 end

data/lib/sequent/core/record_sessions/replay_events_session.rb

@@ -1,5 +1,6 @@
 require 'set'
 require 'active_record'
+require 'csv'
 
 module Sequent
   module Core
@@ -198,6 +199,10 @@ module Sequent
           record
         end
 
+        def create_records(record_class, array_of_value_hashes)
+          array_of_value_hashes.each { |values| create_record(record_class, values) }
+        end
+
         def create_or_update_record(record_class, values, created_at = Time.now)
           record = get_record(record_class, values)
           unless record
@@ -287,10 +292,8 @@ module Sequent
               csv = CSV.new("")
               column_names = clazz.column_names.reject { |name| name == "id" }
               records.each do |obj|
-                begin
-                  csv << column_names.map do |column_name|
-                    @column_cache[clazz.name][column_name].type_cast_for_database(obj[column_name])
-                  end
+                csv << column_names.map do |column_name|
+                  ActiveRecord::Base.connection.type_cast(obj[column_name], @column_cache[clazz.name][column_name])
                 end
               end
 
@@ -311,7 +314,7 @@ module Sequent
                 prepared_values = (1..column_names.size).map { |i| "$#{i}" }.join(",")
                 records.each do |r|
                   values = column_names.map do |column_name|
-                    @column_cache[clazz.name][column_name].type_cast_for_database(r[column_name.to_sym])
+                    ActiveRecord::Base.connection.type_cast(r[column_name.to_sym], @column_cache[clazz.name][column_name])
                   end
                   inserts << values
                 end

data/lib/sequent/core/sequent_oj.rb

@@ -6,7 +6,7 @@ module Sequent
     class Oj
       ::Oj.default_options = {
         bigdecimal_as_decimal: false,
-        mode: :compat,
+        mode: :rails,
       }
 
       def self.strict_load(json)

data/lib/sequent/sequent.rb

@@ -1,4 +1,5 @@
 require_relative 'core/core'
+require_relative 'util/util'
 require_relative 'migrations/migrations'
 require_relative 'configuration'
 

data/lib/sequent/support/view_projection.rb

@@ -43,11 +43,11 @@ module Sequent
       extend ActiveRecord::ConnectionAdapters::Quoting
 
       ORDERED_BY_STREAM = lambda do |event_store|
-        event_records = quote_table_name(event_store.event_record_class.table_name)
-        stream_records = quote_table_name(event_store.stream_record_class.table_name)
-        snapshot_event_type = quote(event_store.snapshot_event_class)
+        event_records = quote_table_name(Sequent.configuration.event_record_class.table_name)
+        stream_records = quote_table_name(Sequent.configuration.stream_record_class.table_name)
+        snapshot_event_type = quote(Sequent.configuration.snapshot_event_class)
 
-        event_store.event_record_class
+        Sequent.configuration.event_record_class
           .select("event_type, event_json")
           .joins("INNER JOIN #{stream_records} ON #{event_records}.stream_record_id = #{stream_records}.id")
           .where("event_type <> #{snapshot_event_type}")

data/lib/sequent/test/command_handler_helpers.rb

@@ -1,4 +1,5 @@
 require 'thread_safe'
+require 'sequent/core/event_store'
 
 module Sequent
   module Test
@@ -22,9 +23,9 @@ module Sequent
     # describe InvoiceCommandHandler do
     #
     #   before :each do
-    #     @event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
-    #     @repository = Sequent::Core::AggregateRepository.new(@event_store)
-    #     @command_handler = InvoiceCommandHandler.new(@repository)
+    #     Sequent.configuration.event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
+    #     Sequent.configuration.command_handlers = [] # add your command handlers here
+    #     Sequent.configuration.event_handlers = [] # add you event handlers (eg, workflows) here
     #   end
     #
     #   it "marks an invoice as paid" do
@@ -37,6 +38,8 @@ module Sequent
     module CommandHandlerHelpers
 
       class FakeEventStore
+        extend Forwardable
+
         def initialize
           @event_streams = {}
           @all_events = {}
@@ -73,6 +76,11 @@ module Sequent
             @all_events[event_stream.aggregate_id] += serialized
             @stored_events += serialized
           end
+          publish_events(streams_with_events.flat_map { |_, events| events })
+        end
+
+        def publish_events(events)
+          Sequent.configuration.event_publisher.publish_events(events)
         end
 
         def given_events(events)
@@ -122,22 +130,18 @@ module Sequent
       end
 
       def given_events *events
-        @event_store.given_events(events.flatten(1))
+        Sequent.configuration.event_store.given_events(events.flatten(1))
       end
 
       def when_command command
-        raise "@command_handler is mandatory when using the #{self.class}" unless @command_handler
-        raise "Command handler #{@command_handler} cannot handle command #{command}, please configure the command type (forgot an include in the command class?)" unless @command_handler.class.handles_message?(command)
-        @command_handler.handle_message(command)
-        @repository.commit(command)
-        @repository.clear
+        Sequent.configuration.command_service.execute_commands command
       end
 
       def then_events(*expected_events)
         expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
-        expect(@event_store.stored_events.map(&:class)).to eq(expected_classes)
+        expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
-        @event_store.stored_events.zip(expected_events.flatten(1)).each_with_index do |(actual, expected), index|
+        Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each_with_index do |(actual, expected), index|
           next if expected.class == Class
           _actual = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
           _expected = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))

data/lib/sequent/test/event_handler_helpers.rb

@@ -41,9 +41,9 @@ module Sequent
 
       def then_events(*expected_events)
         expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
-        expect(@event_store.stored_events.map(&:class)).to eq(expected_classes)
+        expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
-        @event_store.stored_events.zip(expected_events.flatten(1)).each do |actual, expected|
+        Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each do |actual, expected|
           next if expected.class == Class
           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

data/lib/sequent/util/skip_if_already_processing.rb

@@ -0,0 +1,15 @@
+module Sequent
+  module Util
+    def self.skip_if_already_processing(already_processing_key, &block)
+      return if Thread.current[already_processing_key]
+
+      begin
+        Thread.current[already_processing_key] = true
+
+        block.yield
+      ensure
+        Thread.current[already_processing_key] = nil
+      end
+    end
+  end
+end

data/lib/sequent/util/util.rb

@@ -0,0 +1 @@
+require_relative 'skip_if_already_processing'

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Lars Vonk
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-30 00:00:00.000000000 Z
+date: 2017-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.17.5
+        version: 3.3.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.17.5
+        version: 3.3.9
 - !ruby/object:Gem::Dependency
   name: thread_safe
   requirement: !ruby/object:Gem::Requirement
@@ -214,6 +214,7 @@ files:
 - lib/sequent/core/command_service.rb
 - lib/sequent/core/core.rb
 - lib/sequent/core/event.rb
+- lib/sequent/core/event_publisher.rb
 - lib/sequent/core/event_record.rb
 - lib/sequent/core/event_store.rb
 - lib/sequent/core/ext/ext.rb
@@ -239,7 +240,6 @@ 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/transactions/active_record_transaction_provider.rb
 - lib/sequent/core/transactions/no_transactions.rb
@@ -259,6 +259,8 @@ files:
 - lib/sequent/test/event_handler_helpers.rb
 - lib/sequent/test/event_stream_helpers.rb
 - lib/sequent/test/time_comparison.rb
+- lib/sequent/util/skip_if_already_processing.rb
+- lib/sequent/util/util.rb
 - lib/version.rb
 homepage: https://github.com/zilverline/sequent
 licenses:
@@ -280,7 +282,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Event sourcing framework for Ruby

data/lib/sequent/core/snapshots.rb

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