sequent 8.1.1 → 8.2.0

data/lib/sequent/core/command_record.rb

@@ -20,7 +20,6 @@ module Sequent
 
         # optional attributes (here for historic reasons)
         # 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,

data/lib/sequent/core/event_record.rb

@@ -53,7 +53,6 @@ module Sequent
       def event=(event)
         self.aggregate_id = event.aggregate_id
         self.sequence_number = event.sequence_number
-        self.organization_id = event.organization_id if event.respond_to?(:organization_id)
         self.event_type = event.class.name
         self.created_at = event.created_at
         self.event_json = serialize_json? ? self.class.serialize_to_json(event) : event.attributes

data/lib/sequent/core/event_store.rb

@@ -10,6 +10,25 @@ require_relative 'snapshot_store'
 module Sequent
   module Core
     class AggregateKeyNotUniqueError < RuntimeError
+      attr_reader :aggregate_type, :aggregate_id
+
+      def self.unique_key_error_message?(message)
+        message =~ /duplicate unique key value for aggregate/
+      end
+
+      def initialize(message)
+        super
+
+        match = message.match(
+          # rubocop:disable Layout/LineLength
+          /aggregate (\p{Upper}\p{Alnum}*(?:::\p{Upper}\p{Alnum}*)*) (\p{XDigit}{8}-\p{XDigit}{4}-\p{XDigit}{4}-\p{XDigit}{4}-\p{XDigit}{12})/,
+          # rubocop:enable Layout/LineLength
+        )
+        if match
+          @aggregate_type = match[1]
+          @aggregate_id = match[2]
+        end
+      end
     end
 
     class EventStore
@@ -201,6 +220,47 @@ module Sequent
         ]
       end
 
+      # Returns an enumerator that yields aggregate ids in blocks of `group_size` arrays. Optionally the
+      # aggregate root type can be specified (as a string) to only yield aggregate ids of the indicated type.
+      def event_streams_enumerator(aggregate_type: nil, group_size: 100)
+        Enumerator.new do |yielder|
+          last_aggregate_id = nil
+          loop do
+            aggregate_rows = ActiveRecord::Base.connection.exec_query(
+              'SELECT aggregate_id
+                 FROM aggregates
+                WHERE ($1::text IS NULL OR aggregate_type_id = (SELECT id FROM aggregate_types WHERE type = $1))
+                  AND ($3::uuid IS NULL OR aggregate_id > $3)
+                ORDER BY 1
+                LIMIT $2',
+              'aggregates_to_update',
+              [
+                aggregate_type,
+                group_size,
+                last_aggregate_id,
+              ],
+            ).to_a
+            break if aggregate_rows.empty?
+
+            last_aggregate_id = aggregate_rows.last['aggregate_id']
+
+            yielder << aggregate_rows.map { |x| x['aggregate_id'] }
+          end
+        end
+      end
+
+      def update_unique_keys(event_streams)
+        fail ArgumentError, 'array of stream records expected' unless event_streams.all? { |x| x.is_a?(EventStream) }
+
+        call_procedure(connection, 'update_unique_keys', [event_streams.to_json])
+      rescue ActiveRecord::RecordNotUnique => e
+        if AggregateKeyNotUniqueError.unique_key_error_message?(e.message)
+          raise AggregateKeyNotUniqueError, e.message
+        else
+          raise OptimisticLockingError
+        end
+      end
+
       def permanently_delete_event_stream(aggregate_id)
         permanently_delete_event_streams([aggregate_id])
       end
@@ -209,12 +269,10 @@ module Sequent
         call_procedure(connection, 'permanently_delete_event_streams', [aggregate_ids.to_json])
       end
 
-      def permanently_delete_commands_without_events(aggregate_id: nil, organization_id: nil)
-        unless aggregate_id || organization_id
-          fail ArgumentError, 'aggregate_id and/or organization_id must be specified'
-        end
+      def permanently_delete_commands_without_events(aggregate_id:)
+        fail ArgumentError, 'aggregate_id must be specified' unless aggregate_id
 
-        call_procedure(connection, 'permanently_delete_commands_without_events', [aggregate_id, organization_id])
+        call_procedure(connection, 'permanently_delete_commands_without_events', [aggregate_id])
       end
 
       private
