sequent 3.3.1 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68422698850db5ac4fa36b805bec257d00d40e1937ae736359b423104e7486fc
-  data.tar.gz: 868cd1cc45201cb6b7d9cbaec96ec2de6053a4b8b1f55ac5aa4b00f0bee32755
+  metadata.gz: 5e0c606e57bb36fdcaeeb102904dd450a0ff9fc2a84fdd5aff7f365a914c45d3
+  data.tar.gz: ea03e8a0c7ab524ff8c73fded97a726edf3dff240b95db62496496d5a6a6d580
 SHA512:
-  metadata.gz: 0eec0c36ffc290976c7654ca6aa69f6b473e093303c465f92b25653426deabd186ed80cda350af0808faa978b2d1488861e92308fde5b35319c42731e5dd1a3e
-  data.tar.gz: 5649b65b48cca40d22dd6c375d48b46389d2cdcddcbe75ec0079ece9d12a4cdb4b3456470f032a16a16b0b0c27011b7ee5337b65c1e91a2b684566474054f3d5
+  metadata.gz: 10f78e12826549dcd0ea3677940b5b2cdbde26fb9ecdf2f5a1bca67d5dd8405447409417b6cd277bd554c3590a2a7a3814a0918ae79ceec2b6da9510d8d1fa3f
+  data.tar.gz: abde6abb5638e8ad3f4f2081eb1e9eada6588d4d74994a5a62a4ef761b9737277981a5c270e75297a5e508cc611031a2e779df43b3a70b3d5a9bb0b77c81ec34

data/bin/sequent

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 require_relative '../lib/sequent/generator'
 
 command = ARGV[0].to_s.strip
@@ -8,8 +10,8 @@ abort('Please specify a command. i.e. `sequent new myapp`') if ARGV[1..-1].empty
 args = ARGV[1..-1].map(&:to_s).map(&:strip)
 
 def new_project(args)
-  _args = args.dup
-  name = _args.shift
+  arguments = args.dup
+  name = arguments.shift
   abort('Please specify a directory name. i.e. `sequent new myapp`') if name.empty?
 
   Sequent::Generator::Project.new(name).execute
@@ -43,8 +45,8 @@ def new_project(args)
 end
 
 def generate_aggregate(args)
-  _args = args.dup
-  aggregate_name = _args.shift
+  arguments = args.dup
+  aggregate_name = arguments.shift
   abort('Please specify an aggregate name. i.e. `sequent g aggregate user`') unless args_valid?(aggregate_name)
 
   Sequent::Generator::Aggregate.new(aggregate_name).execute
@@ -52,41 +54,45 @@ def generate_aggregate(args)
 end
 
 def generate_command(args)
-  _args = args.dup
-  aggregate_name = _args.shift
-  command_name = _args.shift
-  attrs = _args
+  arguments = args.dup
+  aggregate_name = arguments.shift
+  command_name = arguments.shift
+  attrs = arguments
 
-  abort('Please specify an aggregate name and command name. i.e. `sequent g command user AddUser`') unless args_valid?(aggregate_name, command_name)
+  unless args_valid?(aggregate_name, command_name)
+    abort('Please specify an aggregate name and command name. i.e. `sequent g command user AddUser`')
+  end
   Sequent::Generator::Command.new(aggregate_name, command_name, attrs).execute
   puts "#{command_name} command has been added to #{aggregate_name}"
 end
 
 def generate_event(args)
-  _args = args.dup
-  aggregate_name = _args.shift
-  event_name = _args.shift
-  attrs = _args
-
-  abort('Please specify an aggregate name and event name. i.e. `sequent g event user AddUser`') unless args_valid?(aggregate_name, event_name)
+  arguments = args.dup
+  aggregate_name = arguments.shift
+  event_name = arguments.shift
+  attrs = arguments
+
+  abort('Please specify an aggregate name and event name. i.e. `sequent g event user AddUser`') unless args_valid?(
+    aggregate_name, event_name
+  )
   Sequent::Generator::Event.new(aggregate_name, event_name, attrs).execute
   puts "#{event_name} event has been added to #{aggregate_name}"
 end
 
 def generate(args)
-  _args = args.dup
-  entity = _args.shift
+  arguments = args.dup
+  entity = arguments.shift
   abort('Please specify a command. i.e. `sequent g aggregate user`') if entity.empty?
 
   case entity
