sequent 7.1.1 → 8.0.0

data/db/sequent_schema.rb

@@ -1,60 +1,14 @@
-ActiveRecord::Schema.define do
-
-  create_table "event_records", :force => true do |t|
-    t.uuid "aggregate_id", :null => false
-    t.integer "sequence_number", :null => false
-    t.datetime "created_at", :null => false
-    t.string "event_type", :null => false
-    t.text "event_json", :null => false
-    t.integer "command_record_id", :null => false
-    t.integer "stream_record_id", :null => false
-    t.bigint "xact_id"
-  end
+# frozen_string_literal: true
 
-  execute %Q{
-ALTER TABLE event_records ALTER COLUMN xact_id SET DEFAULT pg_current_xact_id()::text::bigint
-}
-  execute %Q{
-CREATE UNIQUE INDEX unique_event_per_aggregate ON event_records (
-  aggregate_id,
-  sequence_number,
-  (CASE event_type WHEN 'Sequent::Core::SnapshotEvent' THEN 0 ELSE 1 END)
-)
-}
-  execute %Q{
-CREATE INDEX snapshot_events ON event_records (aggregate_id, sequence_number DESC) WHERE event_type = 'Sequent::Core::SnapshotEvent'
-}
-
-  add_index "event_records", ["command_record_id"], :name => "index_event_records_on_command_record_id"
-  add_index "event_records", ["event_type"], :name => "index_event_records_on_event_type"
-  add_index "event_records", ["created_at"], :name => "index_event_records_on_created_at"
-  add_index "event_records", ["xact_id"], :name => "index_event_records_on_xact_id"
-
-  create_table "command_records", :force => true do |t|
-    t.string "user_id"
-    t.uuid "aggregate_id"
-    t.string "command_type", :null => false
-    t.string "event_aggregate_id"
-    t.integer "event_sequence_number"
-    t.text "command_json", :null => false
-    t.datetime "created_at", :null => false
-  end
-
-  add_index "command_records", ["event_aggregate_id", 'event_sequence_number'], :name => "index_command_records_on_event"
-
-  create_table "stream_records", :force => true do |t|
-    t.datetime "created_at", :null => false
-    t.string "aggregate_type", :null => false
-    t.uuid "aggregate_id", :null => false
-    t.integer "snapshot_threshold"
+ActiveRecord::Schema.define do
+  say_with_time 'Installing Sequent schema' do
+    say 'Creating tables', true
+    suppress_messages { execute File.read("#{File.dirname(__FILE__)}/sequent_schema_tables.sql") }
+    say 'Creating table partitions', true
+    suppress_messages { execute File.read("#{File.dirname(__FILE__)}/sequent_schema_partitions.sql") }
+    say 'Creating constraints and indexes', true
+    suppress_messages { execute File.read("#{File.dirname(__FILE__)}/sequent_schema_indexes.sql") }
+    say 'Creating stored procedures and views', true
+    suppress_messages { execute File.read("#{File.dirname(__FILE__)}/sequent_pgsql.sql") }
   end
-
-  add_index "stream_records", ["aggregate_id"], :name => "index_stream_records_on_aggregate_id", :unique => true
-  execute %q{
-ALTER TABLE event_records ADD CONSTRAINT command_fkey FOREIGN KEY (command_record_id) REFERENCES command_records (id)
-}
-  execute %q{
-ALTER TABLE event_records ADD CONSTRAINT stream_fkey FOREIGN KEY (stream_record_id) REFERENCES stream_records (id)
-}
-
 end

data/db/sequent_schema_indexes.sql