@@ -277,7 +335,7 @@ module Sequent
           ],
         )
       rescue ActiveRecord::RecordNotUnique => e
-        if e.message =~ /duplicate unique key value for aggregate/
+        if AggregateKeyNotUniqueError.unique_key_error_message?(e.message)
           raise AggregateKeyNotUniqueError, e.message
         else
           raise OptimisticLockingError

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

@@ -20,11 +20,13 @@ module Sequent
         # or a falsey value otherwise.
         #
         def register_matchers(*matchers, handler)
+          fail ArgumentError, 'handler is required' if handler.nil?
+
           matchers.each do |matcher|
             if matcher.is_a?(MessageMatchers::InstanceOf)
-              @instanceof_routes[matcher.expected_class] << handler
+              (@instanceof_routes[matcher.expected_class] ||= Set.new) << handler
             else
-              @routes[matcher] << handler
+              (@routes[matcher] ||= Set.new) << handler
             end
           end
         end
@@ -34,7 +36,7 @@ module Sequent
         #
         def match_message(message)
           result = Set.new
-          result.merge(@instanceof_routes[message.class])
+          result.merge(@instanceof_routes[message.class]) if @instanceof_routes.include?(message.class)
           @routes.each do |matcher, handlers|
             result.merge(handlers) if matcher.matches_message?(message)
           end
@@ -45,15 +47,16 @@ module Sequent
         # Returns true when there is at least one handler for the given message, or false otherwise.
         #
         def matches_message?(message)
-          match_message(message).any?
+          @instanceof_routes.include?(message.class) ||
+            @routes.keys.any? { |matcher| matcher.matches_message?(message) }
         end
 
         ##
         # Removes all routes from the router.
         #
         def clear_routes
-          @instanceof_routes = Hash.new { |h, k| h[k] = Set.new }
-          @routes = Hash.new { |h, k| h[k] = Set.new }
+          @instanceof_routes = {}
+          @routes = {}
         end
       end
     end

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

@@ -45,20 +45,7 @@ module Sequent
         end
 
         def create_records(record_class, array_of_value_hashes)
-          table = record_class.arel_table
-
-          query = array_of_value_hashes.map do |values|
-            insert_manager = new_insert_manager
-            insert_manager.into(table)
-            insert_manager.insert(
-              values.map do |key, value|
-                convert_to_values(key, table, value)
-              end,
-            )
-            insert_manager.to_sql
-          end.join(';')
-
-          execute_sql(query)
+          record_class.unscoped.insert_all!(array_of_value_hashes, returning: false)
         end
 
         def create_or_update_record(record_class, values, created_at = Time.now)
@@ -130,14 +117,6 @@ module Sequent
         def new_record(record_class, values)
           record_class.unscoped.new(values)
         end
-
-        def new_insert_manager
-          Arel::InsertManager.new
-        end
-
-        def convert_to_values(key, table, value)
-          [table[key], table.type_cast_for_database(key, value)]
-        end
       end
     end
   end

data/lib/sequent/generator/template_project/db/database.yml

@@ -1,9 +1,8 @@
 database: &database
   adapter: postgresql
   host: localhost
-  port: 5432
   timeout: 5000
-  schema_search_path: "sequent_schema, view_schema"
+  schema_search_path: "public, sequent_schema, view_schema"
 
 development:
   <<: *database
@@ -14,4 +13,3 @@ test:
   <<: *database
   pool: 5
   database: my_app_test
-

data/lib/sequent/generator/template_project/spec/spec_helper.rb

@@ -23,7 +23,6 @@ RSpec.configure do |config|
   config.before :suite do
     Sequent::Support::Database.connect!('test')
     Sequent::Support::Database.drop_schema!(Sequent.configuration.view_schema_name)
-    Sequent::Support::Database.drop_schema!(Sequent.configuration.event_store_schema_name)
 
     Sequent::Test::DatabaseHelpers.maintain_test_database_schema(env: 'test')
   end

data/lib/sequent/migrations/sequent_schema.rb

@@ -14,8 +14,7 @@ module Sequent
         def create_sequent_schema_if_not_exists(env:, fail_if_exists: true)
           fail ArgumentError, 'env is required' if env.blank?
 
