sequent 4.0.0 → 4.3.0

data/lib/sequent/core/command_service.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'transactions/no_transactions'
 require_relative 'current_event'
 
@@ -39,7 +41,7 @@ module Sequent
       end
 
       def remove_event_handler(clazz)
-        warn "[DEPRECATION] `remove_event_handler` is deprecated"
+        warn '[DEPRECATION] `remove_event_handler` is deprecated'
         event_store.remove_event_handler(clazz)
       end
 
@@ -47,17 +49,13 @@ module Sequent
 
       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
-              Sequent::Util.done_processing(:command_service_process_commands)
-            end
-          ensure
-            command_queue.clear
-            repository.clear
+          transaction_provider.transactional do
+            process_command(command_queue.pop) until command_queue.empty?
+            Sequent::Util.done_processing(:command_service_process_commands)
           end
+        ensure
+          command_queue.clear
+          repository.clear
         end
       end
 
@@ -68,12 +66,12 @@ module Sequent
 
         filters.each { |filter| filter.execute(command) }
 
-        I18n.with_locale(Sequent.configuration.error_locale_resolver.call) do
-          raise CommandNotValid.new(command) unless command.valid?
-        end
+        fail CommandNotValid, 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 }
+        command_handlers.select do |h|
+          h.class.handles_message?(parsed_command)
+        end.each { |h| h.handle_message parsed_command }
         repository.commit(parsed_command)
       end
 
@@ -108,12 +106,14 @@ module Sequent
 
       def initialize(command)
         @command = command
-        msg = @command.respond_to?(:aggregate_id) ? " #{@command.aggregate_id}" : ""
-        super "Invalid command #{@command.class.to_s}#{msg}, errors: #{@command.validation_errors}"
+        msg = @command.respond_to?(:aggregate_id) ? " #{@command.aggregate_id}" : ''
+        super "Invalid command #{@command.class}#{msg}, errors: #{@command.validation_errors}"
       end
 
       def errors(prefix = nil)
-        @command.validation_errors(prefix)
+        I18n.with_locale(Sequent.configuration.error_locale_resolver.call) do
+          @command.validation_errors(prefix)
+        end
       end
 
       def errors_with_command_prefix

data/lib/sequent/core/core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sequent_oj'
 require_relative 'helpers/helpers'
 require_relative 'persistors/persistors'

data/lib/sequent/core/current_event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     class CurrentEvent

data/lib/sequent/core/event.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require_relative 'helpers/string_support'
 require_relative 'helpers/equal_support'
@@ -7,16 +9,17 @@ require_relative 'helpers/copyable'
 module Sequent
   module Core
     class Event
-      include Sequent::Core::Helpers::StringSupport,
-              Sequent::Core::Helpers::EqualSupport,
-              Sequent::Core::Helpers::AttributeSupport,
-              Sequent::Core::Helpers::Copyable
+      include Sequent::Core::Helpers::Copyable
+      include Sequent::Core::Helpers::AttributeSupport
+      include Sequent::Core::Helpers::EqualSupport
+      include Sequent::Core::Helpers::StringSupport
       attrs aggregate_id: String, sequence_number: Integer, created_at: DateTime
 
       def initialize(args = {})
         update_all_attributes args
-        raise "Missing aggregate_id" unless @aggregate_id
-        raise "Missing sequence_number" unless @sequence_number
+        fail 'Missing aggregate_id' unless @aggregate_id
+        fail 'Missing sequence_number' unless @sequence_number
+
         @created_at ||= DateTime.now
       end
 
@@ -24,22 +27,24 @@ module Sequent
         result = {}
         instance_variables
           .reject { |k| payload_variables.include?(k) }
-          .select { |k| self.class.types.keys.include?(to_attribute_name(k))}
+          .select { |k| self.class.types.keys.include?(to_attribute_name(k)) }
           .each do |k|
