sequent 3.2.2 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10b5839af491a1fc854e512051185f6141b6bff465d4aea09fe7c6f20940ba4e
-  data.tar.gz: 32bccd0cc5b44a760e544a48b3be9578abcc9f9de7fbd083ca9ed6f38c5e5932
+  metadata.gz: 0b1fb847d194b47667729bdcf1e9ec4f8c78214f23ff71ee7ce37f1c225dc952
+  data.tar.gz: 23080b89717f7f2ebb30db682295cf0c598b120b84f3aec7ae372d193d937feb
 SHA512:
-  metadata.gz: 6c45431a49ad4100a7ad0ebe812aecb75144a9bf847823268a98b85c96689948e83fcfa76fd1d0c66dea5dabe923d41ab820ceefeb07cf2605d2b98296ebe7d6
-  data.tar.gz: 3198cc99cf9bfa8ba955aecc4fd85fd7559f848a83c64c77d7a7092fafeb7c2aadfec4e31f587c929304537e306e2f5cebfcbbd780c14700c9b384daeaede68e
+  metadata.gz: 33403d55a2d2bb8afd4892e952dcfe26aaa5ae9d4d25fd49bbca48f12fd5b4b077fba819450856b6f1f7b3587f0462c652b8679749bde380dcf10b53c2167cd8
+  data.tar.gz: baf1dc0def17b1a90a6895dd94dfb9777f6c6a1f4292e9f44c956bc1a7b487d86687a6cbf06b5ac84c193c302af134871f813bae2e5476c491246f8103c3b3a1

data/lib/sequent/application_record.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+
+module Sequent
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/lib/sequent/configuration.rb

@@ -26,6 +26,8 @@ module Sequent
 
     DEFAULT_EVENT_RECORD_HOOKS_CLASS = Sequent::Core::EventRecordHooks
 
+    DEFAULT_STRICT_CHECK_ATTRIBUTES_ON_APPLY_EVENTS = false
+
     attr_accessor :aggregate_repository
 
     attr_accessor :event_store,
@@ -49,6 +51,7 @@ module Sequent
 
     attr_accessor :logger
 
+
     attr_accessor :migration_sql_files_directory,
                   :view_schema_name,
                   :offline_replay_persistor_class,
@@ -57,6 +60,8 @@ module Sequent
                   :database_config_directory,
                   :event_store_schema_name
 
+    attr_accessor :strict_check_attributes_on_apply_events
+
     attr_reader :migrations_class_name,
                 :versions_table_name,
                 :replayed_ids_table_name
@@ -101,6 +106,7 @@ 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.strict_check_attributes_on_apply_events = DEFAULT_STRICT_CHECK_ATTRIBUTES_ON_APPLY_EVENTS
 
       self.logger = Logger.new(STDOUT).tap {|l| l.level = Logger::INFO }
     end

data/lib/sequent/core/command_record.rb

@@ -32,7 +32,7 @@ module Sequent
     end
 
     # For storing Sequent::Core::Command in the database using active_record
-    class CommandRecord < ActiveRecord::Base
+    class CommandRecord < Sequent::ApplicationRecord
       include SerializesCommand
 
       self.table_name = "command_records"

data/lib/sequent/core/event_record.rb

@@ -1,5 +1,6 @@
 require 'active_record'
 require_relative 'sequent_oj'
+require_relative '../application_record.rb'
 
 module Sequent
   module Core
@@ -72,7 +73,7 @@ module Sequent
       end
     end
 
-    class EventRecord < ActiveRecord::Base
+    class EventRecord < Sequent::ApplicationRecord
       include SerializesEvent
 
       self.table_name = "event_records"

data/lib/sequent/core/helpers/attribute_support.rb

@@ -20,6 +20,8 @@ module Sequent
       # get this functionality for free.
       #
       module AttributeSupport
+        class UnknownAttributeError < StandardError; end
+
         # module containing class methods to be added
         module ClassMethods
 
@@ -60,6 +62,7 @@ module Sequent
             class_eval <<EOS
               def update_all_attributes(attrs)
                 super if defined?(super)
+                ensure_known_attributes(attrs)
                 #{@types.map { |attribute, _|
               "@#{attribute} = attrs[:#{attribute}]"
             }.join("\n            ")}
@@ -157,9 +160,13 @@ EOS
           prefix ? HashWithIndifferentAccess[result.map { |k, v| ["#{prefix}_#{k}", v] }] : result
         end
 