-          db_config = Sequent::Support::Database.read_config(env)
-
+          db_config = Sequent::Support::Database.read_database_config(env)
           Sequent::Support::Database.establish_connection(db_config)
 
           event_store_schema = Sequent.configuration.event_store_schema_name
@@ -25,15 +24,7 @@ module Sequent
           FAIL_IF_EXISTS.call(event_store_schema) if schema_exists && fail_if_exists
           return if schema_exists
 
-          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.create_schema(event_store_schema)
-          Sequent::Support::Database.with_schema_search_path(event_store_schema, db_config, env) do
-            load(sequent_schema)
-          end
+          ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, :sql)
         end
       end
     end

data/lib/sequent/migrations/view_schema.rb

@@ -383,7 +383,7 @@ module Sequent
       end
 
       def in_view_schema(&block)
-        Sequent::Support::Database.with_schema_search_path(view_schema, db_config, &block)
+        Sequent::Support::Database.with_search_path(view_schema, &block)
       end
 
       def drop_old_tables(new_version)

data/lib/sequent/rake/migration_files.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Sequent
+  module Rake
+    class MigrationFiles
+      MIGRATION_DIRECTORY = File.realpath(File.join(__dir__, '../../../db/migrate'))
+
+      def copy(to)
+        FileUtils.mkdir_p(to)
+        now = Time.current.strftime('%Y%m%d%H%M%S')
+        current_entries = current_migration_files(to)
+
+        Dir
+          .entries(MIGRATION_DIRECTORY)
+          .reject { |dir| dir.start_with?('.') }
+          .sort
+          .each_with_index do |file, index|
+            full_file_name = File.join(MIGRATION_DIRECTORY, file)
+
+            if File.directory?(full_file_name)
+              copy_directory(file, MIGRATION_DIRECTORY, to)
+            else
+              _timestamp, *file_parts = file.split('_')
+              next if current_entries.include?(file_parts.join('_'))
+
+              file_name = [(now.to_i + index).to_s, *file_parts].join('_')
+              destination_file_name = File.join(to, file_name)
+              FileUtils.cp(full_file_name, destination_file_name, preserve: true, verbose: true)
+            end
+          end
+      end
+
+      private
+
+      def current_migration_files(to)
+        Dir
+          .entries(to)
+          .reject { |f| f.start_with?('.') }
+          .map do |f|
+            _timestamp, *file_parts = f.split('_')
+            file_parts.join('_')
+          end
+      end
+
+      def copy_directory(directory_name, from, to)
+        source = File.join(from, directory_name)
+        dest = File.join(to, directory_name)
+        FileUtils.mkdir_p(dest)
+
+        existing = Dir.entries(dest)
+
+        Dir
+          .entries(source)
+          .reject { |file| file.start_with?('.') }
+          .sort
+          .each do |file|
+            full_file_name = File.join(source, file)
+            if File.directory?(full_file_name)
+              copy_directory(file, source, dest)
+            else
+              next if existing.include?(file)
+
+              FileUtils.cp(File.join(source, file), File.join(dest, file), preserve: true, verbose: true)
+            end
+          end
+      end
+    end
+  end
+end

data/lib/sequent/rake/migration_tasks.rb

@@ -7,14 +7,35 @@ require 'rake/tasklib'
 require 'sequent/support'
 require 'sequent/migrations/view_schema'
 require 'sequent/migrations/sequent_schema'
+require_relative 'migration_files'
 
 module Sequent
   module Rake
     class MigrationTasks < ::Rake::TaskLib
       include ::Rake::DSL
+      include ActiveRecord::Tasks
+
+      def db_config
+        DatabaseTasks.db_dir = Sequent.configuration.database_schema_directory unless defined?(Rails)
+        Sequent::Support::Database.read_database_config(@env)
+      end
+
+      def connection
+        ensure_sequent_env_set!
+        Sequent::Support::Database.establish_connection(db_config)
+      end
 
       def register_tasks!
         namespace :sequent do
+          namespace :install do
+            desc <<~EOS
+              Copy (new) Sequent database migration files to your projects migrations directory
+            EOS
+            task :migrations do
+              MigrationFiles.new.copy('./db/migrate')
+            end
+          end
+
           desc <<~EOS
             Set the SEQUENT_ENV to RAILS_ENV or RACK_ENV if not already set
           EOS