-          result[k.to_s[1 .. -1].to_sym] = instance_variable_get(k)
+          result[k.to_s[1..-1].to_sym] = instance_variable_get(k)
         end
         result
       end
+
       protected
+
       def payload_variables
-        %i{@aggregate_id @sequence_number @created_at}
+        %i[@aggregate_id @sequence_number @created_at]
       end
 
       private
+
       def to_attribute_name(instance_variable_name)
-        instance_variable_name[1 .. -1].to_sym
+        instance_variable_name[1..-1].to_sym
       end
-
     end
 
     class SnapshotEvent < Event

data/lib/sequent/core/event_publisher.rb

@@ -1,17 +1,23 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     #
-    # EventPublisher ensures that, for every thread, events will be published in the order in which they are queued for publishing.
+    # 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.
+    # 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.
+    # 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)
+          super()
           @event_handler_class = event_handler_class
           @event = event
         end
@@ -23,6 +29,7 @@ module Sequent
 
       def publish_events(events)
         return if configuration.disable_event_handlers
+
         events.each { |event| events_queue.push(event) }
         process_events
       end
@@ -35,13 +42,9 @@ module Sequent
 
       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
+          process_event(events_queue.pop) until events_queue.empty?
+        ensure
+          events_queue.clear
         end
       end
 
@@ -51,11 +54,9 @@ module Sequent
         Sequent.logger.debug("[EventPublisher] Publishing event #{event.class}")
 
         configuration.event_handlers.each do |handler|
-          begin
-            handler.handle_message event
-          rescue
-            raise PublishEventError.new(handler.class, event)
-          end
+          handler.handle_message event
+        rescue StandardError
+          raise PublishEventError.new(handler.class, event)
         end
       end
 

data/lib/sequent/core/event_record.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require_relative 'sequent_oj'
-require_relative '../application_record.rb'
+require_relative '../application_record'
 
 module Sequent
   module Core
-
     # == Event Record Hooks
     #
     # These hooks are called during the life cycle of
@@ -27,7 +28,6 @@ module Sequent
     #     end
     #   end
     class EventRecordHooks
-
       # Called after assigning Sequent's event attributes to the +event_record+.
       #
       # *Params*
@@ -42,13 +42,12 @@ module Sequent
       def self.after_serialization(event_record, event)
         # noop
       end
-
     end
 
     module SerializesEvent
       def event
-        payload = Sequent::Core::Oj.strict_load(self.event_json)
-        Class.const_get(self.event_type).deserialize_from_json(payload)
+        payload = Sequent::Core::Oj.strict_load(event_json)
+        Class.const_get(event_type).deserialize_from_json(payload)
       end
 
       def event=(event)
@@ -76,7 +75,7 @@ module Sequent
     class EventRecord < Sequent::ApplicationRecord
       include SerializesEvent
 
-      self.table_name = "event_records"
+      self.table_name = 'event_records'
 
       belongs_to :stream_record
       belongs_to :command_record
@@ -98,6 +97,7 @@ module Sequent
 
       def find_origin(record)
         return find_origin(record.parent) if record.parent.present?
+
         record
       end
     end

data/lib/sequent/core/event_store.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 require_relative 'event_record'
 require_relative 'sequent_oj'
 
 module Sequent
   module Core
-
     class EventStore
       include ActiveRecord::ConnectionAdapters::Quoting
       extend Forwardable
@@ -16,13 +17,13 @@ module Sequent
         attr_reader :event_hash
 
         def initialize(event_hash)
+          super()
           @event_hash = event_hash
         end
 
         def message
           "Event hash: #{event_hash.inspect}\nCause: #{cause.inspect}"
         end
-
       end
 
       def initialize
@@ -41,7 +42,7 @@ module Sequent
       #   `StreamRecord` to arrays ordered uncommitted `Event`s.
       #
       def commit_events(command, streams_with_events)
-        fail ArgumentError, "command is required" if command.nil?
+        fail ArgumentError, 'command is required' if command.nil?
 
         Sequent.logger.debug("[EventStore] Committing events for command #{command.class}")
 
