sequent 3.3.1 → 4.1.0

data/lib/sequent/migrations/planner.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module Sequent
   module Migrations
     class Planner
       Plan = Struct.new(:projectors, :migrations) do
         def replay_tables
-          migrations.select { |m| m.class == ReplayTable }
+          migrations.select { |m| m.instance_of?(ReplayTable) }
         end
 
         def alter_tables
-          migrations.select { |m| m.class == AlterTable }
+          migrations.select { |m| m.instance_of?(AlterTable) }
         end
 
         def empty?
@@ -28,7 +30,7 @@ module Sequent
           migrations.yield_self(&method(:select_projectors)),
           migrations
             .yield_self(&method(:create_migrations))
-            .yield_self(&method(:remove_redundant_migrations))
+            .yield_self(&method(:remove_redundant_migrations)),
         )
       end
 
@@ -43,11 +45,11 @@ module Sequent
 
       def remove_redundant_migrations(migrations)
         redundant_migrations = migrations
-                                 .yield_self(&method(:group_identical_migrations))
-                                 .yield_self(&method(:select_redundant_migrations))
-                                 .yield_self(&method(:remove_redundancy))
-                                 .values
-                                 .flatten
+          .yield_self(&method(:group_identical_migrations))
+          .yield_self(&method(:select_redundant_migrations))
+          .yield_self(&method(:remove_redundancy))
+          .values
+          .flatten
 
         (migrations - redundant_migrations)
           .yield_self(&method(:remove_alter_tables_before_replay_table))
@@ -64,21 +66,22 @@ module Sequent
 
       def remove_alter_tables_before_replay_table(migrations)
         migrations - migrations
-                       .each_with_index
-                       .select { |migration, _index| migration.class == AlterTable }
-                       .select { |migration, index| migrations
-                                                      .slice((index + 1)..-1)
-                                                      .find { |m| m.class == ReplayTable && m.record_class == migration.record_class }
-                       }.map(&:first)
+          .each_with_index
+          .select { |migration, _index| migration.instance_of?(AlterTable) }
+          .select do |migration, index|
+                       migrations
+                         .slice((index + 1)..-1)
+                         .find { |m| m.instance_of?(ReplayTable) && m.record_class == migration.record_class }
+                     end.map(&:first)
       end
 
       def remove_redundancy(grouped_migrations)
-        grouped_migrations.reduce({}) { |memo, (key, ms)|
+        grouped_migrations.reduce({}) do |memo, (key, ms)|
           memo[key] = ms
-                        .yield_self(&method(:order_by_version_desc))
-                        .slice(1..-1)
+            .yield_self(&method(:order_by_version_desc))
+            .slice(1..-1)
           memo
-        }
+        end
       end
 
       def order_by_version_desc(migrations)
@@ -95,13 +98,20 @@ module Sequent
       end
 
       def map_to_migrations(migrations)
-        migrations.reduce({}) do |memo, (version, _migrations)|
-          fail "Declared migrations for version #{version} must be an Array. For example: {'3' => [FooProjector]}" unless _migrations.is_a?(Array)
+        migrations.reduce({}) do |memo, (version, ms)|
+          unless ms.is_a?(Array)
+            fail "Declared migrations for version #{version} must be an Array. For example: {'3' => [FooProjector]}"
+          end
 
-          memo[version] = _migrations.flat_map do |migration|
+          memo[version] = ms.flat_map do |migration|
             if migration.is_a?(AlterTable)
-              alter_table_sql_file_name = "#{Sequent.configuration.migration_sql_files_directory}/#{migration.table_name}_#{version}.sql"
-              fail "Missing file #{alter_table_sql_file_name} to apply for version #{version}" unless File.exist?(alter_table_sql_file_name)
+              alter_table_sql_file_name = <<~EOS.chomp
+                #{Sequent.configuration.migration_sql_files_directory}/#{migration.table_name}_#{version}.sql
+              EOS
+              unless File.exist?(alter_table_sql_file_name)
+                fail "Missing file #{alter_table_sql_file_name} to apply for version #{version}"
+              end
+
               migration.copy(version)
             elsif migration < Sequent::Projector
               migration.managed_tables.map { |table| ReplayTable.create(table, version) }

data/lib/sequent/migrations/projectors.rb

@@ -1,19 +1,20 @@
+# frozen_string_literal: true
+
 require_relative 'planner'
 module Sequent
   module Migrations
     class Projectors
       def self.versions