@@ -41,11 +62,36 @@ module Sequent
             desc 'Creates the database and initializes the event_store schema for the current env'
             task create: ['sequent:init'] do
               ensure_sequent_env_set!
-
-              db_config = Sequent::Support::Database.read_config(@env)
               Sequent::Support::Database.create!(db_config)
+            end
+
+            desc 'Apply Sequent event store migrations (NOT view schema projection migrations)'
+            task migrate: [:create] do
+              ensure_sequent_env_set!
+              Sequent::Support::Database.establish_connection(db_config)
+              ActiveRecord::MigrationContext.new('db/migrate').migrate
+              ::Rake::Task['sequent:db:schema:dump'].invoke
+            end
+
+            namespace :schema do
+              desc "Creates the database schema file 'db/structure.sql'"
+              task :dump do
+                connection
+                old_dump_schemas = ActiveRecord.dump_schemas
+                begin
+                  ActiveRecord.dump_schemas = nil
+                  DatabaseTasks.structure_dump_flags = "--exclude-schema=#{Sequent.configuration.view_schema_name}"
+                  DatabaseTasks.dump_schema(db_config, :sql)
+                ensure
+                  ActiveRecord.dump_schemas = old_dump_schemas
+                end
+              end
 
-              Sequent::Migrations::SequentSchema.create_sequent_schema_if_not_exists(env: @env, fail_if_exists: true)
+              desc "Loads the database schema file 'db/structure.sql'"
+              task :load do
+                connection
+                DatabaseTasks.load_schema(db_config, :sql)
+              end
             end
 
             desc 'Drops the database for the current env'
@@ -69,12 +115,6 @@ module Sequent
               Sequent::Migrations::ViewSchema.create_view_schema_if_not_exists(env: @env)
             end
 
-            desc 'Creates the event_store schema for the current env'
-            task create_event_store: ['sequent:init'] do
-              ensure_sequent_env_set!
-              Sequent::Migrations::SequentSchema.create_sequent_schema_if_not_exists(env: @env, fail_if_exists: true)
-            end
-
             desc 'Utility tasks that can be used to guard against unsafe usage of rails db:migrate directly'
             task :dont_use_db_migrate_directly do
               fail <<~EOS unless ENV['SEQUENT_MIGRATION_SCHEMAS'].present?
@@ -207,6 +247,28 @@ module Sequent
 
               view_schema.migrate_dryrun(regex: args[:regex])
             end
+
+            desc <<~EOS
+              Loads all aggregates of the specified type (if any) and updates the aggregate's unique keys in the database.
+
+              Use this after adding new unique key constraints to an aggregate to ensure every aggregate's unique keys
+              are present in the database.
+            EOS
+            task :unique_keys, %i[aggregate_type group_size] => ['sequent:init', :init] do |_task, args|
+              count = 0
+              Sequent.configuration.event_store.event_streams_enumerator(
+                aggregate_type: args[:aggregate_type],
+                group_size: args[:group_size] || 100,
+              ).each do |aggregate_ids|
+                Sequent.configuration.transaction_provider.transactional do
+                  aggregates = Sequent.configuration.aggregate_repository.load_aggregates(aggregate_ids)
+                  Sequent.configuration.event_store.update_unique_keys(aggregates.map(&:event_stream))
+                  count += aggregates.size
+                  printf("\rUpdated unique keys for #{count} aggregates.")
+                end
+              end
+              puts("\nDone.")
+            end
           end
 
           namespace :snapshots do

data/lib/sequent/support/database.rb

@@ -11,6 +11,8 @@ module Sequent
     # take in a database configuration). Instance methods assume that a database
     # connection yet is established.
     class Database
+      include ActiveRecord::Tasks
+
       attr_reader :db_config
 
       def self.connect!(env)
@@ -18,43 +20,34 @@ module Sequent
         establish_connection(db_config)
       end
 
-      def self.read_config(env)
+      def self.read_database_config(env)
         fail ArgumentError, 'env is mandatory' unless env
 