@@ -50,7 +51,38 @@ module Sequent
       end
 
       ##
-      # Returns all events for the aggregate ordered by sequence_number
+      # Returns all events for the AggregateRoot ordered by sequence_number, disregarding snapshot events.
+      #
+      # This streaming is done in batches to prevent loading many events in memory all at once. A usecase for ignoring
+      # the snapshots is when events of a nested AggregateRoot need to be loaded up until a certain moment in time.
+      #
+      # @param aggregate_id Aggregate id of the AggregateRoot
+      # @param load_until The timestamp up until which you want to built the aggregate. Optional.
+      # @param &block Block that should be passed to handle the batches returned from this method
+      def stream_events_for_aggregate(aggregate_id, load_until: nil, &block)
+        stream = find_event_stream(aggregate_id)
+        fail ArgumentError, 'no stream found for this aggregate' if stream.blank?
+
+        q = Sequent
+          .configuration
+          .event_record_class
+          .where(aggregate_id: aggregate_id)
+          .where.not(event_type: Sequent.configuration.snapshot_event_class.name)
+          .order(:sequence_number)
+        q = q.where('created_at < ?', load_until) if load_until.present?
+        has_events = false
+
+        q.select('event_type, event_json').each_row do |event_hash|
+          has_events = true
+          event = deserialize_event(event_hash)
+          block.call([stream, event])
+        end
+        fail ArgumentError, 'no events for this aggregate' unless has_events
+      end
+
+      ##
+      # Returns all events for the aggregate ordered by sequence_number, loading them from the latest snapshot
+      # event onwards, if a snapshot is present
       #
       def load_events(aggregate_id)
         load_events_for_aggregates([aggregate_id])[0]
@@ -61,27 +93,36 @@ module Sequent
 
         streams = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_ids)
 
-        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|
+        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
 
         events
-          .group_by { |event| event.aggregate_id }
-          .map { |aggregate_id, _events| [streams.find { |stream_record| stream_record.aggregate_id == aggregate_id }.event_stream, _events] }
+          .group_by(&:aggregate_id)
+          .map do |aggregate_id, es|
+          [
+            streams.find do |stream_record|
+              stream_record.aggregate_id == aggregate_id
+            end.event_stream,
+            es,
+          ]
+        end
       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
-)}
+        <<~SQL.chomp
+          (
+          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
+          )
+        SQL
       end
 
       def stream_exists?(aggregate_id)
@@ -97,7 +138,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       # @param block that returns the events.
       # <b>DEPRECATED:</b> use <tt>replay_events_from_cursor</tt> instead.
       def replay_events
-        warn "[DEPRECATION] `replay_events` is deprecated in favor of `replay_events_from_cursor`"
+        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)
       end
@@ -109,8 +150,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       #
       # @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:,
+      def replay_events_from_cursor(get_events:, block_size: 2000,
                                     on_progress: PRINT_PROGRESS)
         progress = 0
         cursor = get_events.call
@@ -128,7 +168,7 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
         on_progress[progress, true, ids_replayed]
       end
 
-      PRINT_PROGRESS = lambda do |progress, done, _|
+      PRINT_PROGRESS = ->(progress, done, _) do
         if done
           Sequent.logger.debug "Done replaying #{progress} events"
         else
@@ -142,38 +182,34 @@ ORDER BY sequence_number ASC, (CASE event_type WHEN #{quote Sequent.configuratio
       def aggregates_that_need_snapshots(last_aggregate_id, limit = 10)
         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 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
-}
+        query = <<~SQL.chomp
+          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 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
+        SQL
         Sequent.configuration.event_record_class.connection.select_all(query).map { |x| x['aggregate_id'] }
       end
 
       def find_event_stream(aggregate_id)
         record = Sequent.configuration.stream_record_class.where(aggregate_id: aggregate_id).first