-    when 'aggregate'
-      generate_aggregate(_args)
-    when 'command'
-      generate_command(_args)
-    when 'event'
-      generate_event(_args)
-    else
-      abort("Unknown argument #{entity} for `generate`. Try `sequent g aggregate user`")
+  when 'aggregate'
+    generate_aggregate(arguments)
+  when 'command'
+    generate_command(arguments)
+  when 'event'
+    generate_event(arguments)
+  else
+    abort("Unknown argument #{entity} for `generate`. Try `sequent g aggregate user`")
   end
 end
 

data/lib/notices.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# This file is for any notices such as deprecation warnings, which should appear
+# in the logs during app boot. Adding such warnings in other places causes
+# lots of noise with duplicated messages, whereas this file is only
+# run once.

data/lib/sequent/application_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 
 module Sequent

data/lib/sequent/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'core/event_store'
 require_relative 'core/command_service'
 require_relative 'core/transactions/no_transactions'
@@ -7,15 +9,15 @@ require 'logger'
 
 module Sequent
   class Configuration
-
     DEFAULT_VERSIONS_TABLE_NAME = 'sequent_versions'
     DEFAULT_REPLAYED_IDS_TABLE_NAME = 'sequent_replayed_ids'
 
     DEFAULT_MIGRATION_SQL_FILES_DIRECTORY = 'db/tables'
     DEFAULT_DATABASE_CONFIG_DIRECTORY = 'db'
+    DEFAULT_DATABASE_SCHEMA_DIRECTORY = 'db'
 
     DEFAULT_VIEW_SCHEMA_NAME = 'view_schema'
-    DEFAULT_EVENT_STORE_SCHEMA_NAME= 'sequent_schema'
+    DEFAULT_EVENT_STORE_SCHEMA_NAME = 'sequent_schema'
 
     MIGRATIONS_CLASS_NAME = 'Sequent::Migrations::Projectors'
 
@@ -28,39 +30,33 @@ module Sequent
 
     DEFAULT_STRICT_CHECK_ATTRIBUTES_ON_APPLY_EVENTS = false
 
-    attr_accessor :aggregate_repository
+    DEFAULT_ERROR_LOCALE_RESOLVER = -> { I18n.locale || :en }
 
-    attr_accessor :event_store,
+    attr_accessor :aggregate_repository,
+                  :event_store,
                   :command_service,
                   :event_record_class,
                   :stream_record_class,
                   :snapshot_event_class,
                   :transaction_provider,
-                  :event_publisher
-
-    attr_accessor :event_record_hooks_class
-
-    attr_accessor :command_handlers,
-                  :command_filters
-
-    attr_accessor :event_handlers
-
-    attr_accessor :uuid_generator
-
-    attr_accessor :disable_event_handlers
-
-    attr_accessor :logger
-
-
-    attr_accessor :migration_sql_files_directory,
+                  :event_publisher,
+                  :event_record_hooks_class,
+                  :command_handlers,
+                  :command_filters,
+                  :event_handlers,
+                  :uuid_generator,
+                  :disable_event_handlers,
+                  :logger,
+                  :error_locale_resolver,
+                  :migration_sql_files_directory,
                   :view_schema_name,
                   :offline_replay_persistor_class,
                   :online_replay_persistor_class,
                   :number_of_replay_processes,
                   :database_config_directory,
-                  :event_store_schema_name
-
-    attr_accessor :strict_check_attributes_on_apply_events
+                  :database_schema_directory,
+                  :event_store_schema_name,
+                  :strict_check_attributes_on_apply_events
 
     attr_reader :migrations_class_name,
                 :versions_table_name,
@@ -106,20 +102,22 @@ module Sequent
       self.offline_replay_persistor_class = DEFAULT_OFFLINE_REPLAY_PERSISTOR_CLASS
       self.online_replay_persistor_class = DEFAULT_ONLINE_REPLAY_PERSISTOR_CLASS
       self.database_config_directory = DEFAULT_DATABASE_CONFIG_DIRECTORY
+      self.database_schema_directory = DEFAULT_DATABASE_SCHEMA_DIRECTORY
       self.strict_check_attributes_on_apply_events = DEFAULT_STRICT_CHECK_ATTRIBUTES_ON_APPLY_EVENTS
 
-      self.logger = Logger.new(STDOUT).tap {|l| l.level = Logger::INFO }
+      self.logger = Logger.new(STDOUT).tap { |l| l.level = Logger::INFO }
+      self.error_locale_resolver = DEFAULT_ERROR_LOCALE_RESOLVER
     end
 
     def replayed_ids_table_name=(table_name)