-      end
-
+        def ensure_known_attributes(attrs)
+          return unless Sequent.configuration.strict_check_attributes_on_apply_events
 
+          unknowns = attrs.keys.map(&:to_s) - self.class.types.keys.map(&:to_s)
+          raise UnknownAttributeError.new("#{self.class.name} does not specify attrs: #{unknowns.join(", ")}") if unknowns.any?
+        end
+      end
     end
   end
 end

data/lib/sequent/core/persistors/active_record_persistor.rb

@@ -104,7 +104,7 @@ module Sequent
         end
 
         def execute_sql(statement)
-          ActiveRecord::Base.connection.execute(statement)
+          Sequent::ApplicationRecord.connection.execute(statement)
         end
 
         def commit

data/lib/sequent/core/persistors/replay_optimized_postgres_persistor.rb

@@ -307,7 +307,7 @@ module Sequent
               end
 
               buf = ''
-              conn = ActiveRecord::Base.connection.raw_connection
+              conn = Sequent::ApplicationRecord.connection.raw_connection
               copy_data = StringIO.new csv.string
               conn.transaction do
                 conn.copy_data("COPY #{clazz.table_name} (#{column_names.join(",")}) FROM STDIN WITH csv") do
@@ -346,7 +346,7 @@ module Sequent
         private
 
         def cast_value_to_column_type(clazz, column_name, record)
-          ActiveRecord::Base.connection.type_cast(record[column_name.to_sym], @column_cache[clazz.name][column_name])
+          Sequent::ApplicationRecord.connection.type_cast(record[column_name.to_sym], @column_cache[clazz.name][column_name])
         end
       end
     end

data/lib/sequent/core/projector.rb

@@ -11,7 +11,26 @@ module Sequent
         end
 
         def managed_tables
-          @managed_tables
+          @managed_tables || managed_tables_from_superclass
+        end
+
+        def manages_no_tables
+          @manages_no_tables = true
+          manages_tables *[]
+        end
+
+        def manages_no_tables?
+          !!@manages_no_tables || manages_no_tables_from_superclass?
+        end
+
+        private
+
+        def managed_tables_from_superclass
+          self.superclass.managed_tables if self.superclass.respond_to?(:managed_tables)
+        end
+
+        def manages_no_tables_from_superclass?
+          self.superclass.manages_no_tables? if self.superclass.respond_to?(:manages_no_tables?)
         end
       end
 
@@ -96,7 +115,10 @@ module Sequent
         :commit
 
       private
+
       def ensure_valid!
+        return if self.class.manages_no_tables?
+
         fail "A Projector must manage at least one table. Did you forget to add `managed_tables` to #{self.class.name}?" if self.class.managed_tables.nil? || self.class.managed_tables.empty?
       end
     end

data/lib/sequent/core/stream_record.rb

@@ -13,7 +13,7 @@ module Sequent
       end
     end
 
-    class StreamRecord < ActiveRecord::Base
+    class StreamRecord < Sequent::ApplicationRecord
 
       self.table_name = "stream_records"
 

data/lib/sequent/core/transactions/active_record_transaction_provider.rb

@@ -4,7 +4,7 @@ module Sequent
 
       class ActiveRecordTransactionProvider
         def transactional
-          ActiveRecord::Base.transaction(requires_new: true) do
+          Sequent::ApplicationRecord.transaction(requires_new: true) do
             yield
           end
           after_commit_queue.each &:call

data/lib/sequent/generator/template_project/app/records/post_record.rb

@@ -1,2 +1,2 @@
-class PostRecord < ActiveRecord::Base
+class PostRecord < Sequent::ApplicationRecord
 end

data/lib/sequent/migrations/executor.rb