-        if record
-          record.event_stream
-        else
-          nil
-        end
+        record&.event_stream
       end
 
       private
 
       def column_names
         @column_names ||= Sequent
-                            .configuration
-                            .event_record_class
-                            .column_names
-                            .reject { |c| c == primary_key_event_records }
+          .configuration
+          .event_record_class
+          .column_names
+          .reject { |c| c == primary_key_event_records }
       end
 
       def primary_key_event_records
@@ -181,11 +217,11 @@ SELECT aggregate_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"))
+        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)
+      rescue StandardError
+        raise DeserializeEventError, event_hash
       end
 
       def resolve_event_type(event_type)
@@ -215,13 +251,15 @@ SELECT aggregate_id
         end
         connection = Sequent.configuration.event_record_class.connection
         values = event_records
-                   .map { |r| "(#{column_names.map { |c| connection.quote(r[c.to_sym]) }.join(',')})" }
-                   .join(',')
+          .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(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}}
+        sql = <<~SQL.chomp
+          insert into #{connection.quote_table_name(Sequent.configuration.event_record_class.table_name)} (#{columns}) values #{values}
+        SQL
         Sequent.configuration.event_record_class.connection.insert(sql, nil, primary_key_event_records)
       rescue ActiveRecord::RecordNotUnique
-        fail OptimisticLockingError.new
+        raise OptimisticLockingError
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Symbol
   def self.deserialize_from_json(value)
     value.blank? ? nil : value.try(:to_sym)
@@ -25,19 +27,25 @@ end
 class BigDecimal
   def self.deserialize_from_json(value)
     return nil if value.nil?
+
     BigDecimal(value)
   end
 end
 
 module Boolean
   def self.deserialize_from_json(value)
-    value.nil? ? nil : (value.present? ? value : false)
+    if value.nil?
+      nil
+    else
+      (value.present? ? value : false)
+    end
   end
 end
 
 class Date
   def self.from_params(value)
     return value if value.is_a?(Date)
+
     value.blank? ? nil : Date.iso8601(value.dup)
   rescue ArgumentError
     value

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     module Helpers
@@ -5,7 +7,8 @@ module Sequent
         attr_accessor :item_type
 
         def initialize(item_type)
-          raise "needs a item_type" unless item_type
+          fail 'needs a item_type' unless item_type
+
           @item_type = item_type
         end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model/validator'
 
 module Sequent
@@ -21,24 +23,23 @@ module Sequent
       #   validates_with Sequent::Core::AssociationValidator, associations: [:trainee]
       #
       class AssociationValidator < ActiveModel::Validator
-
         def initialize(options = {})
           super
-          raise "Must provide ':associations' to validate" unless options[:associations].present?
+          fail "Must provide ':associations' to validate" unless options[:associations].present?
         end
 
         def validate(record)
           associations = options[:associations]
           associations = [associations] unless associations.instance_of?(Array)
           associations.each do |association|
-            value = record.instance_variable_get("@#{association.to_s}")
+            value = record.instance_variable_get("@#{association}")
             if value && incorrect_type?(value, record, association)
               record.errors.add(association, "is not of type #{describe_type(record.class.types[association])}")
-            elsif value && value.is_a?(Array)
+            elsif value&.is_a?(Array)
               item_type = record.class.types.fetch(association).item_type
-              record.errors.add(association, "is invalid") unless validate_all(value, item_type).all?
-            else
-              record.errors.add(association, "is invalid") if value && value.invalid?
+              record.errors.add(association, 'is invalid') unless validate_all(value, item_type).all?
+            elsif value&.invalid?
+              record.errors.add(association, 'is invalid')
             end
           end
         end
@@ -47,6 +48,7 @@ module Sequent
 
         def incorrect_type?(value, record, association)
           return unless record.class.respond_to?(:types)
+
           type = record.class.types[association]
           if type.respond_to?(:candidate?)
             !type.candidate?(value)