-        fail "Define your own Sequent::Migrations::List class that extends this class and implements this method"
+        fail 'Define your own Sequent::Migrations::List class that extends this class and implements this method'
       end
 
       def self.version
-        fail "Define your own Sequent::Migrations::List class that extends this class and implements this method"
+        fail 'Define your own Sequent::Migrations::List class that extends this class and implements this method'
       end
 
       def self.migrations_between(old, new)
         Planner.new(versions).plan(old, new)
       end
     end
-
   end
 end

data/lib/sequent/migrations/sql.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../application_record'
 
 module Sequent

data/lib/sequent/migrations/view_schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parallel'
 require 'postgresql_cursor'
 
@@ -24,11 +26,13 @@ module Sequent
     # - AlterTable (For instance if you introduce a new column)
     #
     # To maintain your migrations you need to:
-    # 1. Create a class that extends `Sequent::Migrations::Projectors` and specify in `Sequent.configuration.migrations_class_name`
+    # 1. Create a class that extends `Sequent::Migrations::Projectors`
+    #    and specify in `Sequent.configuration.migrations_class_name`
     # 2. Define per version which migrations you want to execute
     #    See the definition of `Sequent::Migrations::Projectors.versions` and `Sequent::Migrations::Projectors.version`
     # 3. Specify in Sequent where your sql files reside (Sequent.configuration.migration_sql_files_directory)
-    # 4. Ensure that you add %SUFFIX% to each name that needs to be unique in postgres (like TABLE names, INDEX names, PRIMARY KEYS)
+    # 4. Ensure that you add %SUFFIX% to each name that needs to be unique in postgres
+    #    (like TABLE names, INDEX names, PRIMARY KEYS)
     #    E.g. `create table foo%SUFFIX% (id serial NOT NULL, CONSTRAINT foo_pkey%SUFFIX% PRIMARY KEY (id))`
     # 5. If you want to run an `alter_table` migration ensure that
     #   a sql file named `table_name_VERSION.sql` exists.
@@ -96,8 +100,17 @@ module Sequent
         create_view_schema_if_not_exists
         in_view_schema do
           Sequent::Core::Migratable.all.flat_map(&:managed_tables).each do |table|
-            statements = sql_file_to_statements("#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql") { |raw_sql| raw_sql.remove('%SUFFIX%') }
+            sql_file = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql"
+            statements = sql_file_to_statements(sql_file) do |raw_sql|
+              raw_sql.remove('%SUFFIX%')
+            end
             statements.each { |statement| exec_sql(statement) }
+
+            indexes_file_name = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.indexes.sql"
+            if File.exist?(indexes_file_name)
+              statements = sql_file_to_statements(indexes_file_name) { |raw_sql| raw_sql.remove('%SUFFIX%') }
+              statements.each(&method(:exec_sql))
+            end
           end
         end
       end
@@ -115,10 +128,14 @@ module Sequent
       #
       # This method is mainly useful during an initial setup of the view schema
       def create_view_schema_if_not_exists