+        DatabaseTasks.db_dir = Sequent.configuration.database_schema_directory unless defined?(Rails)
         database_yml = File.join(Sequent.configuration.database_config_directory, 'database.yml')
         config = YAML.safe_load(ERB.new(File.read(database_yml)).result, aliases: true)[env]
-        ActiveRecord::Base.configurations.resolve(config).configuration_hash.with_indifferent_access
+        ActiveRecord::Base.configurations.resolve(config)
       end
 
-      def self.create!(db_config)
-        establish_connection(db_config, {database: 'postgres'})
-        ActiveRecord::Base.connection.create_database(get_db_config_attribute(db_config, :database))
+      def self.read_config(env)
+        read_database_config(env).configuration_hash.with_indifferent_access
       end
 
-      def self.drop!(db_config)
-        establish_connection(db_config, {database: 'postgres'})
-        ActiveRecord::Base.connection.drop_database(get_db_config_attribute(db_config, :database))
+      def self.create!(db_config)
+        DatabaseTasks.create(db_config)
       end
 
-      def self.get_db_config_attribute(db_config, attribute)
-        if Sequent.configuration.can_use_multiple_databases?
-          db_config[Sequent.configuration.primary_database_key][attribute]
-        else
-          db_config[attribute]
-        end
+      def self.drop!(db_config)
+        DatabaseTasks.drop(db_config)
       end
 
-      def self.establish_connection(db_config, db_config_overrides = {})
+      def self.establish_connection(db_config)
         if Sequent.configuration.can_use_multiple_databases?
-          db_config = db_config.deep_merge(
-            Sequent.configuration.primary_database_key => db_config_overrides,
-          ).stringify_keys
           ActiveRecord::Base.configurations = db_config.stringify_keys
           ActiveRecord::Base.connects_to database: {
             Sequent.configuration.primary_database_role => Sequent.configuration.primary_database_key,
           }
         else
-          db_config = db_config.merge(db_config_overrides)
           ActiveRecord::Base.establish_connection(db_config)
         end
       end
@@ -78,18 +71,6 @@ module Sequent
         execute_sql "DROP SCHEMA if exists #{schema_name} cascade"
       end
 
-      def self.with_schema_search_path(search_path, db_config, env = ENV['SEQUENT_ENV'])
-        fail ArgumentError, 'env is required' unless env
-
-        disconnect!
-
-        establish_connection(db_config, {schema_search_path: search_path})
-        yield
-      ensure
-        disconnect!
-        establish_connection(db_config)
-      end
-
       def self.with_search_path(search_path)
         old_search_path = ActiveRecord::Base.connection.select_value("SELECT current_setting('search_path')")
         begin

data/lib/sequent/test/command_handler_helpers.rb

@@ -89,7 +89,11 @@ module Sequent
               stream.unique_keys.to_h { |scope, key| [[scope, key], stream.aggregate_id] }
             end,
           ) do |_key, id_1, id_2|
-            fail Sequent::Core::AggregateKeyNotUniqueError if id_1 != id_2
+            if id_1 != id_2
+              stream, = streams_with_events.find { |s| s[0].aggregate_id == id_2 }
+              fail Sequent::Core::AggregateKeyNotUniqueError,
+                   "duplicate unique key value for aggregate #{stream.aggregate_type} #{stream.aggregate_id}"
+            end
           end
 
           streams_with_events.each do |event_stream, events|
@@ -122,6 +126,15 @@ module Sequent
           [deserialize_events(@stored_events[mark..]), position_mark]
         end
 
+        def event_streams_enumerator(aggregate_type: nil, group_size: 100)
+          @event_streams
+            .values
+            .select { |es| aggregate_type.nil? || es.aggregate_type == aggregate_type }
+            .sort_by { |es| [es.events_partition_key, es.aggregate_id] }
+            .map(&:aggregate_id)
+            .each_slice(group_size)
+        end
+
         private
 
         def serialize_events(events)

data/lib/sequent/util/dry_run.rb

@@ -36,6 +36,10 @@ module Sequent
                  :load_events,
                  :stream_exists?,
                  :events_exists?,
+                 :event_streams_enumerator,
+                 :find_event_stream,
+                 :position_mark,
+                 :load_events_since_marked_position,
                  to: :event_store
 
         def initialize(result, event_store)
