sequent 0.1.10 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17b7ed3c1ef96f46ab49ba1f980e06d596b50a30
-  data.tar.gz: cc6ab65e25cfbe2822a88aaf4308683d4ba18eab
+  metadata.gz: f1c376e79b2afb9c653058f4cb38e7d24bb7d742
+  data.tar.gz: 751c997c10407d7dd073b70b268ed69d16d1b459
 SHA512:
-  metadata.gz: 0cc5a1eabb3991255cbbf40fc4bdb50a25bb57dcec04f7a81a624307beb719efe225acfdf541291524b48e699ea91f3dc0886e1ce4965de1b2bfb8155466ea90
-  data.tar.gz: 22461d8b930f1fea40c72032bd9115af5e21ca19ef63cd460a7ebe80ddd8cf5e7a61518b3971923937fa14ca0d024d2bb42747c73ad8202881235a8a8fe18766
+  metadata.gz: 042064fb131306a5197e035330dceb3e467c2031f73932777286ec72219545ef7fcc5bbd3b0322177801d994e87adf66735be07e4b03fbf2e725d209b11e8b09
+  data.tar.gz: 777558493270ceeb8e80038e6b2336bfebbdbb103e74c341f676e53599971e8723862b3b6aa424d008f294ff78108a580652f31a90600fa90a275387696ba5f2

data/db/sequent_schema.rb

@@ -2,7 +2,6 @@ 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
@@ -12,7 +11,6 @@ ActiveRecord::Schema.define do
   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