-        exec_sql(%Q{CREATE SCHEMA IF NOT EXISTS #{view_schema}})
+        exec_sql(%(CREATE SCHEMA IF NOT EXISTS #{view_schema}))
         in_view_schema do
-          exec_sql(%Q{CREATE TABLE IF NOT EXISTS #{Versions.table_name} (version integer NOT NULL, CONSTRAINT version_pk PRIMARY KEY(version))})
-          exec_sql(%Q{CREATE TABLE IF NOT EXISTS #{ReplayedIds.table_name} (event_id bigint NOT NULL, CONSTRAINT event_id_pk PRIMARY KEY(event_id))})
+          exec_sql(<<~SQL.chomp)
+            CREATE TABLE IF NOT EXISTS #{Versions.table_name} (version integer NOT NULL, CONSTRAINT version_pk PRIMARY KEY(version))
+          SQL
+          exec_sql(<<~SQL.chomp)
+            CREATE TABLE IF NOT EXISTS #{ReplayedIds.table_name} (event_id bigint NOT NULL, CONSTRAINT event_id_pk PRIMARY KEY(event_id))
+          SQL
         end
       end
 
@@ -156,10 +173,14 @@ module Sequent
           executor.execute_online(plan)
         end
 
-        if plan.projectors.any?
-          replay!(Sequent.configuration.online_replay_persistor_class.new)
+        replay!(Sequent.configuration.online_replay_persistor_class.new) if plan.projectors.any?
+
+        in_view_schema do
+          executor.create_indexes_after_execute_online(plan)
         end
+        # rubocop:disable Lint/RescueException
       rescue Exception => e
+        # rubocop:enable Lint/RescueException
         rollback_migration
         raise e
       end
@@ -191,7 +212,13 @@ module Sequent
         executor.set_table_names_to_new_version(plan)
 
         # 1 replay events not yet replayed
-        replay!(Sequent.configuration.offline_replay_persistor_class.new, exclude_ids: true, group_exponent: 1) if plan.projectors.any?
+        if plan.projectors.any?
+          replay!(
+            Sequent.configuration.offline_replay_persistor_class.new,
+            exclude_ids: true,
+            group_exponent: 1,
+          )
+        end
 
         in_view_schema do
           Sequent::ApplicationRecord.transaction do
@@ -205,50 +232,57 @@ module Sequent
           truncate_replay_ids_table!
         end
         logger.info "Migrated to version #{Sequent.new_version}"
+        # rubocop:disable Lint/RescueException
       rescue Exception => e
+        # rubocop:enable Lint/RescueException
         rollback_migration
         raise e
       end
 
       private
 
-
       def ensure_version_correct!
         create_view_schema_if_not_exists
         new_version = Sequent.new_version
 
-        fail ArgumentError.new("new_version [#{new_version}] must be greater or equal to current_version [#{current_version}]") if new_version < current_version
-
+        if new_version < current_version
+          fail ArgumentError,
+               "new_version [#{new_version}] must be greater or equal to current_version [#{current_version}]"
+        end
       end
 
       def replay!(replay_persistor, projectors: plan.projectors, exclude_ids: false, group_exponent: 3)
         logger.info "group_exponent: #{group_exponent.inspect}"
 
         with_sequent_config(replay_persistor, projectors) do
-          logger.info "Start replaying events"
+          logger.info 'Start replaying events'
 
-          time("#{16 ** group_exponent} groups replayed") do
+          time("#{16**group_exponent} groups replayed") do
             event_types = projectors.flat_map { |projector| projector.message_mapping.keys }.uniq.map(&:name)
             disconnect!
 
-            number_of_groups = 16 ** group_exponent
+            number_of_groups = 16**group_exponent
             groups = groups_of_aggregate_id_prefixes(number_of_groups)
 
             @connected = false
             # using `map_with_index` because https://github.com/grosser/parallel/issues/175
-            result = Parallel.map_with_index(groups, in_processes: Sequent.configuration.number_of_replay_processes) do |aggregate_prefixes, index|
-              begin
-                @connected ||= establish_connection
-                time("Group (#{aggregate_prefixes.first}-#{aggregate_prefixes.last}) #{index + 1}/#{number_of_groups} replayed") do
-                  replay_events(aggregate_prefixes, event_types, exclude_ids, replay_persistor, &insert_ids)
-                end
-                nil
-              rescue => e
-                logger.error "Replaying failed for ids: ^#{aggregate_prefixes.first} - #{aggregate_prefixes.last}"
-                logger.error "+++++++++++++++ ERROR +++++++++++++++"
-                recursively_print(e)
-                raise Parallel::Kill # immediately kill all sub-processes
+            result = Parallel.map_with_index(
+              groups,
+              in_processes: Sequent.configuration.number_of_replay_processes,
+            ) do |aggregate_prefixes, index|
+              @connected ||= establish_connection
+              msg = <<~EOS.chomp
+                Group (#{aggregate_prefixes.first}-#{aggregate_prefixes.last}) #{index + 1}/#{number_of_groups} replayed
+              EOS
+              time(msg) do
+                replay_events(aggregate_prefixes, event_types, exclude_ids, replay_persistor, &insert_ids)
               end
+              nil
+            rescue StandardError => e
+              logger.error "Replaying failed for ids: ^#{aggregate_prefixes.first} - #{aggregate_prefixes.last}"
+              logger.error '+++++++++++++++ ERROR +++++++++++++++'
+              recursively_print(e)
+              raise Parallel::Kill # immediately kill all sub-processes
             end
             establish_connection
             fail if result.nil?
@@ -260,7 +294,7 @@ module Sequent
         Sequent.configuration.event_store.replay_events_from_cursor(
           block_size: 1000,
           get_events: -> { event_stream(aggregate_prefixes, event_types, exclude_already_replayed) },
-          on_progress: on_progress
+          on_progress: on_progress,
         )
 
         replay_persistor.commit
@@ -283,29 +317,31 @@ module Sequent
       end
 
       def groups_of_aggregate_id_prefixes(number_of_groups)
-        all_prefixes = (0...16 ** LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE).to_a.map { |i| i.to_s(16) } # first x digits of hex
-        all_prefixes = all_prefixes.map { |s| s.length == 3 ? s : "#{"0" * (3 - s.length)}#{s}" }
+        all_prefixes = (0...16**LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE).to_a.map do |i|
+          i.to_s(16)
+        end
+        all_prefixes = all_prefixes.map { |s| s.length == 3 ? s : "#{'0' * (3 - s.length)}#{s}" }
 
         logger.info "Number of groups #{number_of_groups}"
 
         logger.debug "Prefixes: #{all_prefixes.length}"
-        fail "Can not have more groups #{number_of_groups} than number of prefixes #{all_prefixes.length}" if number_of_groups > all_prefixes.length
+        if number_of_groups > all_prefixes.length
+          fail "Can not have more groups #{number_of_groups} than number of prefixes #{all_prefixes.length}"
+        end
 
         all_prefixes.each_slice(all_prefixes.length / number_of_groups).to_a
       end
 
-      def in_view_schema
-        Sequent::Support::Database.with_schema_search_path(view_schema, db_config) do
-          yield
-        end
+      def in_view_schema(&block)
+        Sequent::Support::Database.with_schema_search_path(view_schema, db_config, &block)
       end
 
       def drop_old_tables(new_version)
         versions_to_check = (current_version - 10)..new_version
         old_tables = versions_to_check.flat_map do |old_version|
-          exec_sql(
-            "select table_name from information_schema.tables where table_schema = '#{Sequent.configuration.view_schema_name}' and table_name LIKE '%_#{old_version}'"
-          ).flat_map { |row| row.values }
+          exec_sql(<<~SQL).flat_map(&:values)
+            select table_name from information_schema.tables where table_schema = '#{Sequent.configuration.view_schema_name}' and table_name LIKE '%_#{old_version}'
+          SQL
         end
         old_tables.each do |old_table|
           exec_sql("DROP TABLE #{Sequent.configuration.view_schema_name}.#{old_table} CASCADE")
@@ -314,7 +350,13 @@ module Sequent
 
       def insert_ids
         ->(progress, done, ids) do
-          exec_sql("insert into #{ReplayedIds.table_name} (event_id) values #{ids.map { |id| "(#{id})" }.join(',')}") unless ids.empty?
+          unless ids.empty?
+            exec_sql(
+              "insert into #{ReplayedIds.table_name} (event_id) values #{ids.map do |id|
+                                                                           "(#{id})"
+                                                                         end.join(',')}",
+            )
+          end
           Sequent::Core::EventStore::PRINT_PROGRESS[progress, done, ids] if progress > 0
         end
       end
@@ -324,7 +366,9 @@ module Sequent
 
         config = Sequent.configuration.dup
 
-        replay_projectors = projectors.map { |projector_class| projector_class.new(projector_class.replay_persistor || replay_persistor) }
+        replay_projectors = projectors.map do |projector_class|
+          projector_class.new(projector_class.replay_persistor || replay_persistor)
+        end
         config.transaction_provider = Sequent::Core::Transactions::NoTransactions.new
         config.event_handlers = replay_projectors
 
@@ -336,12 +380,17 @@ module Sequent
       end
 
       def event_stream(aggregate_prefixes, event_types, exclude_already_replayed)
-        fail ArgumentError.new("aggregate_prefixes is mandatory") unless aggregate_prefixes.present?
+        fail ArgumentError, 'aggregate_prefixes is mandatory' unless aggregate_prefixes.present?
 
         event_stream = Sequent.configuration.event_record_class.where(event_type: event_types)
-        event_stream = event_stream.where("substring(aggregate_id::varchar from 1 for #{LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE}) in (?)", aggregate_prefixes)
-        event_stream = event_stream.where("NOT EXISTS (SELECT 1 FROM #{ReplayedIds.table_name} WHERE event_id = event_records.id)") if exclude_already_replayed
-        event_stream = event_stream.where("event_records.created_at > ?", 1.day.ago) if exclude_already_replayed
+        event_stream = event_stream.where(<<~SQL, aggregate_prefixes)
+          substring(aggregate_id::varchar from 1 for #{LENGTH_OF_SUBSTRING_INDEX_ON_AGGREGATE_ID_IN_EVENT_STORE}) in (?)
+        SQL
+        if exclude_already_replayed
+          event_stream = event_stream
+            .where("NOT EXISTS (SELECT 1 FROM #{ReplayedIds.table_name} WHERE event_id = event_records.id)")
+        end
+        event_stream = event_stream.where('event_records.created_at > ?', 1.day.ago) if exclude_already_replayed
         event_stream.order('sequence_number ASC').select('id, event_type, event_json, sequence_number')
       end
 

data/lib/sequent/rake/migration_tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'rake'
 require 'rake/tasklib'
@@ -12,13 +14,14 @@ module Sequent
 
       def register_tasks!
         namespace :sequent do
-          desc 'Rake task that runs before all sequent rake tasks. Hook applications can use to for instance run other rake tasks.'
+          desc <<~EOS
+            Rake task that runs before all sequent rake tasks. Hook applications can use to for instance run other rake tasks.
+          EOS
           task :init
 
           namespace :db do
-
             desc 'Creates the database and initializes the event_store schema for the current env'
-            task :create => ['sequent:init'] do
+            task create: ['sequent:init'] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -31,14 +34,18 @@ module Sequent
             task :drop, [:production] => ['sequent:init'] do |_t, args|
               ensure_rack_env_set!
 
-              fail "Wont drop db in production unless you whitelist the environment as follows: rake sequent:db:drop[yes_drop_production]" if @env == 'production' && args[:production] != 'yes_drop_production'
+              if @env == 'production' && args[:production] != 'yes_drop_production'
+                fail <<~OES
+                  Wont drop db in production unless you whitelist the environment as follows: rake sequent:db:drop[yes_drop_production]
+                OES
+              end
 
               db_config = Sequent::Support::Database.read_config(@env)
               Sequent::Support::Database.drop!(db_config)
             end
 
             desc 'Creates the view schema for the current env'
-            task :create_view_schema => ['sequent:init'] do
+            task create_view_schema: ['sequent:init'] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -47,33 +54,41 @@ module Sequent
             end
 
             desc 'Creates the event_store schema for the current env'
-            task :create_event_store => ['sequent:init'] do
+            task create_event_store: ['sequent:init'] do
               ensure_rack_env_set!
               db_config = Sequent::Support::Database.read_config(@env)
               create_event_store(db_config)
             end
 
+            # rubocop:disable Lint/NestedMethodDefinition
             def create_event_store(db_config)
               event_store_schema = Sequent.configuration.event_store_schema_name
-              sequent_schema = File.join(Sequent.configuration.database_config_directory, "#{event_store_schema}.rb")
-              fail "File #{sequent_schema} does not exist. Check your Sequent configuration." unless File.exists?(sequent_schema)
+              sequent_schema = File.join(Sequent.configuration.database_schema_directory, "#{event_store_schema}.rb")
+              unless File.exist?(sequent_schema)
+                fail "File #{sequent_schema} does not exist. Check your Sequent configuration."
+              end
 
               Sequent::Support::Database.establish_connection(db_config)
-              fail "Schema #{event_store_schema} already exists in the database" if Sequent::Support::Database.schema_exists?(event_store_schema)
+              if Sequent::Support::Database.schema_exists?(event_store_schema)
+                fail "Schema #{event_store_schema} already exists in the database"
+              end
 
               Sequent::Support::Database.create_schema(event_store_schema)
               Sequent::Support::Database.with_schema_search_path(event_store_schema, db_config, @env) do
                 load(sequent_schema)
               end
             end
+            # rubocop:enable Lint/NestedMethodDefinition
           end
 
           namespace :migrate do
-            desc 'Rake task that runs before all migrate rake tasks. Hook applications can use to for instance run other rake tasks.'
+            desc <<~EOS
+              Rake task that runs before all migrate rake tasks. Hook applications can use to for instance run other rake tasks.
+            EOS
             task :init
 
             desc 'Prints the current version in the database'
-            task :current_version => ['sequent:init', :init] do
+            task current_version: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               Sequent::Support::Database.connect!(@env)
@@ -81,8 +96,10 @@ module Sequent
               puts "Current version in the database is: #{Sequent::Migrations::ViewSchema::Versions.maximum(:version)}"
             end
 
-            desc 'Migrates the Projectors while the app is running. Call +sequent:migrate:offline+ after this successfully completed.'
-            task :online => ['sequent:init', :init] do
+            desc <<~EOS
+              Migrates the Projectors while the app is running. Call +sequent:migrate:offline+ after this successfully completed.
+            EOS
+            task online: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -91,8 +108,10 @@ module Sequent
               view_schema.migrate_online
             end
 
-            desc 'Migrates the events inserted while +online+ was running. It is expected +sequent:migrate:online+ ran first.'
-            task :offline => ['sequent:init', :init] do
+            desc <<~EOS
+              Migrates the events inserted while +online+ was running. It is expected +sequent:migrate:online+ ran first.
+            EOS
+            task offline: ['sequent:init', :init] do
               ensure_rack_env_set!
 
               db_config = Sequent::Support::Database.read_config(@env)
@@ -103,21 +122,35 @@ module Sequent
           end
 
           namespace :snapshots do
-            desc 'Rake task that runs before all snapshots rake tasks. Hook applications can use to for instance run other rake tasks.'
+            desc <<~EOS
+              Rake task that runs before all snapshots rake tasks. Hook applications can use to for instance run other rake tasks.
+            EOS
             task :init
 
-            task :set_snapshot_threshold, [:aggregate_type,:threshold] => ['sequent:init', :init] do
+            task :set_snapshot_threshold, %i[aggregate_type threshold] => ['sequent:init', :init] do |_t, args|
               aggregate_type = args['aggregate_type']
               threshold = args['threshold']
 
-              fail ArgumentError.new('usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]') unless aggregate_type
-              fail ArgumentError.new('usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]') unless threshold
+              unless aggregate_type
+                fail ArgumentError,
+                     'usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]'
+              end
+              unless threshold
+                fail ArgumentError,
+                     'usage rake sequent:snapshots:set_snapshot_threshold[AggregegateType,threshold]'
+              end
 
-              execute "UPDATE #{Sequent.configuration.stream_record_class} SET snapshot_threshold = #{threshold.to_i} WHERE aggregate_type = '#{aggregate_type}'"
+              execute <<~EOS
+                UPDATE #{Sequent.configuration.stream_record_class} SET snapshot_threshold = #{threshold.to_i} WHERE aggregate_type = '#{aggregate_type}'
+              EOS
             end
 
-            task :delete_all => ['sequent:init', :init] do
-              result = Sequent::ApplicationRecord.connection.execute("DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'")
+            task delete_all: ['sequent:init', :init] do
+              result = Sequent::ApplicationRecord
+                .connection
+                .execute(<<~EOS)
+                  DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'
+                EOS
               Sequent.logger.info "Deleted #{result.cmd_tuples} aggregate snapshots from the event store"
             end
           end
@@ -125,9 +158,12 @@ module Sequent
       end
 
       private
+
+      # rubocop:disable Naming/MemoizedInstanceVariableName
       def ensure_rack_env_set!
-        @env ||= ENV['RACK_ENV'] || fail("RACK_ENV not set")
+        @env ||= ENV['RACK_ENV'] || fail('RACK_ENV not set')
       end
+      # rubocop:enable Naming/MemoizedInstanceVariableName
     end
   end
 end

data/lib/sequent/rake/tasks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'rake'
 require 'rake/tasklib'
@@ -11,12 +13,13 @@ module Sequent
 
       DEFAULT_OPTIONS = {
         migrations_path: 'db/migrate',
-        event_store_schema: 'public'
-      }
+        event_store_schema: 'public',
+      }.freeze
 
       attr_reader :options
 
       def initialize(options)
+        super()
         @options = DEFAULT_OPTIONS.merge(options)
       end
 

data/lib/sequent/sequent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'configuration'
 require_relative 'core/event'
 require_relative 'core/command'
@@ -6,7 +8,6 @@ require_relative 'core/aggregate_root'
 require_relative 'core/projector'
 require_relative 'core/workflow'
 require_relative 'core/value_object'
-require_relative 'generator'
 require_relative 'migrations/migrations'
 
 module Sequent
@@ -65,6 +66,10 @@ module Sequent
     configuration.aggregate_repository
   end
 
+  def self.dry_run(*commands)
+    Sequent::Util::DryRun.these_commands(commands)
+  end
+
   # Shortcut classes for easy usage
   Event = Sequent::Core::Event
   Command = Sequent::Core::Command