@@ -0,0 +1,66 @@
+require_relative 'sql'
+
+module Sequent
+  module Migrations
+
+    ##
+    # The executor is the implementation of the 3-phase deploy in Sequent.
+    # is responsible for executing the `Planner::Plan`.
+    #
+    class Executor
+      include Sql
+
+      def execute_online(plan)
+        plan.replay_tables.each do |migration|
+          table = migration.record_class
+          sql_file = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql"
+          statements = sql_file_to_statements(sql_file) { |raw_sql| raw_sql.gsub('%SUFFIX%', "_#{migration.version}") }
+          statements.each(&method(:exec_sql))
+          table.table_name = "#{table.table_name}_#{migration.version}"
+          table.reset_column_information
+        end
+      end
+
+      def execute_offline(plan, current_version)
+        plan.replay_tables.each do |migration|
+          table = migration.record_class
+          current_table_name = table.table_name.gsub("_#{migration.version}", "")
+          # 2 Rename old table
+          exec_sql("ALTER TABLE IF EXISTS #{current_table_name} RENAME TO #{current_table_name}_#{current_version}")
+          # 3 Rename new table
+          exec_sql("ALTER TABLE #{table.table_name} RENAME TO #{current_table_name}")
+          # Use new table from now on
+          table.table_name = current_table_name
+          table.reset_column_information
+        end
+
+        plan.alter_tables.each do |migration|
+          table = migration.record_class
+          sql_file = "#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}_#{migration.version}.sql"
+          statements = sql_file_to_statements(sql_file)
+          statements.each(&method(:exec_sql))
+        end
+      end
+
+      def reset_table_names(plan)
+        plan.replay_tables.each do |migration|
+          table = migration.record_class
+          table.table_name = table.table_name.gsub("_#{migration.version}", "")
+          table.reset_column_information
+        end
+      end
+
+      def set_table_names_to_new_version(plan)
+        plan.replay_tables.each do |migration|
+          table = migration.record_class
+          unless table.table_name.end_with?("_#{migration.version}")
+            table.table_name = "#{table.table_name}_#{migration.version}"
+            table.reset_column_information
+            fail MigrationError.new("Table #{table.table_name} does not exist. Did you run ViewSchema.migrate_online first?") unless table.table_exists?
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/sequent/migrations/functions.rb

@@ -0,0 +1,76 @@
+module Sequent
+  module Migrations
+    class Migration
+
+      module ClassMethods
+        def create(record_class, version)
+          migration = new(record_class)
+          migration.version = version
+          migration
+        end
+      end
+
+      def self.inherited(child_class)
+        class << child_class
+          include ClassMethods
+        end
+      end
+
+      attr_reader :record_class
+      attr_accessor :version
+
+      def initialize(record_class)
+        @record_class = record_class
+        @version = nil
+      end
+
+      def table_name
+        @record_class.table_name
+      end
+
+      def copy(with_version)
+        self.class.create(record_class, with_version)
+      end
+
+      def ==(other)
+        return false unless other.class == self.class
+
+        self.table_name == other.table_name && version == other.version
+      end
+
+      def hash
+        self.table_name.hash + (version&.hash || 0)
+      end
+    end
+
+    class AlterTable < Migration; end
+
+    class ReplayTable < Migration; end
+
+    module Functions
+
+      module ClassMethods
+        def alter_table(name)
+          AlterTable.new(name)
+        end
+
+        def replay_table(name)
+          ReplayTable.new(name)
+        end
+
+        # Short hand for Sequent::Core::Migratable.all
+        def all_projectors
+          Sequent::Core::Migratable.all
+        end
+
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+
+    include Functions
+  end
+end

data/lib/sequent/migrations/migrations.rb

@@ -7,3 +7,4 @@ end
 require_relative 'migrate_events'
 require_relative 'projectors'
 require_relative 'view_schema'
+require_relative 'functions'

data/lib/sequent/migrations/planner.rb

