sequent 3.3.1 → 4.1.0

data/lib/sequent/core/command_service.rb

@@ -1,26 +1,34 @@
+# frozen_string_literal: true
+
 require_relative 'transactions/no_transactions'
 require_relative 'current_event'
 
 module Sequent
   module Core
     #
-    # Single point in the application where subclasses of Sequent::Core::BaseCommand
-    # are executed. This will initiate the entire flow of:
+    # Single point in the application to get something done in Sequent.
+    # The CommandService handles all subclasses Sequent::Core::BaseCommand. Most common
+    # use is to subclass `Sequent::Command`.
+    #
+    # The CommandService is available via the shortcut method `Sequent.command_service`
+    #
+    # To use the CommandService please use:
     #
-    # * Validate command
-    # * Call correct Sequent::Core::BaseCommandHandler
-    # * CommandHandler decides which Sequent::Core::AggregateRoot (s) to call
-    # * Events are stored in the Sequent::Core::EventStore
-    # * Unit of Work is cleared
+    #   Sequent.command_service.execute_commands(...)
     #
     class CommandService
+      #
       # Executes the given commands in a single transactional block as implemented by the +transaction_provider+
       #
-      # For each command:
+      # For each Command:
+      #
+      # * Validate command
+      # * Call Sequent::CommandHandler's listening to the given Command
+      # * Store and publish Events
+      # * Any new Command's (from e.g. workflows) are queued for processing in the same transaction
+      #
+      # At the end the transaction is committed and the AggregateRepository's Unit of Work is cleared.
       #
-      # * All filters are executed. Any exception raised will rollback the transaction and propagate up
-      # * 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)
         commands.each do |command|
           if command.respond_to?(:event_aggregate_id) && CurrentEvent.current
@@ -33,6 +41,7 @@ module Sequent
       end
 
       def remove_event_handler(clazz)
+        warn '[DEPRECATION] `remove_event_handler` is deprecated'
         event_store.remove_event_handler(clazz)
       end
 
@@ -40,25 +49,29 @@ 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
-            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
 
       def process_command(command)
+        fail ArgumentError, 'command is required' if command.nil?
+
+        Sequent.logger.debug("[CommandService] Processing command #{command.class}")
+
         filters.each { |filter| filter.execute(command) }
 
-        raise CommandNotValid.new(command) unless command.valid?
+        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
 
@@ -89,15 +102,18 @@ module Sequent
 
     # Raised when BaseCommand.valid? returns false
     class CommandNotValid < ArgumentError
+      attr_reader :command
 
       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,23 +42,21 @@ 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
 
       def process_event(event)
+        fail ArgumentError, 'event is required' if event.nil?
+
+        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
@@ -33,10 +34,18 @@ module Sequent
       # Stores the events in the EventStore and publishes the events
       # to the registered event_handlers.
       #
-      # Streams_with_Events is an enumerable of pairs from
-      # `StreamRecord` to arrays of uncommitted `Event`s.
+      # The events are published according to the order in
+      # the tail of the given `streams_with_events` array pair.
+      #
+      # @param command The command that caused the Events
+      # @param streams_with_events is an enumerable of pairs from
+      #   `StreamRecord` to arrays ordered uncommitted `Event`s.
       #
       def commit_events(command, streams_with_events)
+        fail ArgumentError, 'command is required' if command.nil?
+
+        Sequent.logger.debug("[EventStore] Committing events for command #{command.class}")
+
         store_events(command, streams_with_events)
         publish_events(streams_with_events.flat_map { |_, events| events })
       end
@@ -53,40 +62,52 @@ 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)
         Sequent.configuration.stream_record_class.exists?(aggregate_id: aggregate_id)
       end
 
+      def events_exists?(aggregate_id)
+        Sequent.configuration.event_record_class.exists?(aggregate_id: aggregate_id)
+      end
       ##
       # 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
-        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
@@ -98,8 +119,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
@@ -117,7 +137,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
@@ -131,42 +151,46 @@ 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 == 'id' }
+        @column_names ||= Sequent
+          .configuration
+          .event_record_class
+          .column_names
+          .reject { |c| c == primary_key_event_records }
+      end
+
+      def primary_key_event_records
+        @primary_key_event_records ||= Sequent.configuration.event_record_class.primary_key
       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)
@@ -196,13 +220,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}}
-        Sequent.configuration.event_record_class.connection.insert(sql)
+        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)