@@ -0,0 +1,37 @@
+ALTER TABLE aggregates ADD PRIMARY KEY (aggregate_id);
+ALTER TABLE aggregates ADD UNIQUE (events_partition_key, aggregate_id);
+CREATE INDEX aggregates_aggregate_type_id_idx ON aggregates (aggregate_type_id);
+
+ALTER TABLE commands ADD PRIMARY KEY (id);
+CREATE INDEX commands_command_type_id_idx ON commands (command_type_id);
+CREATE INDEX commands_aggregate_id_idx ON commands (aggregate_id);
+CREATE INDEX commands_event_idx ON commands (event_aggregate_id, event_sequence_number);
+
+ALTER TABLE events ADD PRIMARY KEY (partition_key, aggregate_id, sequence_number);
+CREATE INDEX events_command_id_idx ON events (command_id);
+CREATE INDEX events_event_type_id_idx ON events (event_type_id);
+
+ALTER TABLE aggregates
+  ADD FOREIGN KEY (aggregate_type_id) REFERENCES aggregate_types (id) ON UPDATE CASCADE;
+
+ALTER TABLE events
+  ADD FOREIGN KEY (partition_key, aggregate_id) REFERENCES aggregates (events_partition_key, aggregate_id)
+          ON UPDATE CASCADE ON DELETE RESTRICT;
+ALTER TABLE events
+  ADD FOREIGN KEY (command_id) REFERENCES commands (id) ON UPDATE RESTRICT ON DELETE RESTRICT;
+ALTER TABLE events
+  ADD FOREIGN KEY (event_type_id) REFERENCES event_types (id) ON UPDATE CASCADE;
+ALTER TABLE events ALTER COLUMN xact_id SET DEFAULT pg_current_xact_id()::text::bigint;
+
+ALTER TABLE commands
+  ADD FOREIGN KEY (command_type_id) REFERENCES command_types (id) ON UPDATE CASCADE;
+
+ALTER TABLE aggregates_that_need_snapshots
+  ADD FOREIGN KEY (aggregate_id) REFERENCES aggregates (aggregate_id) ON UPDATE CASCADE ON DELETE CASCADE;
+
+CREATE INDEX aggregates_that_need_snapshots_outdated_idx
+          ON aggregates_that_need_snapshots (snapshot_outdated_at ASC, snapshot_sequence_number_high_water_mark DESC, aggregate_id ASC)
+       WHERE snapshot_outdated_at IS NOT NULL;
+
+ALTER TABLE snapshot_records
+  ADD FOREIGN KEY (aggregate_id) REFERENCES aggregates_that_need_snapshots (aggregate_id) ON UPDATE CASCADE ON DELETE CASCADE;

data/db/sequent_schema_partitions.sql