@@ -0,0 +1,118 @@
+module Sequent
+  module Migrations
+    class Planner
+      Plan = Struct.new(:projectors, :migrations) do
+        def replay_tables
+          migrations.select { |m| m.class == ReplayTable }
+        end
+
+        def alter_tables
+          migrations.select { |m| m.class == AlterTable }
+        end
+
+        def empty?
+          migrations.empty?
+        end
+      end
+
+      attr_reader :versions
+
+      def initialize(versions)
+        @versions = versions
+      end
+
+      def plan(old, new)
+        migrations = versions.slice(*Range.new(old + 1, new).to_a.map(&:to_s))
+
+        Plan.new(
+          migrations.yield_self(&method(:select_projectors)),
+          migrations
+            .yield_self(&method(:create_migrations))
+            .yield_self(&method(:remove_redundant_migrations))
+        )
+      end
+
+      private
+
+      def select_projectors(migrations)
+        migrations
+          .values
+          .flatten
+          .select { |v| v.is_a?(Class) && v < Sequent::Projector }.uniq
+      end
+
+      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
+
+        (migrations - redundant_migrations)
+          .yield_self(&method(:remove_alter_tables_before_replay_table))
+      end
+
+      def group_identical_migrations(migrations)
+        migrations
+          .group_by { |migration| {migration_type: migration.class, record_class: migration.record_class} }
+      end
+
+      def select_redundant_migrations(grouped_migrations)
+        grouped_migrations.select { |type, ms| type[:migration_type] == ReplayTable && ms.length > 1 }
+      end
+
+      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)
+      end
+
+      def remove_redundancy(grouped_migrations)
+        grouped_migrations.reduce({}) { |memo, (key, ms)|
+          memo[key] = ms
+                        .yield_self(&method(:order_by_version_desc))
+                        .slice(1..-1)
+          memo
+        }
+      end
+
+      def order_by_version_desc(migrations)
+        migrations.sort_by { |m| m.version.to_i }
+          .reverse
+      end
+
+      def create_migrations(migrations)
+        migrations
+          .yield_self(&method(:map_to_migrations))
+          .values
+          .compact
+          .flatten
+      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)
+
+          memo[version] = _migrations.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)
+              migration.copy(version)
+            elsif migration < Sequent::Projector
+              migration.managed_tables.map { |table| ReplayTable.create(table, version) }
+            else
+              fail "Unknown Migration #{migration}"
+            end
+          end
+
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/sequent/migrations/projectors.rb

@@ -1,18 +1,19 @@
+require_relative 'planner'
 module Sequent
   module Migrations
     class Projectors
       def self.versions
-        fail "Define your own Sequent::Migrations::Projectors 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::Projectors 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.projectors_between(old, new)
-        versions.values_at(*Range.new(old + 1, new).to_a.map(&:to_s)).compact.flatten.uniq
+      def self.migrations_between(old, new)
+        Planner.new(versions).plan(old, new)
       end
     end
+
   end
 end
-

data/lib/sequent/migrations/sql.rb

@@ -0,0 +1,17 @@
+require_relative '../application_record'
+
+module Sequent
+  module Migrations
+    module Sql
+      def sql_file_to_statements(file_location)
+        sql_string = File.read(file_location, encoding: 'bom|utf-8')
+        sql_string = yield(sql_string) if block_given?
+        sql_string.split(/;$/).reject { |statement| statement.remove("\n").blank? }
+      end
+
+      def exec_sql(sql)
+        Sequent::ApplicationRecord.connection.execute(sql)
+      end
+    end
+  end
+end

data/lib/sequent/migrations/view_schema.rb

@@ -6,30 +6,56 @@ require_relative '../sequent'
 require_relative '../util/timer'
 require_relative '../util/printer'
 require_relative './projectors'
+require_relative 'planner'
+require_relative 'executor'
+require_relative 'sql'
 
 module Sequent
   module Migrations
     class MigrationError < RuntimeError; end
 
-
     ##
-    # Responsible for migration of Projectors between view schema versions.
+    # ViewSchema is used for migration of you view_schema. For instance
+    # when you create new Projectors or change existing Projectors.
     #
-    # A Projector needs migration when for instance:
+    # The following migrations are supported:
     #
-    # - New columns are added
-    # - Structure is changed
+    # - ReplayTable (Projector migrations)
+    # - 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`
-    # 2. Define per version which Projectors you want to migrate
+    # 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)
     #    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.
+    #
+    # Example:
+    #
+    # class AppMigrations < Sequent::Migrations::Projectors
+    #   def self.version
+    #     '3'
+    #   end
+    #
+    #   def self.versions
+    #     {
+    #       '1' => [Sequent.all_projectors],
+    #       '2' => [
+    #         UserProjector,
+    #         InvoiceProjector,
+    #       ],
+    #       '3' => [
+    #         Sequent::Migrations.alter_table(UserRecord)
+    #       ]
     #
+    #     }
+    #   end
+    #
+    # end
     class ViewSchema
-
       # Corresponds with the index on aggregate_id column in the event_records table
       #
       # Since we replay in batches of the first 3 chars of the uuid we created an index on
@@ -42,9 +68,10 @@ module Sequent
 
       include Sequent::Util::Timer
       include Sequent::Util::Printer
+      include Sql
 
-      class Versions < ActiveRecord::Base; end
-      class ReplayedIds < ActiveRecord::Base; end
+      class Versions < Sequent::ApplicationRecord; end
+      class ReplayedIds < Sequent::ApplicationRecord; end
 
       attr_reader :view_schema, :db_config, :logger
 