@@ -31,7 +29,6 @@ CREATE UNIQUE INDEX unique_event_per_aggregate ON event_records (
 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"
 

data/lib/sequent/configuration.rb

@@ -19,6 +19,10 @@ module Sequent
 
     attr_accessor :event_handlers
 
+    attr_accessor :uuid_generator
+
+    attr_accessor :disable_event_handlers
+
     def self.instance
       @instance ||= new
     end
@@ -27,6 +31,10 @@ module Sequent
       @instance = new
     end
 
+    def self.restore(configuration)
+      @instance = configuration
+    end
+
     def initialize
       self.command_handlers = []
       self.command_filters = []
@@ -38,6 +46,8 @@ module Sequent
       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.disable_event_handlers = false
     end
 
     def event_store=(event_store)

data/lib/sequent/core/aggregate_repository.rb

@@ -18,13 +18,13 @@ module Sequent
 
       attr_reader :event_store
 
-      class NonUniqueAggregateId < Exception
+      class NonUniqueAggregateId < StandardError
         def initialize(existing, new)
           super "Duplicate aggregate #{new} with same key as existing #{existing}"
         end
       end
 
-      class AggregateNotFound < Exception
+      class AggregateNotFound < StandardError
         def initialize(id)
           super "Aggregate with id #{id} not found"
         end
@@ -56,16 +56,49 @@ module Sequent
       # Loads aggregate by given id and class
       # Returns the one in the current Unit Of Work otherwise loads it from history.
       def load_aggregate(aggregate_id, clazz = nil)
-        result = aggregates.fetch(aggregate_id) do |_|
-          stream, events = @event_store.load_events(aggregate_id)
-          raise AggregateNotFound.new(aggregate_id) unless stream
+        load_aggregates([aggregate_id], clazz)[0]
+      end
+
+      ##
+      # Loads multiple aggregates at once.
+      # Returns the ones in the current Unit Of Work otherwise loads it from history.
+      #
+      # Note: This will load all the aggregates in memory, so querying 100s of aggregates
+      # with 100s of events could cause memory issues.
+      #
+      # Returns all aggregates or raises +AggregateNotFound+
+      # If +clazz+ is given and one of the aggregates is not of the correct type
+      # a +TypeError+ is raised.
+      #
+      # +aggregate_ids+ The ids of the aggregates to be loaded
+      # +clazz+ Optional argument that checks if all aggregates are of type +clazz+
+      def load_aggregates(aggregate_ids, clazz = nil)
+        fail ArgumentError.new('aggregate_ids is required') unless aggregate_ids
+        return [] if aggregate_ids.empty?
+
+        _aggregate_ids = aggregate_ids.uniq
+        _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|
           aggregate_class = Class.const_get(stream.aggregate_type)
-          aggregates[aggregate_id] = aggregate_class.load_from_history(stream, events)
+          aggregate_class.load_from_history(stream, events)
+        end
+
+        if _aggregates.count != _aggregate_ids.count
+          missing_aggregate_ids = _aggregate_ids - _aggregates.map(&:id)
+          raise AggregateNotFound.new(missing_aggregate_ids)
         end
 
-        raise TypeError, "#{result.class} is not a #{clazz}" if result && clazz && !(result.class <= clazz)
+        if clazz
+          _aggregates.each do |aggregate|
+            raise TypeError, "#{aggregate.class} is not a #{clazz}" if !(aggregate.class <= clazz)
+          end
+        end
 
-        result
+        _aggregates.map do |aggregate|
+          aggregates[aggregate.id] = aggregate
+        end
       end
 
       ##

data/lib/sequent/core/aggregate_root.rb

@@ -103,29 +103,5 @@ module Sequent
         @uncommitted_events << event
       end
     end
-
-    # You can use this class when running in a multi tenant environment
-    # It basically makes sure that the +organization_id+ (the tenant_id for historic reasons)
-    # is available for the subclasses
-    class TenantAggregateRoot < AggregateRoot
-      attr_reader :organization_id
-
-      def initialize(id, organization_id)
-        super(id)
-        @organization_id = organization_id
-      end
-
-      def load_from_history(stream, events)
-        raise "Empty history" if events.empty?
-        @organization_id = events.first.organization_id
-        super
-      end
-
-      protected
-
-      def build_event(event, params = {})
-        super(event, params.merge({organization_id: @organization_id}))
-      end
-    end
   end
 end

data/lib/sequent/core/aggregate_snapshotter.rb

@@ -6,7 +6,7 @@ module Sequent
 
     class AggregateSnapshotter < BaseCommandHandler
 
-      def handles_message?(message)
+      def self.handles_message?(message)
         message.is_a? SnapshotCommand
       end
 
@@ -27,7 +27,7 @@ module Sequent
         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
+        Sequent.logger.error("Failed to take snapshot for aggregate #{aggregate_id}: #{e}, #{e.inspect}")
       end
     end
   end

data/lib/sequent/core/base_command_handler.rb

@@ -26,16 +26,12 @@ module Sequent
         @repository = repository
       end
 
-      def handles_message?(command)
-        self.class.message_mapping.keys.include? command.class
-      end
-
       protected
-      def do_with_aggregate(command, clazz, aggregate_id = nil)
+
+      def do_with_aggregate(command, clazz = nil, aggregate_id = nil)
         aggregate = @repository.load_aggregate(aggregate_id.nil? ? command.aggregate_id : aggregate_id, clazz)
         yield aggregate if block_given?
       end
-
     end
   end
 end

data/lib/sequent/core/base_event_handler.rb

@@ -44,7 +44,7 @@ module Sequent
 
       def_delegators :@record_session, :update_record, :create_record, :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
+                     :find_records, :last_record, :execute
 
     end
 

data/lib/sequent/core/command.rb

@@ -25,6 +25,9 @@ module Sequent
         @created_at = DateTime.now
       end
 
+      def self.inherited(subclass)
+        Commands << subclass
+      end
     end
 
     module UpdateSequenceNumber
@@ -36,6 +39,26 @@ module Sequent
       end
     end
 
+    class Commands
+      class << self
+        def commands
+          @commands ||= []
+        end
+
+        def all
+          commands
+        end
+
+        def <<(command)
+          commands << command
+        end
+
+        def find(command_name)
+          commands.find { |c| c.name == command_name }
+        end
+      end
+    end
+
     # Most commonly used command
     # Command can be instantiated just by using:
     #
@@ -53,25 +76,10 @@ module Sequent
         raise ArgumentError, "Missing aggregate_id" if args[:aggregate_id].nil?
         super
       end
-
     end
 
     class UpdateCommand < Command
       include UpdateSequenceNumber
     end
-
-    class TenantCommand < Command
-      attrs organization_id: String
-
-      def initialize(args = {})
-        raise ArgumentError, "Missing organization_id" if args[:organization_id].nil?
-        super
-      end
-    end
-
-    class UpdateTenantCommand < TenantCommand
-      include UpdateSequenceNumber
-    end
-
   end
 end

data/lib/sequent/core/command_service.rb

@@ -41,7 +41,7 @@ module Sequent
 
               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 }
+              command_handlers.select { |h| h.class.handles_message?(parsed_command) }.each { |h| h.handle_message parsed_command }
               repository.commit(parsed_command)
             end
           end

data/lib/sequent/core/core.rb

@@ -11,8 +11,8 @@ require_relative 'command_service'
 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'
 require_relative 'workflow'
+require_relative 'random_uuid_generator'

data/lib/sequent/core/event.rb

@@ -42,29 +42,8 @@ module Sequent
 
     end
 
-    class TenantEvent < Event
-
-      attrs organization_id: String
-
-      def initialize(args = {})
-        super
-        raise "Missing organization_id" unless @organization_id
-      end
-
-      protected
-      def payload_variables
-        super << :"@organization_id"
-      end
-
-    end
-
-    class CreateEvent < TenantEvent
-
-    end
-
     class SnapshotEvent < Event
       attrs data: String
     end
-
   end
 end

data/lib/sequent/core/event_record.rb

@@ -16,7 +16,17 @@ module Sequent
         self.organization_id = event.organization_id if event.respond_to?(:organization_id)
         self.event_type = event.class.name
         self.created_at = event.created_at
-        self.event_json = Sequent::Core::Oj.dump(event.attributes)
+        self.event_json = self.class.serialize_to_json(event)
+      end
+
+      module ClassMethods
+        def serialize_to_json(event)
+          Sequent::Core::Oj.dump(event)
+        end
+      end
+
+      def self.included(host_class)
+        host_class.extend(ClassMethods)
       end
     end
 