-      fail ArgumentError.new('table_name can not be nil') unless table_name
+      fail ArgumentError, 'table_name can not be nil' unless table_name
 
       @replayed_ids_table_name = table_name
       Sequent::Migrations::ViewSchema::ReplayedIds.table_name = table_name
     end
 
     def versions_table_name=(table_name)
-      fail ArgumentError.new('table_name can not be nil') unless table_name
+      fail ArgumentError, 'table_name can not be nil' unless table_name
 
       @versions_table_name = table_name
       Sequent::Migrations::ViewSchema::Versions.table_name = table_name
@@ -127,9 +125,11 @@ module Sequent
 
     def migrations_class_name=(class_name)
       migration_class = Class.const_get(class_name)
-      fail ArgumentError.new("#{migration_class} must extend Sequent::Migrations::Projectors") unless migration_class <= Sequent::Migrations::Projectors
+      unless migration_class <= Sequent::Migrations::Projectors
+        fail ArgumentError, "#{migration_class} must extend Sequent::Migrations::Projectors"
+      end
+
       @migrations_class_name = class_name
     end
-
   end
 end

data/lib/sequent/core/aggregate_repository.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
     # Repository for aggregates.
@@ -38,7 +40,7 @@ module Sequent
       def add_aggregate(aggregate)
         existing = aggregates[aggregate.id]
         if existing && !existing.equal?(aggregate)
-          raise NonUniqueAggregateId.new(aggregate, aggregates[aggregate.id])
+          fail NonUniqueAggregateId.new(aggregate, aggregates[aggregate.id])
         else
           aggregates[aggregate.id] = aggregate
         end
@@ -69,30 +71,30 @@ module Sequent
       # +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
+        fail ArgumentError, '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)
+        unique_ids = aggregate_ids.uniq
+        result = aggregates.values_at(*unique_ids).compact
+        query_ids = unique_ids - result.map(&:id)
 
-        _aggregates += Sequent.configuration.event_store.load_events_for_aggregates(_query_ids).map do |stream, events|
+        result += 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
 
-        if _aggregates.count != _aggregate_ids.count
-          missing_aggregate_ids = _aggregate_ids - _aggregates.map(&:id)
-          raise AggregateNotFound.new(missing_aggregate_ids)
+        if result.count != unique_ids.count
+          missing_aggregate_ids = unique_ids - result.map(&:id)
+          fail AggregateNotFound, missing_aggregate_ids
         end
 
         if clazz
-          _aggregates.each do |aggregate|
-            raise TypeError, "#{aggregate.class} is not a #{clazz}" if !(aggregate.class <= clazz)
+          result.each do |aggregate|
+            fail TypeError, "#{aggregate.class} is not a #{clazz}" unless aggregate.class <= clazz
           end
         end
 
-        _aggregates.map do |aggregate|
+        result.map do |aggregate|
           aggregates[aggregate.id] = aggregate
         end
       end
@@ -100,11 +102,17 @@ module Sequent
       ##
       # Returns whether the event store has an aggregate with the given id
       def contains_aggregate?(aggregate_id)
-        Sequent.configuration.event_store.stream_exists?(aggregate_id)
+        Sequent.configuration.event_store.stream_exists?(aggregate_id) &&
+          Sequent.configuration.event_store.events_exists?(aggregate_id)
       end
 
       # Gets all uncommitted_events from the 'registered' aggregates
       # and stores them in the event store.
+      #
+      # The events given to the EventStore are ordered in loading order
+      # of the different AggregateRoot's. So Events are stored
+      # (and therefore published) in order in which they are `apply`-ed per AggregateRoot.
+      #
       # The command is 'attached' for traceability purpose so we can see
       # which command resulted in which events.
       #
@@ -113,8 +121,9 @@ module Sequent
       def commit(command)
         updated_aggregates = aggregates.values.reject { |x| x.uncommitted_events.empty? }
         return if updated_aggregates.empty?
+
         streams_with_events = updated_aggregates.map do |aggregate|
-          [ aggregate.event_stream, aggregate.uncommitted_events ]
+          [aggregate.event_stream, aggregate.uncommitted_events]
         end
         updated_aggregates.each(&:clear_events)
         store_events command, streams_with_events
@@ -130,6 +139,7 @@ module Sequent
       # A +HasUncommittedEvents+ is raised when there are uncommitted_events in the Unit of Work.
       def clear!
         fail HasUncommittedEvents if aggregates.values.any? { |x| !x.uncommitted_events.empty? }