@@ -95,6 +122,14 @@ module Sequent
         end
       end
 
+      def plan
+        @plan ||= Planner.new(Sequent.migration_class.versions).plan(current_version, Sequent.new_version)
+      end
+
+      def executor
+        @executor ||= Executor.new
+      end
+
       ##
       # First part of a view schema migration
       #
@@ -118,14 +153,12 @@ module Sequent
           truncate_replay_ids_table!
 
           drop_old_tables(Sequent.new_version)
-          for_each_table_to_migrate do |table|
-            statements = sql_file_to_statements("#{Sequent.configuration.migration_sql_files_directory}/#{table.table_name}.sql") { |raw_sql| raw_sql.gsub('%SUFFIX%', "_#{Sequent.new_version}") }
-            statements.each { |statement| exec_sql(statement) }
-            table.table_name = "#{table.table_name}_#{Sequent.new_version}"
-            table.reset_column_information
-          end
+          executor.execute_online(plan)
+        end
+
+        if plan.projectors.any?
+          replay!(Sequent.configuration.online_replay_persistor_class.new)
         end
-        replay!(projectors_to_migrate, Sequent.configuration.online_replay_persistor_class.new)
       rescue Exception => e
         rollback_migration
         raise e
@@ -155,28 +188,20 @@ module Sequent
 
         ensure_version_correct!
 
-        set_table_names_to_new_version
+        executor.set_table_names_to_new_version(plan)
 
         # 1 replay events not yet replayed
-        replay!(projectors_to_migrate, Sequent.configuration.offline_replay_persistor_class.new, exclude_ids: true, group_exponent: 1)
+        replay!(Sequent.configuration.offline_replay_persistor_class.new, exclude_ids: true, group_exponent: 1) if plan.projectors.any?
 
         in_view_schema do
-          ActiveRecord::Base.transaction do
-            for_each_table_to_migrate do |table|
-              current_table_name = table.table_name.gsub("_#{Sequent.new_version}", "")
-              # 2 Rename old table
-              exec_sql("ALTER TABLE IF EXISTS #{current_table_name} RENAME TO #{current_table_name}_#{current_version}")
-              # 3 Rename new table
-              exec_sql("ALTER TABLE #{table.table_name} RENAME TO #{current_table_name}")
-              # Use new table from now on
-              table.table_name = current_table_name
-              table.reset_column_information
-            end
-            # 4. Create migration record
+          Sequent::ApplicationRecord.transaction do
+            # 2.1, 2.2
+            executor.execute_offline(plan, current_version)
+            # 2.3 Create migration record
             Versions.create!(version: Sequent.new_version)
           end
 
-          # 5. Truncate replayed ids
+          # 3. Truncate replayed ids
           truncate_replay_ids_table!
         end
         logger.info "Migrated to version #{Sequent.new_version}"
@@ -186,41 +211,29 @@ module Sequent
       end
 
       private
-      def set_table_names_to_new_version
-        for_each_table_to_migrate do |table|
-          unless table.table_name.end_with?("_#{Sequent.new_version}")
-            table.table_name = "#{table.table_name}_#{Sequent.new_version}"
-            table.reset_column_information
-            fail MigrationError.new("Table #{table.table_name} does not exist. Did you run migrate_online first?") unless table.table_exists?
-          end
-        end
-      end
 
-      def reset_table_names
-        for_each_table_to_migrate do |table|
-          table.table_name = table.table_name.gsub("_#{Sequent.new_version}", "")
-          table.reset_column_information
-        end
-      end
 
       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
+
       end
 
-      def replay!(projectors, replay_persistor, exclude_ids: false, group_exponent: 3)
+      def replay!(replay_persistor, exclude_ids: false, group_exponent: 3)
+        projectors = plan.projectors
+
         logger.info "group_exponent: #{group_exponent.inspect}"
 
         with_sequent_config(replay_persistor, projectors) do
           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
@@ -264,7 +277,7 @@ module Sequent
         drop_old_tables(Sequent.new_version)
 
         truncate_replay_ids_table!
-        reset_table_names
+        executor.reset_table_names(plan)
       end
 
       def truncate_replay_ids_table!
@@ -272,7 +285,7 @@ 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 = (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}" }
 
         logger.info "Number of groups #{number_of_groups}"
@@ -280,17 +293,7 @@ module Sequent
         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
 
