sequent 4.0.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3322a4b950e847a5818555b2718df70e2b81a8e398074309a0b58c2a8d332ce5
-  data.tar.gz: 6136697a8a9596e999fabf3814509428b06188a0ac577fa3443a80ec190cbdd7
+  metadata.gz: feea2aeb3dba28570a36615392e4ecc1037bfdfd1c2d667bcc787113e4c7fdba
+  data.tar.gz: 79dc60b21109885a56f3f68cf97185afee5692167f54db1934eaa89dc9d030de
 SHA512:
-  metadata.gz: f8ce675ae0a16274630066192086fb8c46bb0306e9280fd4b8901500af4a7af56844c5d6c40cd0f45a87342c33a4faeb2eee48f0dc0fb05a0a09046a2dea7414
-  data.tar.gz: e750e54d72de1c8641a513839c675adeb32fbeaa3435528a8aca755a951a7572d696e9348b7594e104f044978a0e9780f8e080ff1ad5e4ea9b7cc203fac6fee2
+  metadata.gz: bb74d9c6cbb946bab9b00cb2ea73eab80caed4737d12ce2115a6c97348ca0e9452a14280b3d0de9ecba237c201fdd8b2914382751569224c89cae92128d5d3f5
+  data.tar.gz: 5fe084735eb4df8855b8102e68d027ca828a8dd7540d577b6e0a97616bbd22815432e684f20d48d04ad111db962fe935af4bff50afd8ebc7242f5c15f01b97a7

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
@@ -18,10 +20,11 @@ def new_project(args)
     Success!
 
     Your brand spanking new sequent app is waiting for you in:
-      #{File.expand_path(name, __dir__)}
+      #{File.expand_path(name, Dir.pwd)}
 
     To finish setting up your app:
       cd #{name}
+      bundle install
       bundle exec rake sequent:db:create
       bundle exec rake sequent:db:create_view_schema
       bundle exec rake sequent:migrate:online
@@ -43,8 +46,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 +55,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

@@ -1,3 +1,5 @@
+# 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

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,7 +9,6 @@ require 'logger'
 
 module Sequent
   class Configuration
-
     DEFAULT_VERSIONS_TABLE_NAME = 'sequent_versions'
     DEFAULT_REPLAYED_IDS_TABLE_NAME = 'sequent_replayed_ids'
 
@@ -16,7 +17,7 @@ module Sequent
     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'
 
@@ -31,41 +32,31 @@ module Sequent
 
     DEFAULT_ERROR_LOCALE_RESOLVER = -> { I18n.locale || :en }
 
-    attr_accessor :aggregate_repository
-
-    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 :error_locale_resolver
-
-    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,
                   :database_schema_directory,
-                  :event_store_schema_name
-
-    attr_accessor :strict_check_attributes_on_apply_events
+                  :event_store_schema_name,
+                  :strict_check_attributes_on_apply_events
 
     attr_reader :migrations_class_name,
                 :versions_table_name,
@@ -114,19 +105,19 @@ module Sequent
       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
@@ -134,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
@@ -55,6 +57,37 @@ module Sequent
         load_aggregates([aggregate_id], clazz)[0]
       end
 
+      # Optimised for loading lots of events and ignore snapshot events. To get the correct historical state of an
+      # AggregateRoot it is necessary to be able to ignore snapshots. For a nested AggregateRoot, there will not be a
+      # sequence number known, so a load_until timestamp can be used instead.
+      #
+      # +aggregate_id+ The id of the aggregate to be loaded
+      #
+      # +clazz+ Optional argument that checks if aggregate is of type +clazz+
+      #
+      # +load_until+ Optional argument that defines up until what point in time the AggregateRoot will be rebuilt.
+      def load_aggregate_for_snapshotting(aggregate_id, clazz = nil, load_until: nil)
+        fail ArgumentError, 'aggregate_id is required' if aggregate_id.blank?
+
+        stream = Sequent
+          .configuration
+          .event_store
+          .find_event_stream(aggregate_id)
+        aggregate = Class.const_get(stream.aggregate_type).stream_from_history(stream)
+
+        Sequent
+          .configuration
+          .event_store
+          .stream_events_for_aggregate(aggregate_id, load_until: load_until) do |event_stream|
+          aggregate.stream_from_history(event_stream)
+        end
+
+        if clazz
+          fail TypeError, "#{aggregate.class} is not a #{clazz}" unless aggregate.class <= clazz
+        end
+        aggregate
+      end
+
       ##
       # Loads multiple aggregates at once.
       # Returns the ones in the current Unit Of Work otherwise loads it from history.
@@ -69,30 +102,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
@@ -119,8 +152,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
@@ -136,6 +170,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
@@ -70,6 +80,26 @@ module Sequent
         events.each { |event| apply_event(event) }
       end
 
+      def initialize_for_streaming(stream)
+        @uncommitted_events = []
+        @sequence_number = 1
+        @event_stream = stream
+      end
+
+      def stream_from_history(stream_events)
+        _stream, event = stream_events
+        fail 'Empty history' if event.blank?
+
+        @id ||= event.aggregate_id
+        apply_event(event)
+      end
+
+      def self.stream_from_history(stream)
+        aggregate_root = allocate
+        aggregate_root.initialize_for_streaming(stream)
+        aggregate_root
+      end
+
       def to_s
         "#{self.class.name}: #{@id}"
       end
@@ -100,7 +130,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 +153,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'
@@ -17,13 +19,13 @@ module Sequent
     # 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
 
@@ -35,6 +37,7 @@ module Sequent
       end
 
       def self.inherited(subclass)
+        super
         Commands << subclass
       end
     end
@@ -44,7 +47,11 @@ 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
 
@@ -85,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,7 +39,7 @@ module Sequent
     class CommandRecord < Sequent::ApplicationRecord
       include SerializesCommand
 
-      self.table_name = "command_records"
+      self.table_name = 'command_records'
 
       has_many :event_records
 
@@ -58,6 +62,7 @@ module Sequent
 
       def find_origin(record)
         return find_origin(record.parent) if record.parent.present?
+
         record
       end
     end