+
         clear
       end
 

data/lib/sequent/core/aggregate_root.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'base64'
 require_relative 'helpers/message_handler'
 require_relative 'helpers/autoset_attributes'
 require_relative 'stream_record'
+require_relative 'aggregate_roots'
 
 module Sequent
   module Core
-
     module SnapshotConfiguration
       module ClassMethods
         ##
@@ -40,13 +42,20 @@ module Sequent
 
       attr_reader :id, :uncommitted_events, :sequence_number, :event_stream
 
+      def self.inherited(subclass)
+        super
+        AggregateRoots << subclass
+      end
+
       def self.load_from_history(stream, events)
         first, *rest = events
         if first.is_a? SnapshotEvent
+          # rubocop:disable Security/MarshalLoad
           aggregate_root = Marshal.load(Base64.decode64(first.data))
+          # rubocop:enable Security/MarshalLoad
           rest.each { |x| aggregate_root.apply_event(x) }
         else
-          aggregate_root = allocate() # allocate without calling new
+          aggregate_root = allocate # allocate without calling new
           aggregate_root.load_from_history(stream, events)
         end
         aggregate_root
@@ -62,7 +71,8 @@ module Sequent
       end
 
       def load_from_history(stream, events)
-        raise "Empty history" if events.empty?
+        fail 'Empty history' if events.empty?
+
         @id = events.first.aggregate_id
         @uncommitted_events = []
         @sequence_number = 1
@@ -100,7 +110,7 @@ module Sequent
       #     apply InvoiceSentEvent, send_date: DateTime.now
       #   end
       #
-      def apply(event, params={})
+      def apply(event, params = {})
         event = build_event(event, params) if event.is_a?(Class)
         apply_event(event)
         @uncommitted_events << event
@@ -123,12 +133,11 @@ module Sequent
         if args.empty?
           apply event_class
         elsif self.class
-             .event_attribute_keys(event_class)
-             .any? { |k| instance_variable_get(:"@#{k.to_s}") != args[k.to_sym] }
+            .event_attribute_keys(event_class)
+            .any? { |k| instance_variable_get(:"@#{k}") != args[k.to_sym] }
           apply event_class, args
         end
       end
-
     end
   end
 end

data/lib/sequent/core/aggregate_roots.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Core
+    #
+    # Utility class containing all subclasses of AggregateRoot
+    #
+    class AggregateRoots
+      class << self
+        def aggregate_roots
+          @aggregate_roots ||= []
+        end
+
+        def all
+          aggregate_roots
+        end
+
+        def <<(aggregate_root)
+          aggregate_roots << aggregate_root
+        end
+      end
+    end
+  end
+end

data/lib/sequent/core/aggregate_snapshotter.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 module Sequent
   module Core
-
     ##
     # Take up to `limit` snapshots when needed. Throws `:done` when done.
     #
-    class SnapshotCommand <  Sequent::Core::BaseCommand
+    class SnapshotCommand < Sequent::Core::BaseCommand
       attrs limit: Integer
     end
 
@@ -14,9 +15,11 @@ module Sequent
     end
 
     class AggregateSnapshotter < BaseCommandHandler
-
       on SnapshotCommand do |command|
-        aggregate_ids = repository.event_store.aggregates_that_need_snapshots(@last_aggregate_id, command.limit)
+        aggregate_ids = Sequent.configuration.event_store.aggregates_that_need_snapshots(
+          @last_aggregate_id,
+          command.limit,
+        )
         aggregate_ids.each do |aggregate_id|
           take_snapshot!(aggregate_id)
         end
@@ -32,7 +35,7 @@ module Sequent
         aggregate = repository.load_aggregate(aggregate_id)
         Sequent.logger.info "Taking snapshot for aggregate #{aggregate}"
         aggregate.take_snapshot!
-      rescue => e
+      rescue StandardError => e
         Sequent.logger.error("Failed to take snapshot for aggregate #{aggregate_id}: #{e}, #{e.inspect}")
       end
     end

data/lib/sequent/core/base_command_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helpers/message_handler'
 require_relative 'helpers/uuid_helper'
 
@@ -17,8 +19,8 @@ module Sequent
     #     end
     #   end
     class BaseCommandHandler
-      include Sequent::Core::Helpers::MessageHandler,
-              Sequent::Core::Helpers::UuidHelper
+      include Sequent::Core::Helpers::UuidHelper
+      include Sequent::Core::Helpers::MessageHandler
 
       protected
 