-        all_prefixes.each_slice(all_prefixes.length/number_of_groups).to_a
-      end
-
-      def for_each_table_to_migrate
-        projectors_to_migrate.flat_map(&:managed_tables).each do |managed_table|
-          yield(managed_table)
-        end
-      end
-
-      def projectors_to_migrate
-        Sequent.migration_class.projectors_between(current_version, Sequent.new_version)
+        all_prefixes.each_slice(all_prefixes.length / number_of_groups).to_a
       end
 
       def in_view_schema
@@ -299,12 +302,6 @@ module Sequent
         end
       end
 
-      def sql_file_to_statements(file_location)
-        raw_sql_string = File.read(file_location, encoding: 'bom|utf-8')
-        sql_string = yield(raw_sql_string)
-        sql_string.split(/;$/).reject { |statement| statement.remove("\n").blank? }
-      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|
@@ -358,10 +355,6 @@ module Sequent
       def establish_connection
         Sequent::Support::Database.establish_connection(db_config)
       end
-
-      def exec_sql(sql)
-        ActiveRecord::Base.connection.execute(sql)
-      end
     end
   end
 end

data/lib/sequent/rake/migration_tasks.rb

@@ -117,7 +117,7 @@ module Sequent
             end
 
             task :delete_all => ['sequent:init', :init] do
-              result = ActiveRecord::Base.connection.execute("DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'")
+              result = Sequent::ApplicationRecord.connection.execute("DELETE FROM #{Sequent.configuration.event_record_class.table_name} WHERE event_type = 'Sequent::Core::SnapshotEvent'")
               Sequent.logger.info "Deleted #{result.cmd_tuples} aggregate snapshots from the event store"
             end
           end

data/lib/sequent/rake/tasks.rb

@@ -57,7 +57,7 @@ module Sequent
 
           task :establish_connection do
             env_db = db_config(options.fetch(:environment))
-            Sequent::Support::Database.establish_connection(env_db)
+            ActiveRecord::Base.establish_connection(env_db)
           end
 
           desc 'Migrate the database'

data/lib/sequent/sequent.rb

@@ -7,6 +7,7 @@ require_relative 'core/projector'
 require_relative 'core/workflow'
 require_relative 'core/value_object'
 require_relative 'generator'
+require_relative 'migrations/migrations'
 
 module Sequent
   def self.new_uuid

data/lib/sequent/support/database.rb

@@ -66,7 +66,6 @@ module Sequent
         ActiveRecord::Base.establish_connection db_config
 
         yield
-
       ensure
         disconnect!
         db_config['schema_search_path'] = original_search_paths
@@ -102,7 +101,6 @@ module Sequent
         else
           ActiveRecord::Migrator.migrate(migrations_path)
         end
-
       end
     end
   end

data/lib/sequent.rb

@@ -1,3 +1,4 @@
+require_relative 'sequent/application_record'
 require_relative 'sequent/sequent'
 require_relative 'sequent/core/core'
 require_relative 'sequent/util/util'

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Sequent
-  VERSION = '3.2.2'
+  VERSION = '3.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 3.3.0
 platform: ruby
 authors:
 - Lars Vonk
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-04 00:00:00.000000000 Z
+date: 2019-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -265,6 +265,7 @@ files:
 - bin/sequent
 - db/sequent_schema.rb
 - lib/sequent.rb
+- lib/sequent/application_record.rb
 - lib/sequent/configuration.rb
 - lib/sequent/core/aggregate_repository.rb
 - lib/sequent/core/aggregate_root.rb
@@ -344,9 +345,13 @@ files:
 - lib/sequent/generator/template_project/spec/app/projectors/post_projector_spec.rb
 - lib/sequent/generator/template_project/spec/lib/post/post_command_handler_spec.rb
 - lib/sequent/generator/template_project/spec/spec_helper.rb
+- lib/sequent/migrations/executor.rb
+- lib/sequent/migrations/functions.rb
 - lib/sequent/migrations/migrate_events.rb
 - lib/sequent/migrations/migrations.rb
+- lib/sequent/migrations/planner.rb
 - lib/sequent/migrations/projectors.rb
+- lib/sequent/migrations/sql.rb
 - lib/sequent/migrations/view_schema.rb
 - lib/sequent/rake/migration_tasks.rb
 - lib/sequent/rake/tasks.rb
@@ -377,7 +382,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="