@@ -50,6 +54,10 @@ module Sequent
           new_events = streams_with_events.flat_map { |_, events| events }
           @result.published_command_with_events(command, new_events)
         end
+
+        def update_unique_keys(event_streams)
+          # no-op
+        end
       end
 
       ##

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sequent
-  VERSION = '8.1.1'
+  VERSION = '8.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequent
 version: !ruby/object:Gem::Version
-  version: 8.1.1
+  version: 8.2.0
 platform: ruby
 authors:
 - Lars Vonk
@@ -369,13 +369,39 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/sequent
-- db/migrate/20250108162754_aggregate_unique_keys.rb
+- db/migrate/20250101000000_sequent_initial_schema.rb
+- db/migrate/20250101000001_sequent_stored_procedures.rb
+- db/migrate/20250312105100_sequent_store_events_v02.rb
+- db/migrate/sequent/aggregate_event_type_v01.sql
+- db/migrate/sequent/aggregates_that_need_snapshots_v01.sql
+- db/migrate/sequent/command_records_v01.sql
+- db/migrate/sequent/delete_all_snapshots_v01.sql
+- db/migrate/sequent/delete_snapshots_before_v01.sql
+- db/migrate/sequent/enrich_command_json_v01.sql
+- db/migrate/sequent/enrich_event_json_v01.sql
+- db/migrate/sequent/event_records_v01.sql
+- db/migrate/sequent/load_event_v01.sql
+- db/migrate/sequent/load_events_v01.sql
+- db/migrate/sequent/load_latest_snapshots_v01.sql
+- db/migrate/sequent/permanently_delete_commands_without_events_v01.sql
+- db/migrate/sequent/permanently_delete_event_streams_v01.sql
+- db/migrate/sequent/save_events_trigger_v01.sql
+- db/migrate/sequent/select_aggregates_for_snapshotting_v01.sql
+- db/migrate/sequent/store_aggregates_v01.sql
+- db/migrate/sequent/store_command_v01.sql
+- db/migrate/sequent/store_events_v01.sql
+- db/migrate/sequent/store_events_v02.sql
+- db/migrate/sequent/store_snapshots_v01.sql
+- db/migrate/sequent/stream_records_v01.sql
+- db/migrate/sequent/update_types_v01.sql
+- db/migrate/sequent/update_unique_keys_v01.sql
 - db/sequent_8_migration.sql
 - db/sequent_pgsql.sql
 - db/sequent_schema.rb
 - db/sequent_schema_indexes.sql
 - db/sequent_schema_partitions.sql
 - db/sequent_schema_tables.sql
+- db/structure.sql
 - lib/notices.rb
 - lib/sequent.rb
 - lib/sequent/application_record.rb
@@ -510,6 +536,7 @@ files:
 - lib/sequent/migrations/sql.rb
 - lib/sequent/migrations/versions.rb
 - lib/sequent/migrations/view_schema.rb
+- lib/sequent/rake/migration_files.rb
 - lib/sequent/rake/migration_tasks.rb
 - lib/sequent/sequent.rb
 - lib/sequent/support.rb

data/db/migrate/20250108162754_aggregate_unique_keys.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class AggregateUniqueKeys < ActiveRecord::Migration[7.2]
-  def up
-    Sequent::Support::Database.with_search_path(Sequent.configuration.event_store_schema_name) do
-      say 'Creating aggregate_unique_keys table', true
-      suppress_messages do
-        execute <<~SQL
-          CREATE TABLE IF NOT EXISTS aggregate_unique_keys (
-              aggregate_id uuid NOT NULL,
-              scope text NOT NULL,
-              key jsonb NOT NULL,
-              PRIMARY KEY (aggregate_id, scope),
-              UNIQUE (scope, key),
-              FOREIGN KEY (aggregate_id) REFERENCES aggregates (aggregate_id) ON UPDATE CASCADE ON DELETE CASCADE
-          )
-        SQL
-      end
-
-      say 'Creating event store stored procedures and views', true
-      suppress_messages do
-        sequent_pgsql_filename = File.join(Sequent.configuration.database_schema_directory, 'sequent_pgsql.sql')
-        execute File.read(sequent_pgsql_filename)
-      end
-    end
-  end
-
-  def down
-    fail ActiveRecord::IrreversibleMigration
-  end
-end