@@ -0,0 +1,34 @@
+-- ### Configure partitions as needed
+CREATE TABLE commands_default PARTITION OF commands DEFAULT;
+-- CREATE TABLE commands_0 PARTITION OF commands FOR VALUES FROM (1) TO (100e6);
+-- CREATE TABLE commands_1 PARTITION OF commands FOR VALUES FROM (100e6) TO (200e6);
+-- CREATE TABLE commands_2 PARTITION OF commands FOR VALUES FROM (200e6) TO (300e6);
+-- CREATE TABLE commands_3 PARTITION OF commands FOR VALUES FROM (300e6) TO (400e6);
+
+-- ### Configure partitions as needed
+CREATE TABLE aggregates_default PARTITION OF aggregates DEFAULT;
+-- CREATE TABLE aggregates_0 PARTITION OF aggregates FOR VALUES FROM (MINVALUE) TO ('10000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_1 PARTITION OF aggregates FOR VALUES FROM ('10000000-0000-0000-0000-000000000000') TO ('20000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_2 PARTITION OF aggregates FOR VALUES FROM ('20000000-0000-0000-0000-000000000000') TO ('30000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_3 PARTITION OF aggregates FOR VALUES FROM ('30000000-0000-0000-0000-000000000000') TO ('40000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_4 PARTITION OF aggregates FOR VALUES FROM ('40000000-0000-0000-0000-000000000000') TO ('50000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_5 PARTITION OF aggregates FOR VALUES FROM ('50000000-0000-0000-0000-000000000000') TO ('60000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_6 PARTITION OF aggregates FOR VALUES FROM ('60000000-0000-0000-0000-000000000000') TO ('70000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_7 PARTITION OF aggregates FOR VALUES FROM ('70000000-0000-0000-0000-000000000000') TO ('80000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_8 PARTITION OF aggregates FOR VALUES FROM ('80000000-0000-0000-0000-000000000000') TO ('90000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_9 PARTITION OF aggregates FOR VALUES FROM ('90000000-0000-0000-0000-000000000000') TO ('a0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_a PARTITION OF aggregates FOR VALUES FROM ('a0000000-0000-0000-0000-000000000000') TO ('b0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_b PARTITION OF aggregates FOR VALUES FROM ('b0000000-0000-0000-0000-000000000000') TO ('c0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_c PARTITION OF aggregates FOR VALUES FROM ('c0000000-0000-0000-0000-000000000000') TO ('d0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_d PARTITION OF aggregates FOR VALUES FROM ('d0000000-0000-0000-0000-000000000000') TO ('e0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_e PARTITION OF aggregates FOR VALUES FROM ('e0000000-0000-0000-0000-000000000000') TO ('f0000000-0000-0000-0000-000000000000');
+-- CREATE TABLE aggregates_f PARTITION OF aggregates FOR VALUES FROM ('f0000000-0000-0000-0000-000000000000') TO (MAXVALUE);
+
+-- ### Configure partitions as needed
+CREATE TABLE events_default PARTITION OF events DEFAULT;
+-- CREATE TABLE events_2023_and_earlier PARTITION OF events FOR VALUES FROM ('Y00') TO ('Y24');
+-- CREATE TABLE events_2024 PARTITION OF events FOR VALUES FROM ('Y24') TO ('Y25');
+-- CREATE TABLE events_2025 PARTITION OF events FOR VALUES FROM ('Y25') TO ('Y26');
+-- CREATE TABLE events_2026 PARTITION OF events FOR VALUES FROM ('Y26') TO ('Y27');
+-- CREATE TABLE events_2027_and_later PARTITION OF events FOR VALUES FROM ('Y27') TO ('Y99');
+-- CREATE TABLE events_aggregate PARTITION OF events FOR VALUES FROM ('A') TO ('Ag');

data/db/sequent_schema_tables.sql

@@ -0,0 +1,74 @@
+CREATE TABLE command_types (id SMALLINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, type text UNIQUE NOT NULL);
+CREATE TABLE aggregate_types (id SMALLINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, type text UNIQUE NOT NULL);
+CREATE TABLE event_types (id SMALLINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY, type text UNIQUE NOT NULL);
+
+CREATE SEQUENCE IF NOT EXISTS commands_id_seq;
+
+CREATE TABLE commands (
+    id bigint NOT NULL DEFAULT nextval('commands_id_seq'),
+    created_at timestamp with time zone NOT NULL,
+    user_id uuid,
+    aggregate_id uuid,
+    command_type_id SMALLINT NOT NULL,
+    command_json jsonb NOT NULL,
+    event_aggregate_id uuid,
+    event_sequence_number integer
+) PARTITION BY RANGE (id);
+
+ALTER SEQUENCE commands_id_seq OWNED BY commands.id;
+
+CREATE TABLE aggregates (
+    aggregate_id uuid NOT NULL,
+    events_partition_key text NOT NULL DEFAULT '',
+    aggregate_type_id SMALLINT NOT NULL,
+    snapshot_threshold integer,
+    created_at timestamp with time zone NOT NULL DEFAULT NOW()
+) PARTITION BY RANGE (aggregate_id);
+
+CREATE TABLE events (
+  aggregate_id uuid NOT NULL,
+  partition_key text NOT NULL DEFAULT '',
+  sequence_number integer NOT NULL,
+  created_at timestamp with time zone NOT NULL,
+  command_id bigint NOT NULL,
+  event_type_id SMALLINT NOT NULL,
+  event_json jsonb NOT NULL,
+  xact_id bigint
+) PARTITION BY RANGE (partition_key);
+
+CREATE TABLE aggregates_that_need_snapshots (
+  aggregate_id uuid NOT NULL PRIMARY KEY,
+  snapshot_sequence_number_high_water_mark integer,
+  snapshot_outdated_at timestamp with time zone,
+  snapshot_scheduled_at timestamp with time zone
+);
+
+COMMENT ON TABLE aggregates_that_need_snapshots IS 'Contains a row for every aggregate with more events than its snapshot threshold.';
+COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_sequence_number_high_water_mark
+  IS 'The highest sequence number of the stored snapshot. Kept when snapshot are deleted to more easily query aggregates that need snapshotting the most';
+COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_outdated_at IS 'Not NULL indicates a snapshot is needed since the stored timestamp';
+COMMENT ON COLUMN aggregates_that_need_snapshots.snapshot_scheduled_at IS 'Not NULL indicates a snapshot is in the process of being taken';
+
+CREATE TABLE snapshot_records (
+  aggregate_id uuid NOT NULL,
+  sequence_number integer NOT NULL,
+  created_at timestamptz NOT NULL,
+  snapshot_type text NOT NULL,
+  snapshot_json jsonb NOT NULL,
+  PRIMARY KEY (aggregate_id, sequence_number)
+);
+
+CREATE TABLE saved_event_records (
+  operation varchar(1) NOT NULL CHECK (operation IN ('U', 'D')),
+  timestamp timestamptz NOT NULL,
+  "user" text NOT NULL,
+  aggregate_id uuid NOT NULL,
+  partition_key text DEFAULT '',
+  sequence_number integer NOT NULL,
+  created_at timestamp with time zone NOT NULL,
+  command_id bigint NOT NULL,
+  event_type text NOT NULL,
+  event_json jsonb NOT NULL,
+  xact_id bigint,
+  PRIMARY KEY (aggregate_id, sequence_number, timestamp)
+);

data/lib/sequent/cli/app.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative '../generator'
+require_relative 'sequent8_migration'
+module Sequent
+  module Cli
+    class App
+      extend GLI::App
+
+      program_desc 'Sequent Command Line Interface (CLI)'
+
+      version Sequent::VERSION
+      on_error do |_error|
+        true
+      end
+
+      desc 'Generate a directory structure for a Sequent project'
+      command :new do |c|
+        prompt = TTY::Prompt.new(interrupt: :exit)
+
+        c.arg_name 'project_name'
+        c.action do |_global, _options, args|
+          help_now!('can only specify one single argument e.g. `sequent new project_name`') if args&.length != 1
+
+          project_name = args[0]
+          Sequent::Generator::Project.new(project_name).execute
+          prompt.say(<<~EOS)
+            Success!
+
+            Your brand spanking new sequent app is waiting for you in:
+              #{File.expand_path(project_name, Dir.pwd)}
+
+            To finish setting up your app:
+              cd #{project_name}
+              bundle install
+              bundle exec rake sequent:db:create
+              bundle exec rake sequent:db:create_view_schema
+              bundle exec rake sequent:migrate:online
+              bundle exec rake sequent:migrate:offline
+
+            Run the example specs:
+              SEQUENT_ENV=test bundle exec rake sequent:db:create
+              bundle exec rspec spec
+
+            To generate new aggregates use:
+              sequent generate <aggregate_name>. e.g. sequent generate address
+
+            For more information see:
+              https://www.sequent.io
+
+            Happy coding!
+          EOS
+        rescue TargetAlreadyExists
+          prompt.error("Target '#{project_name}' already exists, aborting")
+        end
+      end
+
+      desc 'Generate a new aggregate, command, or event'
+      command [:generate, :g] do |c|
+        prompt = TTY::Prompt.new(interrupt: :exit)
+
+        c.arg_name 'aggregate_name'
+        c.desc 'Generate an aggregate'
+        c.command :aggregate do |a|
+          a.action do |_global, _options, args|
+            if args&.length != 1
+              help_now!('must specify one single argument e.g. `sequent generate aggregate Employee`')
+            end
+
+            aggregate_name = args[0]
+
+            Sequent::Generator::Aggregate.new(aggregate_name).execute
+
+            prompt.say(<<~EOS)
+              #{aggregate_name} aggregate has been generated
+            EOS
+          end
+        end
+
+        c.desc 'Generate a command'
+        c.arg_name 'aggregate_name command_name'
+        c.command :command do |command|
+          command.action do |_global, _options, args|
+            if args&.length&.< 2
+              help_now!('must specify at least two arguments e.g. `sequent generate command Employee CreateEmployee`')
+            end
+
+            aggregate_name, command_name, *attributes = args
+
+            Sequent::Generator::Command.new(aggregate_name, command_name, attributes).execute
+            prompt.say(<<~EOS)
+              "#{command_name} command has been added to #{aggregate_name}"
+            EOS
+          rescue NoAggregateFound
+            prompt.error("Aggregate '#{aggregate_name}' not found, aborting")
+          end
+        end
+
+        c.desc 'Generate an Event'
+        c.arg_name 'aggregate_name event_name'
+        c.command :event do |command|
+          command.action do |_global, _options, args|
+            if args&.length&.< 2
+              help_now!('must specify at least two arguments e.g. `sequent generate event Employee EmployeeCreated`')
+            end
+
+            aggregate_name, event_name, *attributes = args
+
+            Sequent::Generator::Command.new(aggregate_name, event_name, attributes).execute
+            prompt.say(<<~EOS)
+              "#{event_name} event has been added to #{aggregate_name}"
+            EOS
+          rescue NoAggregateFound
+            prompt.error("Aggregate '#{aggregate_name}' not found, aborting")
+          end
+        end
+      end
+
+      desc 'Migrates a Sequent 7 project to Sequent 8'
+      command :migrate do |c|
+        prompt = TTY::Prompt.new(interrupt: :exit)
+        c.action do |_global, _options, _args|
+          Sequent8Migration.new(prompt).execute
+        rescue Gem::MissingSpecError
+          prompt.error('Sequent gem not found. Please check your Gemfile.')
+        rescue Sequent8Migration::Stop => e
+          prompt.error(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/sequent/cli/sequent_8_migration.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Cli
+    class Sequent8Migration
+      class Stop < StandardError; end
+
+      def initialize(prompt)
+        @prompt = prompt
+      end
+
+      # @raise Gem::MissingSpecError
+      def execute
+        print_introduction
+        abort_if_no('Do you wish to start the migration?')
+        copy_schema_files
+        abort_if_no('Do you which to continue?')
+        stop_application
+        migrate_data
+        prompt.ask('Press <enter> if the migration is done and you checked the results?')
+        migrated = commit_or_rollback
+
+        if migrated
+          prompt.say <<~EOS
+
+            Step 5. Deploy your Sequent 8 based application and start it.
+
+            Congratulations! You are now running your application on Sequent 8!
+          EOS
+        else
+          prompt.say <<~EOS
+
+            We are sorry the migration did not succeed. If you think this is a bug in Sequent don't hesitate to reach
+            out and submit an issue on Github: https://github.com/zilverline/sequent.
+
+            Don't forget to start your application again!
+          EOS
+        end
+      end
+
+      private
+
+      attr_reader :prompt
+
+      def print_introduction
+        prompt.say <<~EOS
+          This script will guide you through upgrading your Sequent application to Sequent 8.
+
+          The Sequent 8 database has been further optimized for disk usage and
+          performance. In addition it supports partitioning the tables for aggregates,
+          commands, and events, making it easier to manage the database (VACUUM,
+          CLUSTER) since these can work on the smaller partition tables.
+
+          It is highly recommended to test this upgrade on a copy of your production database first.
+
+          This script consists of the following steps:
+
+          Step 1: Copy the Sequent 8 database schema and
+          migration files to your project's `db/` directory. When this step is completed you
+          can customize these files to your liking and commit the changes.
+
+          One decision you need to make is whether you want to define partitions. This is
+          mainly useful when your database tables are larger than 10 gigabytes or so. By
+          default Sequent 8 uses a single "default" partition.
+
+          The `db/sequent_schema_partitions.sql` file contains the database partitions for
+          the `aggregates`, `commands`, and `events` tables, you can customize your
+          partitions here.
+
+          Step 2: Shutdown your application.
+
+          Step 3: Run the migration script. The script starts a transaction but DOES NOT
+          commit the results.
+
+          Step 4: Check the results and COMMIT or ROLLBACK the result. If you COMMIT,
+          you must perform a VACUUM ANALYZE to ensure PostgreSQL can efficiently query
+          the new tables
+
+          Step 5: Now you can deploy your Sequent 8 based application and start it again.
+
+        EOS
+      end
+
+      def copy_schema_files
+        prompt.say <<~EOS
+
+          Step 1. First a copy of the Sequent 8 database schema and migration scripts are
+          added to your db/ directory.
+        EOS
+        prompt.warn <<~EOS
+
+          WARNING: this may overwrite your existing scripts, please use your version control system to commit or abort any of the changes!
+        EOS
+
+        abort_if_no('Do you which to continue?')
+
+        FileUtils.copy_entry("#{sequent_gem_dir}/db", 'db')
+
+        prompt.warn <<~EOS
+
+          WARNING: The schema files have been copied, please verify and adjust the contents before committing and continuing.
+        EOS
+      end
+
+      def stop_application
+        prompt.say <<~EOS
+
+          Step 2. Please shut down your existing application.
+        EOS
+
+        abort_if_no(<<~EOS)
+          Only proceed once your application is stopped. Is your application stopped and do you want to continue?
+        EOS
+      end
+
+      def migrate_data
+        prompt.say <<~EOS
+
+          Step 3. Open a `psql` connection to the database you wish to migrate.
+        EOS
+        prompt.warn <<~EOS
+
+          It is highly recommended to test this on a copy of your production database first!
+        EOS
+
+        prompt.say <<~EOS
+
+          Depending on the size of your database the migration can take a long time. Open the `psql` connection from a screen session if needed.
+          If you run this from a screen session from another server you will need to copy all needed sql files to that server.
+
+          ```
+          psql -U myapp_user myapp_db
+          ```
+        EOS
+
+        prompt.ask('Press <enter> to read the next instructions once you connected to the database...')
+
+        prompt.say <<~EOS
+
+          Run the database migration. This doesn't commit anything yet so you can check the results first.
+
+          ```
+          psql> \\i db/sequent_8_migration.sql
+          ```
+        EOS
+      end
+
+      def commit_or_rollback
+        answer = prompt.yes? 'Did the migration succeed?'
+        if answer
+          prompt.say <<~EOS
+
+            Step 4. After checking everything went OK, COMMIT and optimize the database:
+
+            ```
+            psql> COMMIT; VACUUM VERBOSE ANALYZE;
+            ```
+          EOS
+        else
+          prompt.say <<~EOS
+
+            Step 4. Rollback the migration:
+
+            ```
+            psql> ROLLBACK;
+            ```
+          EOS
+        end
+        answer
+      end
+
+      def sequent_gem_dir = Gem::Specification.find_by_name('sequent').gem_dir
+
+      def abort_if_no(message, abort_message: 'Stopped at your request. You can restart this migration at any time.')
+        answer = prompt.yes?(message)
+        fail Stop, abort_message unless answer
+      end
+    end
+  end
+end

data/lib/sequent/configuration.rb

@@ -21,6 +21,7 @@ module Sequent
     MIGRATIONS_CLASS_NAME = 'Sequent::Migrations::Projectors'
 
     DEFAULT_NUMBER_OF_REPLAY_PROCESSES = 4
+    DEFAULT_REPLAY_GROUP_TARGET_SIZE = 250_000
 
     DEFAULT_OFFLINE_REPLAY_PERSISTOR_CLASS = Sequent::Core::Persistors::ActiveRecordPersistor
     DEFAULT_ONLINE_REPLAY_PERSISTOR_CLASS = Sequent::Core::Persistors::ActiveRecordPersistor
@@ -35,11 +36,10 @@ module Sequent
 
     attr_accessor :aggregate_repository,
                   :event_store,
-                  :event_store_cache_event_types,
                   :command_service,
                   :event_record_class,
+                  :snapshot_record_class,
                   :stream_record_class,
-                  :snapshot_event_class,
                   :transaction_provider,
                   :event_publisher,
                   :event_record_hooks_class,
@@ -56,6 +56,7 @@ module Sequent
                   :offline_replay_persistor_class,
                   :online_replay_persistor_class,
                   :number_of_replay_processes,
+                  :replay_group_target_size,
                   :database_config_directory,
                   :database_schema_directory,
                   :event_store_schema_name,
@@ -91,12 +92,11 @@ module Sequent
       self.command_middleware = Sequent::Core::Middleware::Chain.new
 
       self.aggregate_repository = Sequent::Core::AggregateRepository.new
-      self.event_store_cache_event_types = true
       self.event_store = Sequent::Core::EventStore.new
       self.command_service = Sequent::Core::CommandService.new
       self.event_record_class = Sequent::Core::EventRecord
+      self.snapshot_record_class = Sequent::Core::SnapshotRecord
       self.stream_record_class = Sequent::Core::StreamRecord
-      self.snapshot_event_class = Sequent::Core::SnapshotEvent
       self.transaction_provider = Sequent::Core::Transactions::ActiveRecordTransactionProvider.new
       self.uuid_generator = Sequent::Core::RandomUuidGenerator
       self.event_publisher = Sequent::Core::EventPublisher.new
@@ -107,6 +107,7 @@ module Sequent
       self.event_store_schema_name = DEFAULT_EVENT_STORE_SCHEMA_NAME
       self.migrations_class_name = MIGRATIONS_CLASS_NAME
       self.number_of_replay_processes = DEFAULT_NUMBER_OF_REPLAY_PROCESSES
+      self.replay_group_target_size = DEFAULT_REPLAY_GROUP_TARGET_SIZE
 
       self.event_record_hooks_class = DEFAULT_EVENT_RECORD_HOOKS_CLASS
 
@@ -129,7 +130,7 @@ module Sequent
     end
 
     def can_use_multiple_databases?
-      enable_multiple_database_support && ActiveRecord.version > Gem::Version.new('6.1.0')
+      enable_multiple_database_support
     end
 
     def versions_table_name=(table_name)
@@ -159,18 +160,20 @@ module Sequent
 
       self.class.instance.command_handlers ||= []
       for_each_autoregisterable_descenant_of(Sequent::CommandHandler) do |command_handler_class|
-        Sequent.logger.debug("[Configuration] Autoregistering CommandHandler #{command_handler_class}")
+        if Sequent.logger.debug?
+          Sequent.logger.debug("[Configuration] Autoregistering CommandHandler #{command_handler_class}")
+        end
         self.class.instance.command_handlers << command_handler_class.new
       end
 
       self.class.instance.event_handlers ||= []
       for_each_autoregisterable_descenant_of(Sequent::Projector) do |projector_class|
-        Sequent.logger.debug("[Configuration] Autoregistering Projector #{projector_class}")
+        Sequent.logger.debug("[Configuration] Autoregistering Projector #{projector_class}") if Sequent.logger.debug?
         self.class.instance.event_handlers << projector_class.new
       end
 
       for_each_autoregisterable_descenant_of(Sequent::Workflow) do |workflow_class|
-        Sequent.logger.debug("[Configuration] Autoregistering Workflow #{workflow_class}")
+        Sequent.logger.debug("[Configuration] Autoregistering Workflow #{workflow_class}") if Sequent.logger.debug?
         self.class.instance.event_handlers << workflow_class.new
       end
 

data/lib/sequent/core/aggregate_repository.rb

@@ -20,13 +20,13 @@ module Sequent
 
       class NonUniqueAggregateId < StandardError
         def initialize(existing, new)
-          super "Duplicate aggregate #{new} with same key as existing #{existing}"
+          super("Duplicate aggregate #{new} with same key as existing #{existing}")
         end
       end
 
       class AggregateNotFound < StandardError
         def initialize(id)
-          super "Aggregate with id #{id} not found"
+          super("Aggregate with id #{id} not found")
         end
       end