data/lib/sequent/core/event_store.rb

@@ -9,6 +9,35 @@ 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
+
+      class DeserializeEventError < RuntimeError
+        attr_reader :event_hash
+
+        def initialize(event_hash)
+          @event_hash = event_hash
+        end
+
+        def message
+          "Event hash: #{event_hash.inspect}\nCause: #{cause.inspect}"
+        end
+
+      end
+
       attr_accessor :configuration
       def_delegators :@configuration, :stream_record_class, :event_record_class, :snapshot_event_class, :event_handlers
 
@@ -26,28 +55,37 @@ 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 }, event_handlers)
       end
 
       ##
       # Returns all events for the aggregate ordered by sequence_number
       #
       def load_events(aggregate_id)
-        stream = stream_record_class.where(aggregate_id: aggregate_id).first
-        return nil unless stream
+        load_events_for_aggregates([aggregate_id])[0]
+      end
+
+      def load_events_for_aggregates(aggregate_ids)
+        return [] if aggregate_ids.none?
+
+        streams = 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 = #{quote aggregate_id}
-   AND sequence_number >= COALESCE((SELECT MAX(sequence_number)
+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 = #{quote aggregate_id}), 0)
- ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote snapshot_event_class.name} THEN 0 ELSE 1 END) ASC
+                                       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|
           deserialize_event(event_hash)
         end
-        [stream.event_stream, events]
+
+        events
+          .group_by { |event| event.aggregate_id }
+          .map { |aggregate_id, _events| [streams.find { |stream_record| stream_record.aggregate_id == aggregate_id }.event_stream, _events] }
       end
 
       def stream_exists?(aggregate_id)
@@ -58,11 +96,47 @@ SELECT event_type, event_json
       # Replays all events in the event store to the registered event_handlers.
       #
       # @param block that returns the events.
+      # <b>DEPRECATED:</b> use <tt>replay_events_from_cursor</tt> instead.
       def replay_events
-        events = yield.map {|event_hash| deserialize_event(event_hash)}
+        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)
       end
 
+      ##
+      # Replays all events on an `EventRecord` cursor from the given block.
+      #
+      # Prefer this replay method if your db adapter supports cursors.
+      #
+      # @param get_events lambda that returns the events cursor
+      # @param on_progress lambda that gets called on substantial progress
+      def replay_events_from_cursor(block_size: 2000,
+                                    get_events:,
+                                    on_progress: PRINT_PROGRESS)
+        progress = 0
+        cursor = get_events.call
+        ids_replayed = []
+        cursor.each_row(block_size: block_size).each do |record|
+          event = deserialize_event(record)
+          publish_events([event], event_handlers)
+          progress += 1
+          ids_replayed << record['id']
+          if progress % block_size == 0
+            on_progress[progress, false, ids_replayed]
+            ids_replayed.clear
+          end
+        end
+        on_progress[progress, true, ids_replayed]
+      end
+
+      PRINT_PROGRESS = lambda do |progress, done, _|
+        if done
+          puts "Done replaying #{progress} events"
+        else
+          puts "Replayed #{progress} events"
+        end
+      end
+
       ##
       # Returns the ids of aggregates that need a new snapshot.
       #
@@ -72,7 +146,7 @@ SELECT event_type, event_json
         query = %Q{
 SELECT aggregate_id
   FROM #{stream_table} stream
- WHERE aggregate_id > COALESCE(#{quote last_aggregate_id}, '')
+ 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) -
@@ -81,7 +155,7 @@ SELECT aggregate_id
  LIMIT #{quote limit}
  FOR UPDATE
 }
-        event_record_class.connection.select_all(query).map {|x| x['aggregate_id']}
+        event_record_class.connection.select_all(query).map { |x| x['aggregate_id'] }
       end
 
       def find_event_stream(aggregate_id)
@@ -95,10 +169,16 @@ SELECT aggregate_id
 
       private
 
+      def column_names
+        @column_names ||= event_record_class.column_names.reject { |c| c == 'id' }
+      end
+
       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)
+      rescue
+        raise DeserializeEventError.new(event_hash)
       end
 
       def resolve_event_type(event_type)
@@ -106,28 +186,52 @@ SELECT aggregate_id
       end
 
       def publish_events(events, event_handlers)
-        events.each do |event|
-          event_handlers.each do |handler|
-            handler.handle_message event
+        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
       end
 
       def store_events(command, streams_with_events = [])
         command_record = CommandRecord.create!(command: command)
-        streams_with_events.each do |event_stream, uncommitted_events|
+        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.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)
+          uncommitted_events.map do |event|
+            values = {
+              command_record_id: command_record.id,
+              stream_record_id: event_stream.stream_record_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),
+              created_at: event.created_at
+            }
+            values = values.merge(organization_id: event.organization_id) if event.respond_to?(:organization_id)
+
+            event_record_class.new(values)
           end
         end
+        connection = 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)
+      rescue ActiveRecord::RecordNotUnique
+        fail OptimisticLockingError.new
       end
     end
-
   end
 end