data/lib/sequent/core/command.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'helpers/copyable'
 require_relative 'helpers/attribute_support'
 require_relative 'helpers/uuid_helper'
@@ -7,15 +9,23 @@ require_relative 'helpers/mergable'
 
 module Sequent
   module Core
-    # Base command
+    #
+    # Base class for all Command's.
+    #
+    # Commands form the API of your domain. They are
+    # simple data objects with descriptive names
+    # of what they want to achieve. E.g. `SendInvoice`.
+    #
+    # BaseCommand uses `ActiveModel::Validations` for
+    # validations
     class BaseCommand
-      include ActiveModel::Validations,
-              Sequent::Core::Helpers::Copyable,
-              Sequent::Core::Helpers::AttributeSupport,
-              Sequent::Core::Helpers::UuidHelper,
-              Sequent::Core::Helpers::EqualSupport,
-              Sequent::Core::Helpers::ParamSupport,
-              Sequent::Core::Helpers::Mergable
+      include Sequent::Core::Helpers::Mergable
+      include Sequent::Core::Helpers::ParamSupport
+      include Sequent::Core::Helpers::EqualSupport
+      include Sequent::Core::Helpers::UuidHelper
+      include Sequent::Core::Helpers::AttributeSupport
+      include Sequent::Core::Helpers::Copyable
+      include ActiveModel::Validations
       include ActiveModel::Validations::Callbacks
       include Sequent::Core::Helpers::TypeConversionSupport
 
@@ -27,6 +37,7 @@ module Sequent
       end
 
       def self.inherited(subclass)
+        super
         Commands << subclass
       end
     end
@@ -36,10 +47,17 @@ module Sequent
       included do
         attrs sequence_number: Integer
         validates_presence_of :sequence_number
-        validates_numericality_of :sequence_number, only_integer: true, allow_nil: true, allow_blank: true, greater_than: 0
+        validates_numericality_of :sequence_number,
+                                  only_integer: true,
+                                  allow_nil: true,
+                                  allow_blank: true,
+                                  greater_than: 0
       end
     end
 
+    #
+    # Utility class containing all subclasses of BaseCommand
+    #
     class Commands
       class << self
         def commands
@@ -60,7 +78,7 @@ module Sequent
       end
     end
 
-    # Most commonly used command
+    # Most commonly used Command
     # Command can be instantiated just by using:
     #
     #   Command.new(aggregate_id: "1", user_id: "joe")
@@ -74,7 +92,8 @@ module Sequent
       attrs aggregate_id: String, user_id: String, event_aggregate_id: String, event_sequence_number: Integer
 
       def initialize(args = {})
-        raise ArgumentError, "Missing aggregate_id" if args[:aggregate_id].nil?
+        fail ArgumentError, 'Missing aggregate_id' if args[:aggregate_id].nil?
+
         super
       end
     end

data/lib/sequent/core/command_record.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require_relative 'sequent_oj'
 
 module Sequent
   module Core
-
     module SerializesCommand
       def command
         args = Sequent::Core::Oj.strict_load(command_json)
@@ -21,7 +22,10 @@ module Sequent
         # this should be moved to a configurable CommandSerializer
         self.organization_id = command.organization_id if serialize_attribute?(command, :organization_id)
         self.event_aggregate_id = command.event_aggregate_id if serialize_attribute?(command, :event_aggregate_id)
-        self.event_sequence_number = command.event_sequence_number if serialize_attribute?(command, :event_sequence_number)
+        self.event_sequence_number = command.event_sequence_number if serialize_attribute?(
+          command,
+          :event_sequence_number,
+        )
       end
 
       private
@@ -35,14 +39,17 @@ module Sequent
     class CommandRecord < Sequent::ApplicationRecord
       include SerializesCommand
 
-      self.table_name = "command_records"
+      self.table_name = 'command_records'
 
       has_many :event_records
 
       validates_presence_of :command_type, :command_json
 
       def parent
-        EventRecord.find_by(aggregate_id: event_aggregate_id, sequence_number: event_sequence_number)
+        EventRecord
+          .where(aggregate_id: event_aggregate_id, sequence_number: event_sequence_number)
+          .where('event_type != ?', Sequent::Core::SnapshotEvent.name)
+          .first
       end
 
       def children
@@ -55,6 +62,7 @@ module Sequent
 
       def find_origin(record)
         return find_origin(record.parent) if record.parent.present?
+
         record
       end
     end