velocious 1.0.430 → 1.0.431

package/build/src/database/migrator.js

@@ -1,485 +1,557 @@
 // @ts-check
-import { digg } from "diggerize";
-import * as inflection from "inflection";
-import Logger from "../logger.js";
-import { NotImplementedError } from "./migration/index.js";
-import restArgsError from "../utils/rest-args-error.js";
-import TableData from "./table-data/index.js";
+
+import {digg} from "diggerize"
+import * as inflection from "inflection"
+import Logger from "../logger.js"
+import {NotImplementedError} from "./migration/index.js"
+import restArgsError from "../utils/rest-args-error.js"
+import TableData from "./table-data/index.js"
+
 export default class VelociousDatabaseMigrator {
-    /**
-     * Migrations versions.
-      @type {Record<string, Record<string, boolean>>} */
-    migrationsVersions = {};
-    /**
-     * Runs constructor.
-     * @param {object} args - Options object.
-     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
-     * @param {string[]} [args.databaseIdentifiers] - Optional database identifiers to migrate.
-     */
-    constructor({ configuration, databaseIdentifiers, ...restArgs }) {
-        restArgsError(restArgs);
-        if (!configuration)
-            throw new Error("configuration argument is required");
-        this.configuration = configuration;
-        this.databaseIdentifiers = databaseIdentifiers;
-        this.logger = new Logger(this);
+  /**
+   * Migrations versions.
+    @type {Record<string, Record<string, boolean>>} */
+  migrationsVersions = {}
+
+  /**
+   * Runs constructor.
+   * @param {object} args - Options object.
+   * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+   * @param {string[]} [args.databaseIdentifiers] - Optional database identifiers to migrate.
+   */
+  constructor({configuration, databaseIdentifiers, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!configuration) throw new Error("configuration argument is required")
+
+    this.configuration = configuration
+    this.databaseIdentifiers = databaseIdentifiers
+    this.logger = new Logger(this)
+  }
+
+  /**
+   * Runs handles database identifier.
+   * @param {string} dbIdentifier - Database identifier.
+   * @returns {boolean} - Whether this migrator should touch the database identifier.
+   */
+  handlesDatabaseIdentifier(dbIdentifier) {
+    if (!this.databaseIdentifiers) return true
+
+    return this.databaseIdentifiers.includes(dbIdentifier)
+  }
+
+
+  /**
+   * Runs prepare.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async prepare() {
+    await this.createMigrationsTable()
+    await this.loadMigrationsVersions()
+  }
+
+  /**
+   * Runs create migrations table.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async createMigrationsTable() {
+    const dbs = await this.configuration.getCurrentConnections()
+
+    for (const dbIdentifier in dbs) {
+      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue
+
+      await this.createMigrationsTableForDatabase({dbIdentifier, db: dbs[dbIdentifier]})
     }
-    /**
-     * Runs handles database identifier.
-     * @param {string} dbIdentifier - Database identifier.
-     * @returns {boolean} - Whether this migrator should touch the database identifier.
-     */
-    handlesDatabaseIdentifier(dbIdentifier) {
-        if (!this.databaseIdentifiers)
-            return true;
-        return this.databaseIdentifiers.includes(dbIdentifier);
+  }
+
+  /**
+   * Runs create migrations table for database.
+   * @param {object} args - Options object.
+   * @param {string} args.dbIdentifier - Database identifier.
+   * @param {import("./drivers/base.js").default} args.db - Database connection.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async createMigrationsTableForDatabase({dbIdentifier, db}) {
+    const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)
+
+    if (!databaseConfiguration.migrations) {
+      this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`)
+      return
     }
-    /**
-     * Runs prepare.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async prepare() {
-        await this.createMigrationsTable();
-        await this.loadMigrationsVersions();
+
+    const exists = await this.migrationsTableExist(db)
+
+    if (exists) {
+      this.logger.debug(`${dbIdentifier} migrations table already exists - skipping`)
+    } else {
+      this.logger.debug("New TableData for schema_migrations")
+      const schemaMigrationsTable = new TableData("schema_migrations", {ifNotExists: true})
+
+      schemaMigrationsTable.string("version", {null: false, primaryKey: true})
+
+      const createSchemaMigrationsTableSqls = await db.createTableSql(schemaMigrationsTable)
+
+      for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
+        this.logger.debug(`Creating migrations table with SQL`, createSchemaMigrationsTableSql)
+        await db.query(createSchemaMigrationsTableSql)
+      }
     }
-    /**
-     * Runs create migrations table.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async createMigrationsTable() {
-        const dbs = await this.configuration.getCurrentConnections();
-        for (const dbIdentifier in dbs) {
-            if (!this.handlesDatabaseIdentifier(dbIdentifier))
-                continue;
-            await this.createMigrationsTableForDatabase({ dbIdentifier, db: dbs[dbIdentifier] });
-        }
+  }
+
+  /**
+   * Runs has run migration version.
+   * @param {string} dbIdentifier - Db identifier.
+   * @param {number} version - Version.
+   * @returns {boolean} - Whether it has run migration version.
+   */
+  hasRunMigrationVersion(dbIdentifier, version) {
+    if (!this.migrationsVersions) throw new Error("Migrations versions hasn't been loaded yet")
+    if (!this.migrationsVersions[dbIdentifier]) throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`)
+
+    if (version in this.migrationsVersions[dbIdentifier]) {
+      return true
     }
-    /**
-     * Runs create migrations table for database.
-     * @param {object} args - Options object.
-     * @param {string} args.dbIdentifier - Database identifier.
-     * @param {import("./drivers/base.js").default} args.db - Database connection.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async createMigrationsTableForDatabase({ dbIdentifier, db }) {
-        const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
-        if (!databaseConfiguration.migrations) {
-            this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`);
-            return;
-        }
-        const exists = await this.migrationsTableExist(db);
-        if (exists) {
-            this.logger.debug(`${dbIdentifier} migrations table already exists - skipping`);
-        }
-        else {
-            this.logger.debug("New TableData for schema_migrations");
-            const schemaMigrationsTable = new TableData("schema_migrations", { ifNotExists: true });
-            schemaMigrationsTable.string("version", { null: false, primaryKey: true });
-            const createSchemaMigrationsTableSqls = await db.createTableSql(schemaMigrationsTable);
-            for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {
-                this.logger.debug(`Creating migrations table with SQL`, createSchemaMigrationsTableSql);
-                await db.query(createSchemaMigrationsTableSql);
+
+    return false
+  }
+
+  /**
+   * Runs migrate files.
+   * @param {import("./migrator/types.js").MigrationObjectType[]} files - Files.
+   * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback - Import callback.
+   * @returns {Promise<number>} - Number of migrations actually applied (not skipped as already-run).
+   */
+  async migrateFiles(files, importCallback) {
+    let appliedCount = 0
+
+    await this.configuration.ensureConnections({name: "Database migrator: migrate files"}, async () => {
+      for (const migration of files) {
+        const applied = await this.runMigrationFile({
+          migration,
+          requireMigration: async () => {
+            if (!migration.fullPath) throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`)
+
+            const migrationImport = await importCallback(migration.fullPath)
+
+            if (!migrationImport) {
+              throw new Error(`Migration file must export migration class: ${migration.fullPath}`)
             }
-        }
-    }
+
+            return migrationImport
+          }
+        })
+
+        if (applied) appliedCount++
+      }
+
+      await this._afterMigrations()
+    })
+
+    return appliedCount
+  }
+
+  /**
+   * Runs migrate files from require context.
+   * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext - Require context.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async migrateFilesFromRequireContext(requireContext) {
     /**
-     * Runs has run migration version.
-     * @param {string} dbIdentifier - Db identifier.
-     * @param {number} version - Version.
-     * @returns {boolean} - Whether it has run migration version.
-     */
-    hasRunMigrationVersion(dbIdentifier, version) {
-        if (!this.migrationsVersions)
-            throw new Error("Migrations versions hasn't been loaded yet");
-        if (!this.migrationsVersions[dbIdentifier])
-            throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`);
-        if (version in this.migrationsVersions[dbIdentifier]) {
-            return true;
-        }
-        return false;
+     * Files.
+      @type {import("./migrator/types.js").MigrationObjectType[]} */
+    let files = []
+
+    for (const file of requireContext.keys()) {
+      // "13,14" because somes "require-context"-npm-module deletes first character!?
+      const match = file.match(/(\d{13,14})-(.+)\.js$/)
+
+      if (!match) continue
+
+      // Fix require-context-npm-module deletes first character
+      let fileName = file
+      let dateNumber = match[1]
+
+      if (dateNumber.length == 13) {
+        dateNumber = `2${dateNumber}`
+        fileName = `2${fileName}`
+      }
+
+      // Parse regex
+      const date = parseInt(dateNumber)
+      const migrationName = match[2]
+      const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"))
+
+      files.push({
+        file: fileName,
+        date,
+        migrationClassName
+      })
     }
-    /**
-     * Runs migrate files.
-     * @param {import("./migrator/types.js").MigrationObjectType[]} files - Files.
-     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback - Import callback.
-     * @returns {Promise<number>} - Number of migrations actually applied (not skipped as already-run).
-     */
-    async migrateFiles(files, importCallback) {
-        let appliedCount = 0;
-        await this.configuration.ensureConnections({ name: "Database migrator: migrate files" }, async () => {
-            for (const migration of files) {
-                const applied = await this.runMigrationFile({
-                    migration,
-                    requireMigration: async () => {
-                        if (!migration.fullPath)
-                            throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`);
-                        const migrationImport = await importCallback(migration.fullPath);
-                        if (!migrationImport) {
-                            throw new Error(`Migration file must export migration class: ${migration.fullPath}`);
-                        }
-                        return migrationImport;
-                    }
-                });
-                if (applied)
-                    appliedCount++;
-            }
-            await this._afterMigrations();
-        });
-        return appliedCount;
+
+    files = files.sort((migration1, migration2) => migration1.date - migration2.date)
+
+    await this.configuration.ensureConnections({name: "Database migrator: migrate require-context files"}, async () => {
+      for (const migration of files) {
+        await this.runMigrationFile({
+          migration,
+          requireMigration: async () => requireContext(migration.file).default
+        })
+      }
+
+      await this._afterMigrations()
+    })
+  }
+
+  /**
+   * Runs after migrations.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _afterMigrations() {
+    const environmentHandler = this.configuration.getEnvironmentHandler()
+    const dbs = await this.configuration.getCurrentConnections()
+    const filteredDbs = Object.fromEntries(
+      Object.entries(dbs).filter(([dbIdentifier]) => this.handlesDatabaseIdentifier(dbIdentifier))
+    )
+
+    if (!environmentHandler || Object.keys(filteredDbs).length == 0) return
+
+    await environmentHandler.afterMigrations({dbs: filteredDbs})
+  }
+
+  /**
+   * Runs load migrations versions.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async loadMigrationsVersions() {
+    this.migrationsVersions = {}
+
+    const dbs = await this.configuration.getCurrentConnections()
+
+    for (const dbIdentifier in dbs) {
+      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue
+
+      await this.loadMigrationsVersionsForDatabase({dbIdentifier, db: dbs[dbIdentifier]})
+    }
+  }
+
+  /**
+   * Runs load migrations versions for database.
+   * @param {object} args - Options object.
+   * @param {string} args.dbIdentifier - Database identifier.
+   * @param {import("./drivers/base.js").default} args.db - Database connection.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async loadMigrationsVersionsForDatabase({dbIdentifier, db}) {
+    const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)
+
+    if (!databaseConfiguration.migrations) {
+      this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping loading migrations versions for it`)
+      return
+    }
+
+    if (!await this.migrationsTableExist(db)) {
+      this.logger.info(`Migration table does not exist for ${dbIdentifier} - skipping loading migrations versions for it`)
+      delete this.migrationsVersions[dbIdentifier]
+      return
+    }
+
+    const rows = await db.select("schema_migrations")
+
+    this.migrationsVersions[dbIdentifier] = {}
+
+    for (const row of rows) {
+      const version = digg(row, "version")
+
+      this.migrationsVersions[dbIdentifier][version] = true
     }
+  }
+
+  /**
+   * Runs migrations table exist.
+   * @param {import("./drivers/base.js").default} db - Database connection.
+   * @returns {Promise<boolean>} - Resolves with Whether migrations table exist.
+   */
+  async migrationsTableExist(db) {
+    const schemaTable = await db.getTableByName("schema_migrations", {throwError: false})
+
+    if (!schemaTable) return false
+
+    return true
+  }
+
+  /**
+   * Runs execute require context.
+   * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext - Require context.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async executeRequireContext(requireContext) {
+    const migrationFiles = requireContext.keys()
+
     /**
-     * Runs migrate files from require context.
-     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext - Require context.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async migrateFilesFromRequireContext(requireContext) {
-        /**
-         * Files.
-          @type {import("./migrator/types.js").MigrationObjectType[]} */
-        let files = [];
-        for (const file of requireContext.keys()) {
-            // "13,14" because somes "require-context"-npm-module deletes first character!?
-            const match = file.match(/(\d{13,14})-(.+)\.js$/);
-            if (!match)
-                continue;
-            // Fix require-context-npm-module deletes first character
-            let fileName = file;
-            let dateNumber = match[1];
-            if (dateNumber.length == 13) {
-                dateNumber = `2${dateNumber}`;
-                fileName = `2${fileName}`;
+     * Files.
+      @type {import("./migrator/types.js").MigrationObjectType[]} */
+    let files = []
+
+    for (const file of migrationFiles) {
+      const match = file.match(/^(\d{14})-(.+)\.js$/)
+
+      if (!match) continue
+
+      const date = parseInt(match[1])
+      const migrationName = match[2]
+      const migrationClassName = inflection.camelize(migrationName)
+
+      const migrationObject = /**
+                               * Narrows the runtime value to the documented type.
+                                @type {import("./migrator/types.js").MigrationObjectType} */ ({
+        file,
+        date,
+        migrationClassName
+      })
+
+      files.push(migrationObject)
+    }
+
+    files = files.sort((migration1, migration2) => migration1.date - migration2.date)
+
+    for (const migration of files) {
+      await this.runMigrationFile({
+        migration,
+        requireMigration: async () => requireContext(migration.file).default
+      })
+    }
+  }
+
+  /**
+   * Runs reset.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async reset() {
+    const dbs = await this.configuration.getCurrentConnections()
+
+    for (const dbIdentifier in dbs) {
+      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue
+
+      const db = dbs[dbIdentifier]
+
+      await db.withDisabledForeignKeys(async () => {
+        while (true) {
+          const errors = []
+          let anyTableDropped = false
+
+          try {
+            for (const table of await db.getTables()) {
+              this.logger.info(`Dropping table ${table.getName()}`)
+
+              try {
+                await db.dropTable(table.getName(), {cascade: true})
+                anyTableDropped = true
+              } catch (error) {
+                errors.push(error)
+              }
             }
-            // Parse regex
-            const date = parseInt(dateNumber);
-            const migrationName = match[2];
-            const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"));
-            files.push({
-                file: fileName,
-                date,
-                migrationClassName
-            });
-        }
-        files = files.sort((migration1, migration2) => migration1.date - migration2.date);
-        await this.configuration.ensureConnections({ name: "Database migrator: migrate require-context files" }, async () => {
-            for (const migration of files) {
-                await this.runMigrationFile({
-                    migration,
-                    requireMigration: async () => requireContext(migration.file).default
-                });
+
+            break
+          } catch (error) { // eslint-disable-line no-unused-vars
+            if (errors.length > 0 && anyTableDropped) {
+              // Retry
+            } else {
+              throw errors[0]
             }
-            await this._afterMigrations();
-        });
+          }
+        }
+      })
     }
-    /**
-     * Runs after migrations.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async _afterMigrations() {
-        const environmentHandler = this.configuration.getEnvironmentHandler();
-        const dbs = await this.configuration.getCurrentConnections();
-        const filteredDbs = Object.fromEntries(Object.entries(dbs).filter(([dbIdentifier]) => this.handlesDatabaseIdentifier(dbIdentifier)));
-        if (!environmentHandler || Object.keys(filteredDbs).length == 0)
-            return;
-        await environmentHandler.afterMigrations({ dbs: filteredDbs });
+  }
+
+  /**
+   * Runs rollback.
+   * @param {import("./migrator/types.js").MigrationObjectType[]} files - Files.
+   * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback Function to import a file
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async rollback(files, importCallback) {
+    const latestMigrationVersion = await this._latestMigrationVersion()
+
+    if (!latestMigrationVersion) {
+      throw new Error("No migrations have been run yet")
     }
-    /**
-     * Runs load migrations versions.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async loadMigrationsVersions() {
-        this.migrationsVersions = {};
-        const dbs = await this.configuration.getCurrentConnections();
-        for (const dbIdentifier in dbs) {
-            if (!this.handlesDatabaseIdentifier(dbIdentifier))
-                continue;
-            await this.loadMigrationsVersionsForDatabase({ dbIdentifier, db: dbs[dbIdentifier] });
-        }
+
+    const latestMigrationVersionNumber = parseInt(latestMigrationVersion)
+    const migration = files.find((file) => file.date == latestMigrationVersionNumber)
+
+    if (!migration) {
+      throw new Error(`Migration file for version ${latestMigrationVersionNumber} not found`)
     }
+
+    await this.runMigrationFile({
+      migration,
+      requireMigration: async () => {
+        if (!migration.fullPath) throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`)
+
+        return await importCallback(migration.fullPath)
+      },
+      direction: "down"
+    })
+  }
+
+  /**
+   * Runs latest migration version.
+   * @returns {Promise<string | undefined>} The latest migration version
+   */
+  async _latestMigrationVersion() {
+    if (!this.migrationsVersions) await this.loadMigrationsVersions()
+
     /**
-     * Runs load migrations versions for database.
-     * @param {object} args - Options object.
-     * @param {string} args.dbIdentifier - Database identifier.
-     * @param {import("./drivers/base.js").default} args.db - Database connection.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async loadMigrationsVersionsForDatabase({ dbIdentifier, db }) {
-        const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
-        if (!databaseConfiguration.migrations) {
-            this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping loading migrations versions for it`);
-            return;
-        }
-        if (!await this.migrationsTableExist(db)) {
-            this.logger.info(`Migration table does not exist for ${dbIdentifier} - skipping loading migrations versions for it`);
-            delete this.migrationsVersions[dbIdentifier];
-            return;
-        }
-        const rows = await db.select("schema_migrations");
-        this.migrationsVersions[dbIdentifier] = {};
-        for (const row of rows) {
-            const version = digg(row, "version");
-            this.migrationsVersions[dbIdentifier][version] = true;
+     * Defines highestVersion.
+      @type {string | undefined} */
+    let highestVersion
+
+    for (const dbIdentifier in this.migrationsVersions) {
+      for (const migrationVersion in this.migrationsVersions[dbIdentifier]) {
+        if (!highestVersion || migrationVersion > highestVersion) {
+          highestVersion = migrationVersion
         }
+      }
     }
+
+    return highestVersion
+  }
+
+  /**
+   * Runs run migration file.
+   * @param {object} args - Options object.
+   * @param {import("./migrator/types.js").MigrationObjectType} args.migration - Migration.
+   * @param {import("./migrator/types.js").RequireMigrationType} args.requireMigration - Require migration.
+   * @param {string} [args.direction] - Direction.
+   * @returns {Promise<boolean>} - Whether the migration ran on at least one database (false if skipped as already-run everywhere).
+   */
+  async runMigrationFile({migration, requireMigration, direction = "up"}) {
+    if (!this.configuration) throw new Error("No configuration set")
+    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()
+    if (!this.migrationsVersions) await this.loadMigrationsVersions()
+
+    let applied = false
+    const dbs = await this.configuration.getCurrentConnections()
+
     /**
-     * Runs migrations table exist.
-     * @param {import("./drivers/base.js").default} db - Database connection.
-     * @returns {Promise<boolean>} - Resolves with Whether migrations table exist.
-     */
-    async migrationsTableExist(db) {
-        const schemaTable = await db.getTableByName("schema_migrations", { throwError: false });
-        if (!schemaTable)
-            return false;
-        return true;
+     * Db identifiers needing migration versions.
+      @type {string[]} */
+    const dbIdentifiersNeedingMigrationVersions = []
+
+    // migrateFiles() wraps execution in ensureConnections(), so the current
+    // async context can expose DB identifiers not loaded by prepare().
+    for (const dbIdentifier in dbs) {
+      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue
+
+      const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)
+
+      if (!databaseConfiguration.migrations) continue
+      if (this.migrationsVersions[dbIdentifier]) continue
+
+      dbIdentifiersNeedingMigrationVersions.push(dbIdentifier)
     }
-    /**
-     * Runs execute require context.
-     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext - Require context.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async executeRequireContext(requireContext) {
-        const migrationFiles = requireContext.keys();
-        /**
-         * Files.
-          @type {import("./migrator/types.js").MigrationObjectType[]} */
-        let files = [];
-        for (const file of migrationFiles) {
-            const match = file.match(/^(\d{14})-(.+)\.js$/);
-            if (!match)
-                continue;
-            const date = parseInt(match[1]);
-            const migrationName = match[2];
-            const migrationClassName = inflection.camelize(migrationName);
-            const migrationObject = /**
-                                     * Narrows the runtime value to the documented type.
-                                      @type {import("./migrator/types.js").MigrationObjectType} */ ({
-                file,
-                date,
-                migrationClassName
-            });
-            files.push(migrationObject);
-        }
-        files = files.sort((migration1, migration2) => migration1.date - migration2.date);
-        for (const migration of files) {
-            await this.runMigrationFile({
-                migration,
-                requireMigration: async () => requireContext(migration.file).default
-            });
-        }
+
+    for (const dbIdentifier of dbIdentifiersNeedingMigrationVersions) {
+      const db = dbs[dbIdentifier]
+
+      await this.createMigrationsTableForDatabase({dbIdentifier, db})
+      await this.loadMigrationsVersionsForDatabase({dbIdentifier, db})
     }
-    /**
-     * Runs reset.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async reset() {
-        const dbs = await this.configuration.getCurrentConnections();
-        for (const dbIdentifier in dbs) {
-            if (!this.handlesDatabaseIdentifier(dbIdentifier))
-                continue;
-            const db = dbs[dbIdentifier];
-            await db.withDisabledForeignKeys(async () => {
-                while (true) {
-                    const errors = [];
-                    let anyTableDropped = false;
-                    try {
-                        for (const table of await db.getTables()) {
-                            this.logger.info(`Dropping table ${table.getName()}`);
-                            try {
-                                await db.dropTable(table.getName(), { cascade: true });
-                                anyTableDropped = true;
-                            }
-                            catch (error) {
-                                errors.push(error);
-                            }
-                        }
-                        break;
-                    }
-                    catch (error) { // eslint-disable-line no-unused-vars
-                        if (errors.length > 0 && anyTableDropped) {
-                            // Retry
-                        }
-                        else {
-                            throw errors[0];
-                        }
-                    }
-                }
-            });
-        }
+
+    const migrationClass = await requireMigration()
+
+    if (!migrationClass || typeof migrationClass !== "function") {
+      throw new Error(`Migration ${migration.file} must export a default migration class. Type: ${typeof migrationClass}`)
     }
-    /**
-     * Runs rollback.
-     * @param {import("./migrator/types.js").MigrationObjectType[]} files - Files.
-     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback Function to import a file
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async rollback(files, importCallback) {
-        const latestMigrationVersion = await this._latestMigrationVersion();
-        if (!latestMigrationVersion) {
-            throw new Error("No migrations have been run yet");
+
+    const migrationDatabaseIdentifiers = migrationClass.getDatabaseIdentifiers() || ["default"]
+
+    for (const dbIdentifier in dbs) {
+      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue
+
+      const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)
+
+      if (!databaseConfiguration.migrations) {
+        this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping migration ${digg(migration, "date")}`)
+        continue
+      }
+
+      if (!migrationDatabaseIdentifiers.includes(dbIdentifier)) {
+        this.logger.debug(`${dbIdentifier} shouldn't run migration ${migration.file}`, {migrationDatabaseIdentifiers})
+        continue
+      }
+
+      if (direction == "up") {
+        if (this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
+          this.logger.debug(`${dbIdentifier} has already run migration ${migration.file}`)
+          continue
         }
-        const latestMigrationVersionNumber = parseInt(latestMigrationVersion);
-        const migration = files.find((file) => file.date == latestMigrationVersionNumber);
-        if (!migration) {
-            throw new Error(`Migration file for version ${latestMigrationVersionNumber} not found`);
+      } else if (direction == "down") {
+        if (!this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
+          this.logger.debug(`${dbIdentifier} hasn't run migration ${migration.file}`)
+          continue
         }
-        await this.runMigrationFile({
-            migration,
-            requireMigration: async () => {
-                if (!migration.fullPath)
-                    throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(", ")}`);
-                return await importCallback(migration.fullPath);
-            },
-            direction: "down"
-        });
-    }
-    /**
-     * Runs latest migration version.
-     * @returns {Promise<string | undefined>} The latest migration version
-     */
-    async _latestMigrationVersion() {
-        if (!this.migrationsVersions)
-            await this.loadMigrationsVersions();
-        /**
-         * Defines highestVersion.
-          @type {string | undefined} */
-        let highestVersion;
-        for (const dbIdentifier in this.migrationsVersions) {
-            for (const migrationVersion in this.migrationsVersions[dbIdentifier]) {
-                if (!highestVersion || migrationVersion > highestVersion) {
-                    highestVersion = migrationVersion;
-                }
+      } else {
+        throw new Error(`Unknown direction: ${direction}`)
+      }
+
+      this.logger.debug(`Running migration on ${dbIdentifier}: ${migration.file}`, {migrationDatabaseIdentifiers})
+
+      applied = true
+      const db = dbs[dbIdentifier]
+      const MigrationClass = migrationClass
+      const migrationInstance = new MigrationClass({
+        configuration: this.configuration,
+        databaseIdentifier: dbIdentifier,
+        db
+      })
+      const dateString = `${digg(migration, "date")}`
+
+      if (direction == "up") {
+        try {
+          await migrationInstance.change()
+        } catch (changeError) {
+          if (changeError instanceof NotImplementedError) {
+            try {
+              await migrationInstance.up()
+            } catch (upError) {
+              if (upError instanceof NotImplementedError) {
+                throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`, {cause: upError})
+              } else {
+                throw upError
+              }
             }
+          } else {
+            throw changeError
+          }
         }
-        return highestVersion;
-    }
-    /**
-     * Runs run migration file.
-     * @param {object} args - Options object.
-     * @param {import("./migrator/types.js").MigrationObjectType} args.migration - Migration.
-     * @param {import("./migrator/types.js").RequireMigrationType} args.requireMigration - Require migration.
-     * @param {string} [args.direction] - Direction.
-     * @returns {Promise<boolean>} - Whether the migration ran on at least one database (false if skipped as already-run everywhere).
-     */
-    async runMigrationFile({ migration, requireMigration, direction = "up" }) {
-        if (!this.configuration)
-            throw new Error("No configuration set");
-        if (!this.configuration.isDatabasePoolInitialized())
-            await this.configuration.initializeDatabasePool();
-        if (!this.migrationsVersions)
-            await this.loadMigrationsVersions();
-        let applied = false;
-        const dbs = await this.configuration.getCurrentConnections();
-        /**
-         * Db identifiers needing migration versions.
-          @type {string[]} */
-        const dbIdentifiersNeedingMigrationVersions = [];
-        // migrateFiles() wraps execution in ensureConnections(), so the current
-        // async context can expose DB identifiers not loaded by prepare().
-        for (const dbIdentifier in dbs) {
-            if (!this.handlesDatabaseIdentifier(dbIdentifier))
-                continue;
-            const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
-            if (!databaseConfiguration.migrations)
-                continue;
-            if (this.migrationsVersions[dbIdentifier])
-                continue;
-            dbIdentifiersNeedingMigrationVersions.push(dbIdentifier);
-        }
-        for (const dbIdentifier of dbIdentifiersNeedingMigrationVersions) {
-            const db = dbs[dbIdentifier];
-            await this.createMigrationsTableForDatabase({ dbIdentifier, db });
-            await this.loadMigrationsVersionsForDatabase({ dbIdentifier, db });
+
+        const existingSchemaMigrations = await db.newQuery()
+          .from("schema_migrations")
+          .where({version: dateString})
+          .results()
+
+        if (existingSchemaMigrations.length == 0) {
+          await db.insert({tableName: "schema_migrations", data: {version: dateString}})
         }
-        const migrationClass = await requireMigration();
-        if (!migrationClass || typeof migrationClass !== "function") {
-            throw new Error(`Migration ${migration.file} must export a default migration class. Type: ${typeof migrationClass}`);
-        }
-        const migrationDatabaseIdentifiers = migrationClass.getDatabaseIdentifiers() || ["default"];
-        for (const dbIdentifier in dbs) {
-            if (!this.handlesDatabaseIdentifier(dbIdentifier))
-                continue;
-            const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier);
-            if (!databaseConfiguration.migrations) {
-                this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping migration ${digg(migration, "date")}`);
-                continue;
-            }
-            if (!migrationDatabaseIdentifiers.includes(dbIdentifier)) {
-                this.logger.debug(`${dbIdentifier} shouldn't run migration ${migration.file}`, { migrationDatabaseIdentifiers });
-                continue;
-            }
-            if (direction == "up") {
-                if (this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
-                    this.logger.debug(`${dbIdentifier} has already run migration ${migration.file}`);
-                    continue;
-                }
-            }
-            else if (direction == "down") {
-                if (!this.hasRunMigrationVersion(dbIdentifier, migration.date)) {
-                    this.logger.debug(`${dbIdentifier} hasn't run migration ${migration.file}`);
-                    continue;
-                }
-            }
-            else {
-                throw new Error(`Unknown direction: ${direction}`);
-            }
-            this.logger.debug(`Running migration on ${dbIdentifier}: ${migration.file}`, { migrationDatabaseIdentifiers });
-            applied = true;
-            const db = dbs[dbIdentifier];
-            const MigrationClass = migrationClass;
-            const migrationInstance = new MigrationClass({
-                configuration: this.configuration,
-                databaseIdentifier: dbIdentifier,
-                db
-            });
-            const dateString = `${digg(migration, "date")}`;
-            if (direction == "up") {
-                try {
-                    await migrationInstance.change();
-                }
-                catch (changeError) {
-                    if (changeError instanceof NotImplementedError) {
-                        try {
-                            await migrationInstance.up();
-                        }
-                        catch (upError) {
-                            if (upError instanceof NotImplementedError) {
-                                throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`, { cause: upError });
-                            }
-                            else {
-                                throw upError;
-                            }
-                        }
-                    }
-                    else {
-                        throw changeError;
-                    }
-                }
-                const existingSchemaMigrations = await db.newQuery()
-                    .from("schema_migrations")
-                    .where({ version: dateString })
-                    .results();
-                if (existingSchemaMigrations.length == 0) {
-                    await db.insert({ tableName: "schema_migrations", data: { version: dateString } });
-                }
-            }
-            else if (direction == "down") {
-                try {
-                    await migrationInstance.down();
-                }
-                catch (downError) {
-                    if (downError instanceof NotImplementedError) {
-                        throw new Error(`'down' didn't exist on migration: ${migration.file} or migrating down with a change method isn't currently supported`, { cause: downError });
-                    }
-                    else {
-                        throw downError;
-                    }
-                }
-                await db.delete({ tableName: "schema_migrations", conditions: { version: dateString } });
-            }
-            else {
-                throw new Error(`Unknown direction: ${direction}`);
-            }
+      } else if (direction == "down") {
+        try {
+          await migrationInstance.down()
+        } catch (downError) {
+          if (downError instanceof NotImplementedError) {
+            throw new Error(`'down' didn't exist on migration: ${migration.file} or migrating down with a change method isn't currently supported`, {cause: downError})
+          } else {
+            throw downError
+          }
         }
-        return applied;
+
+        await db.delete({tableName: "schema_migrations", conditions: {version: dateString}})
+      } else {
+        throw new Error(`Unknown direction: ${direction}`)
+      }
     }
+
+    return applied
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrator.js","sourceRoot":"","sources":["../../../src/database/migrator.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAA;AAC9B,OAAO,KAAK,UAAU,MAAM,YAAY,CAAA;AACxC,OAAO,MAAM,MAAM,cAAc,CAAA;AACjC,OAAO,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAA;AACxD,OAAO,aAAa,MAAM,6BAA6B,CAAA;AACvD,OAAO,SAAS,MAAM,uBAAuB,CAAA;AAE7C,MAAM,CAAC,OAAO,OAAO,yBAAyB;IAC5C;;wDAEoD;IACpD,kBAAkB,GAAG,EAAE,CAAA;IAEvB;;;;;OAKG;IACH,YAAY,EAAC,aAAa,EAAE,mBAAmB,EAAE,GAAG,QAAQ,EAAC;QAC3D,aAAa,CAAC,QAAQ,CAAC,CAAA;QAEvB,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;QAEzE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,CAAC,mBAAmB,GAAG,mBAAmB,CAAA;QAC9C,IAAI,CAAC,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACH,yBAAyB,CAAC,YAAY;QACpC,IAAI,CAAC,IAAI,CAAC,mBAAmB;YAAE,OAAO,IAAI,CAAA;QAE1C,OAAO,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAA;IACxD,CAAC;IAGD;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAA;QAClC,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAA;IACrC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,qBAAqB;QACzB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QAE5D,KAAK,MAAM,YAAY,IAAI,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAE3D,MAAM,IAAI,CAAC,gCAAgC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAE,GAAG,CAAC,YAAY,CAAC,EAAC,CAAC,CAAA;QACpF,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,gCAAgC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAC;QACvD,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAA;QAEpF,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,8EAA8E,CAAC,CAAA;YAChH,OAAM;QACR,CAAC;QAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,EAAE,CAAC,CAAA;QAElD,IAAI,MAAM,EAAE,CAAC;YACX,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,6CAA6C,CAAC,CAAA;QACjF,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAA;YACxD,MAAM,qBAAqB,GAAG,IAAI,SAAS,CAAC,mBAAmB,EAAE,EAAC,WAAW,EAAE,IAAI,EAAC,CAAC,CAAA;YAErF,qBAAqB,CAAC,MAAM,CAAC,SAAS,EAAE,EAAC,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAC,CAAC,CAAA;YAExE,MAAM,+BAA+B,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAA;YAEtF,KAAK,MAAM,8BAA8B,IAAI,+BAA+B,EAAE,CAAC;gBAC7E,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,8BAA8B,CAAC,CAAA;gBACvF,MAAM,EAAE,CAAC,KAAK,CAAC,8BAA8B,CAAC,CAAA;YAChD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,sBAAsB,CAAC,YAAY,EAAE,OAAO;QAC1C,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAA;QAC3F,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,YAAY,EAAE,CAAC,CAAA;QAEjI,IAAI,OAAO,IAAI,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;YACrD,OAAO,IAAI,CAAA;QACb,CAAC;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAAC,KAAK,EAAE,cAAc;QACtC,IAAI,YAAY,GAAG,CAAC,CAAA;QAEpB,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,kCAAkC,EAAC,EAAE,KAAK,IAAI,EAAE;YAChG,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;gBAC9B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC;oBAC1C,SAAS;oBACT,gBAAgB,EAAE,KAAK,IAAI,EAAE;wBAC3B,IAAI,CAAC,SAAS,CAAC,QAAQ;4BAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;wBAEtH,MAAM,eAAe,GAAG,MAAM,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;wBAEhE,IAAI,CAAC,eAAe,EAAE,CAAC;4BACrB,MAAM,IAAI,KAAK,CAAC,+CAA+C,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAA;wBACtF,CAAC;wBAED,OAAO,eAAe,CAAA;oBACxB,CAAC;iBACF,CAAC,CAAA;gBAEF,IAAI,OAAO;oBAAE,YAAY,EAAE,CAAA;YAC7B,CAAC;YAED,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAC/B,CAAC,CAAC,CAAA;QAEF,OAAO,YAAY,CAAA;IACrB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,8BAA8B,CAAC,cAAc;QACjD;;wEAEgE;QAChE,IAAI,KAAK,GAAG,EAAE,CAAA;QAEd,KAAK,MAAM,IAAI,IAAI,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC;YACzC,+EAA+E;YAC/E,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAA;YAEjD,IAAI,CAAC,KAAK;gBAAE,SAAQ;YAEpB,yDAAyD;YACzD,IAAI,QAAQ,GAAG,IAAI,CAAA;YACnB,IAAI,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAEzB,IAAI,UAAU,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC;gBAC5B,UAAU,GAAG,IAAI,UAAU,EAAE,CAAA;gBAC7B,QAAQ,GAAG,IAAI,QAAQ,EAAE,CAAA;YAC3B,CAAC;YAED,cAAc;YACd,MAAM,IAAI,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAA;YACjC,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAC9B,MAAM,kBAAkB,GAAG,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;YAElF,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,QAAQ;gBACd,IAAI;gBACJ,kBAAkB;aACnB,CAAC,CAAA;QACJ,CAAC;QAED,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;QAEjF,MAAM,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,EAAC,IAAI,EAAE,kDAAkD,EAAC,EAAE,KAAK,IAAI,EAAE;YAChH,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;gBAC9B,MAAM,IAAI,CAAC,gBAAgB,CAAC;oBAC1B,SAAS;oBACT,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO;iBACrE,CAAC,CAAA;YACJ,CAAC;YAED,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAA;QAC/B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,gBAAgB;QACpB,MAAM,kBAAkB,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QACrE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QAC5D,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CACpC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC,CAAC,CAC7F,CAAA;QAED,IAAI,CAAC,kBAAkB,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,IAAI,CAAC;YAAE,OAAM;QAEvE,MAAM,kBAAkB,CAAC,eAAe,CAAC,EAAC,GAAG,EAAE,WAAW,EAAC,CAAC,CAAA;IAC9D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,sBAAsB;QAC1B,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;QAE5B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QAE5D,KAAK,MAAM,YAAY,IAAI,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAE3D,MAAM,IAAI,CAAC,iCAAiC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAE,GAAG,CAAC,YAAY,CAAC,EAAC,CAAC,CAAA;QACrF,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,iCAAiC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAC;QACxD,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAA;QAEpF,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;YACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,gFAAgF,CAAC,CAAA;YAClH,OAAM;QACR,CAAC;QAED,IAAI,CAAC,MAAM,IAAI,CAAC,oBAAoB,CAAC,EAAE,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,YAAY,gDAAgD,CAAC,CAAA;YACpH,OAAO,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAA;YAC5C,OAAM;QACR,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAA;QAEjD,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,GAAG,EAAE,CAAA;QAE1C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;YAEpC,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;QACvD,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,oBAAoB,CAAC,EAAE;QAC3B,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC,cAAc,CAAC,mBAAmB,EAAE,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,CAAA;QAErF,IAAI,CAAC,WAAW;YAAE,OAAO,KAAK,CAAA;QAE9B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,qBAAqB,CAAC,cAAc;QACxC,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,EAAE,CAAA;QAE5C;;wEAEgE;QAChE,IAAI,KAAK,GAAG,EAAE,CAAA;QAEd,KAAK,MAAM,IAAI,IAAI,cAAc,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAA;YAE/C,IAAI,CAAC,KAAK;gBAAE,SAAQ;YAEpB,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YAC/B,MAAM,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAC9B,MAAM,kBAAkB,GAAG,UAAU,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;YAE7D,MAAM,eAAe,GAAG;;kGAE8D,CAAC,CAAC;gBACtF,IAAI;gBACJ,IAAI;gBACJ,kBAAkB;aACnB,CAAC,CAAA;YAEF,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;QAC7B,CAAC;QAED,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAA;QAEjF,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,gBAAgB,CAAC;gBAC1B,SAAS;gBACT,gBAAgB,EAAE,KAAK,IAAI,EAAE,CAAC,cAAc,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,OAAO;aACrE,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QAE5D,KAAK,MAAM,YAAY,IAAI,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAE3D,MAAM,EAAE,GAAG,GAAG,CAAC,YAAY,CAAC,CAAA;YAE5B,MAAM,EAAE,CAAC,uBAAuB,CAAC,KAAK,IAAI,EAAE;gBAC1C,OAAO,IAAI,EAAE,CAAC;oBACZ,MAAM,MAAM,GAAG,EAAE,CAAA;oBACjB,IAAI,eAAe,GAAG,KAAK,CAAA;oBAE3B,IAAI,CAAC;wBACH,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC,SAAS,EAAE,EAAE,CAAC;4BACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;4BAErD,IAAI,CAAC;gCACH,MAAM,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC,CAAA;gCACpD,eAAe,GAAG,IAAI,CAAA;4BACxB,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;4BACpB,CAAC;wBACH,CAAC;wBAED,MAAK;oBACP,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC,CAAC,qCAAqC;wBACrD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,eAAe,EAAE,CAAC;4BACzC,QAAQ;wBACV,CAAC;6BAAM,CAAC;4BACN,MAAM,MAAM,CAAC,CAAC,CAAC,CAAA;wBACjB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,cAAc;QAClC,MAAM,sBAAsB,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAA;QAEnE,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;QACpD,CAAC;QAED,MAAM,4BAA4B,GAAG,QAAQ,CAAC,sBAAsB,CAAC,CAAA;QACrE,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,4BAA4B,CAAC,CAAA;QAEjF,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,8BAA8B,4BAA4B,YAAY,CAAC,CAAA;QACzF,CAAC;QAED,MAAM,IAAI,CAAC,gBAAgB,CAAC;YAC1B,SAAS;YACT,gBAAgB,EAAE,KAAK,IAAI,EAAE;gBAC3B,IAAI,CAAC,SAAS,CAAC,QAAQ;oBAAE,MAAM,IAAI,KAAK,CAAC,yCAAyC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;gBAEtH,OAAO,MAAM,cAAc,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;YACjD,CAAC;YACD,SAAS,EAAE,MAAM;SAClB,CAAC,CAAA;IACJ,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,uBAAuB;QAC3B,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAAE,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAA;QAEjE;;uCAE+B;QAC/B,IAAI,cAAc,CAAA;QAElB,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACnD,KAAK,MAAM,gBAAgB,IAAI,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;gBACrE,IAAI,CAAC,cAAc,IAAI,gBAAgB,GAAG,cAAc,EAAE,CAAC;oBACzD,cAAc,GAAG,gBAAgB,CAAA;gBACnC,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,cAAc,CAAA;IACvB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,gBAAgB,CAAC,EAAC,SAAS,EAAE,gBAAgB,EAAE,SAAS,GAAG,IAAI,EAAC;QACpE,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;QAChE,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,yBAAyB,EAAE;YAAE,MAAM,IAAI,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAA;QACtG,IAAI,CAAC,IAAI,CAAC,kBAAkB;YAAE,MAAM,IAAI,CAAC,sBAAsB,EAAE,CAAA;QAEjE,IAAI,OAAO,GAAG,KAAK,CAAA;QACnB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,qBAAqB,EAAE,CAAA;QAE5D;;6BAEqB;QACrB,MAAM,qCAAqC,GAAG,EAAE,CAAA;QAEhD,wEAAwE;QACxE,mEAAmE;QACnE,KAAK,MAAM,YAAY,IAAI,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAE3D,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAA;YAEpF,IAAI,CAAC,qBAAqB,CAAC,UAAU;gBAAE,SAAQ;YAC/C,IAAI,IAAI,CAAC,kBAAkB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAEnD,qCAAqC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;QAC1D,CAAC;QAED,KAAK,MAAM,YAAY,IAAI,qCAAqC,EAAE,CAAC;YACjE,MAAM,EAAE,GAAG,GAAG,CAAC,YAAY,CAAC,CAAA;YAE5B,MAAM,IAAI,CAAC,gCAAgC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAC,CAAC,CAAA;YAC/D,MAAM,IAAI,CAAC,iCAAiC,CAAC,EAAC,YAAY,EAAE,EAAE,EAAC,CAAC,CAAA;QAClE,CAAC;QAED,MAAM,cAAc,GAAG,MAAM,gBAAgB,EAAE,CAAA;QAE/C,IAAI,CAAC,cAAc,IAAI,OAAO,cAAc,KAAK,UAAU,EAAE,CAAC;YAC5D,MAAM,IAAI,KAAK,CAAC,aAAa,SAAS,CAAC,IAAI,iDAAiD,OAAO,cAAc,EAAE,CAAC,CAAA;QACtH,CAAC;QAED,MAAM,4BAA4B,GAAG,cAAc,CAAC,sBAAsB,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAE3F,KAAK,MAAM,YAAY,IAAI,GAAG,EAAE,CAAC;YAC/B,IAAI,CAAC,IAAI,CAAC,yBAAyB,CAAC,YAAY,CAAC;gBAAE,SAAQ;YAE3D,MAAM,qBAAqB,GAAG,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAA;YAEpF,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,CAAC;gBACtC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,yDAAyD,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAC,CAAA;gBACpH,SAAQ;YACV,CAAC;YAED,IAAI,CAAC,4BAA4B,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;gBACzD,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,4BAA4B,SAAS,CAAC,IAAI,EAAE,EAAE,EAAC,4BAA4B,EAAC,CAAC,CAAA;gBAC9G,SAAQ;YACV,CAAC;YAED,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,IAAI,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC9D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,8BAA8B,SAAS,CAAC,IAAI,EAAE,CAAC,CAAA;oBAChF,SAAQ;gBACV,CAAC;YACH,CAAC;iBAAM,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;gBAC/B,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,YAAY,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC/D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,YAAY,yBAAyB,SAAS,CAAC,IAAI,EAAE,CAAC,CAAA;oBAC3E,SAAQ;gBACV,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAA;YACpD,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,YAAY,KAAK,SAAS,CAAC,IAAI,EAAE,EAAE,EAAC,4BAA4B,EAAC,CAAC,CAAA;YAE5G,OAAO,GAAG,IAAI,CAAA;YACd,MAAM,EAAE,GAAG,GAAG,CAAC,YAAY,CAAC,CAAA;YAC5B,MAAM,cAAc,GAAG,cAAc,CAAA;YACrC,MAAM,iBAAiB,GAAG,IAAI,cAAc,CAAC;gBAC3C,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,kBAAkB,EAAE,YAAY;gBAChC,EAAE;aACH,CAAC,CAAA;YACF,MAAM,UAAU,GAAG,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,EAAE,CAAA;YAE/C,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;gBACtB,IAAI,CAAC;oBACH,MAAM,iBAAiB,CAAC,MAAM,EAAE,CAAA;gBAClC,CAAC;gBAAC,OAAO,WAAW,EAAE,CAAC;oBACrB,IAAI,WAAW,YAAY,mBAAmB,EAAE,CAAC;wBAC/C,IAAI,CAAC;4BACH,MAAM,iBAAiB,CAAC,EAAE,EAAE,CAAA;wBAC9B,CAAC;wBAAC,OAAO,OAAO,EAAE,CAAC;4BACjB,IAAI,OAAO,YAAY,mBAAmB,EAAE,CAAC;gCAC3C,MAAM,IAAI,KAAK,CAAC,+CAA+C,SAAS,CAAC,IAAI,EAAE,EAAE,EAAC,KAAK,EAAE,OAAO,EAAC,CAAC,CAAA;4BACpG,CAAC;iCAAM,CAAC;gCACN,MAAM,OAAO,CAAA;4BACf,CAAC;wBACH,CAAC;oBACH,CAAC;yBAAM,CAAC;wBACN,MAAM,WAAW,CAAA;oBACnB,CAAC;gBACH,CAAC;gBAED,MAAM,wBAAwB,GAAG,MAAM,EAAE,CAAC,QAAQ,EAAE;qBACjD,IAAI,CAAC,mBAAmB,CAAC;qBACzB,KAAK,CAAC,EAAC,OAAO,EAAE,UAAU,EAAC,CAAC;qBAC5B,OAAO,EAAE,CAAA;gBAEZ,IAAI,wBAAwB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;oBACzC,MAAM,EAAE,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,EAAC,OAAO,EAAE,UAAU,EAAC,EAAC,CAAC,CAAA;gBAChF,CAAC;YACH,CAAC;iBAAM,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;gBAC/B,IAAI,CAAC;oBACH,MAAM,iBAAiB,CAAC,IAAI,EAAE,CAAA;gBAChC,CAAC;gBAAC,OAAO,SAAS,EAAE,CAAC;oBACnB,IAAI,SAAS,YAAY,mBAAmB,EAAE,CAAC;wBAC7C,MAAM,IAAI,KAAK,CAAC,qCAAqC,SAAS,CAAC,IAAI,mEAAmE,EAAE,EAAC,KAAK,EAAE,SAAS,EAAC,CAAC,CAAA;oBAC7J,CAAC;yBAAM,CAAC;wBACN,MAAM,SAAS,CAAA;oBACjB,CAAC;gBACH,CAAC;gBAED,MAAM,EAAE,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,mBAAmB,EAAE,UAAU,EAAE,EAAC,OAAO,EAAE,UAAU,EAAC,EAAC,CAAC,CAAA;YACtF,CAAC;iBAAM,CAAC;gBACN,MAAM,IAAI,KAAK,CAAC,sBAAsB,SAAS,EAAE,CAAC,CAAA;YACpD,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport {digg} from \"diggerize\"\nimport * as inflection from \"inflection\"\nimport Logger from \"../logger.js\"\nimport {NotImplementedError} from \"./migration/index.js\"\nimport restArgsError from \"../utils/rest-args-error.js\"\nimport TableData from \"./table-data/index.js\"\n\nexport default class VelociousDatabaseMigrator {\n  /**\n   * Migrations versions.\n    @type {Record<string, Record<string, boolean>>} */\n  migrationsVersions = {}\n\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string[]} [args.databaseIdentifiers] - Optional database identifiers to migrate.\n   */\n  constructor({configuration, databaseIdentifiers, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!configuration) throw new Error(\"configuration argument is required\")\n\n    this.configuration = configuration\n    this.databaseIdentifiers = databaseIdentifiers\n    this.logger = new Logger(this)\n  }\n\n  /**\n   * Runs handles database identifier.\n   * @param {string} dbIdentifier - Database identifier.\n   * @returns {boolean} - Whether this migrator should touch the database identifier.\n   */\n  handlesDatabaseIdentifier(dbIdentifier) {\n    if (!this.databaseIdentifiers) return true\n\n    return this.databaseIdentifiers.includes(dbIdentifier)\n  }\n\n\n  /**\n   * Runs prepare.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async prepare() {\n    await this.createMigrationsTable()\n    await this.loadMigrationsVersions()\n  }\n\n  /**\n   * Runs create migrations table.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async createMigrationsTable() {\n    const dbs = await this.configuration.getCurrentConnections()\n\n    for (const dbIdentifier in dbs) {\n      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue\n\n      await this.createMigrationsTableForDatabase({dbIdentifier, db: dbs[dbIdentifier]})\n    }\n  }\n\n  /**\n   * Runs create migrations table for database.\n   * @param {object} args - Options object.\n   * @param {string} args.dbIdentifier - Database identifier.\n   * @param {import(\"./drivers/base.js\").default} args.db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async createMigrationsTableForDatabase({dbIdentifier, db}) {\n    const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)\n\n    if (!databaseConfiguration.migrations) {\n      this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping creating migrations table for it`)\n      return\n    }\n\n    const exists = await this.migrationsTableExist(db)\n\n    if (exists) {\n      this.logger.debug(`${dbIdentifier} migrations table already exists - skipping`)\n    } else {\n      this.logger.debug(\"New TableData for schema_migrations\")\n      const schemaMigrationsTable = new TableData(\"schema_migrations\", {ifNotExists: true})\n\n      schemaMigrationsTable.string(\"version\", {null: false, primaryKey: true})\n\n      const createSchemaMigrationsTableSqls = await db.createTableSql(schemaMigrationsTable)\n\n      for (const createSchemaMigrationsTableSql of createSchemaMigrationsTableSqls) {\n        this.logger.debug(`Creating migrations table with SQL`, createSchemaMigrationsTableSql)\n        await db.query(createSchemaMigrationsTableSql)\n      }\n    }\n  }\n\n  /**\n   * Runs has run migration version.\n   * @param {string} dbIdentifier - Db identifier.\n   * @param {number} version - Version.\n   * @returns {boolean} - Whether it has run migration version.\n   */\n  hasRunMigrationVersion(dbIdentifier, version) {\n    if (!this.migrationsVersions) throw new Error(\"Migrations versions hasn't been loaded yet\")\n    if (!this.migrationsVersions[dbIdentifier]) throw new Error(`Migrations versions hasn't been loaded yet for db: ${dbIdentifier}`)\n\n    if (version in this.migrationsVersions[dbIdentifier]) {\n      return true\n    }\n\n    return false\n  }\n\n  /**\n   * Runs migrate files.\n   * @param {import(\"./migrator/types.js\").MigrationObjectType[]} files - Files.\n   * @param {import(\"./migrator/types.js\").ImportFullpathCallbackType} importCallback - Import callback.\n   * @returns {Promise<number>} - Number of migrations actually applied (not skipped as already-run).\n   */\n  async migrateFiles(files, importCallback) {\n    let appliedCount = 0\n\n    await this.configuration.ensureConnections({name: \"Database migrator: migrate files\"}, async () => {\n      for (const migration of files) {\n        const applied = await this.runMigrationFile({\n          migration,\n          requireMigration: async () => {\n            if (!migration.fullPath) throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(\", \")}`)\n\n            const migrationImport = await importCallback(migration.fullPath)\n\n            if (!migrationImport) {\n              throw new Error(`Migration file must export migration class: ${migration.fullPath}`)\n            }\n\n            return migrationImport\n          }\n        })\n\n        if (applied) appliedCount++\n      }\n\n      await this._afterMigrations()\n    })\n\n    return appliedCount\n  }\n\n  /**\n   * Runs migrate files from require context.\n   * @param {import(\"./migrator/types.js\").RequireMigrationContextType} requireContext - Require context.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async migrateFilesFromRequireContext(requireContext) {\n    /**\n     * Files.\n      @type {import(\"./migrator/types.js\").MigrationObjectType[]} */\n    let files = []\n\n    for (const file of requireContext.keys()) {\n      // \"13,14\" because somes \"require-context\"-npm-module deletes first character!?\n      const match = file.match(/(\\d{13,14})-(.+)\\.js$/)\n\n      if (!match) continue\n\n      // Fix require-context-npm-module deletes first character\n      let fileName = file\n      let dateNumber = match[1]\n\n      if (dateNumber.length == 13) {\n        dateNumber = `2${dateNumber}`\n        fileName = `2${fileName}`\n      }\n\n      // Parse regex\n      const date = parseInt(dateNumber)\n      const migrationName = match[2]\n      const migrationClassName = inflection.camelize(migrationName.replaceAll(\"-\", \"_\"))\n\n      files.push({\n        file: fileName,\n        date,\n        migrationClassName\n      })\n    }\n\n    files = files.sort((migration1, migration2) => migration1.date - migration2.date)\n\n    await this.configuration.ensureConnections({name: \"Database migrator: migrate require-context files\"}, async () => {\n      for (const migration of files) {\n        await this.runMigrationFile({\n          migration,\n          requireMigration: async () => requireContext(migration.file).default\n        })\n      }\n\n      await this._afterMigrations()\n    })\n  }\n\n  /**\n   * Runs after migrations.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _afterMigrations() {\n    const environmentHandler = this.configuration.getEnvironmentHandler()\n    const dbs = await this.configuration.getCurrentConnections()\n    const filteredDbs = Object.fromEntries(\n      Object.entries(dbs).filter(([dbIdentifier]) => this.handlesDatabaseIdentifier(dbIdentifier))\n    )\n\n    if (!environmentHandler || Object.keys(filteredDbs).length == 0) return\n\n    await environmentHandler.afterMigrations({dbs: filteredDbs})\n  }\n\n  /**\n   * Runs load migrations versions.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async loadMigrationsVersions() {\n    this.migrationsVersions = {}\n\n    const dbs = await this.configuration.getCurrentConnections()\n\n    for (const dbIdentifier in dbs) {\n      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue\n\n      await this.loadMigrationsVersionsForDatabase({dbIdentifier, db: dbs[dbIdentifier]})\n    }\n  }\n\n  /**\n   * Runs load migrations versions for database.\n   * @param {object} args - Options object.\n   * @param {string} args.dbIdentifier - Database identifier.\n   * @param {import(\"./drivers/base.js\").default} args.db - Database connection.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async loadMigrationsVersionsForDatabase({dbIdentifier, db}) {\n    const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)\n\n    if (!databaseConfiguration.migrations) {\n      this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping loading migrations versions for it`)\n      return\n    }\n\n    if (!await this.migrationsTableExist(db)) {\n      this.logger.info(`Migration table does not exist for ${dbIdentifier} - skipping loading migrations versions for it`)\n      delete this.migrationsVersions[dbIdentifier]\n      return\n    }\n\n    const rows = await db.select(\"schema_migrations\")\n\n    this.migrationsVersions[dbIdentifier] = {}\n\n    for (const row of rows) {\n      const version = digg(row, \"version\")\n\n      this.migrationsVersions[dbIdentifier][version] = true\n    }\n  }\n\n  /**\n   * Runs migrations table exist.\n   * @param {import(\"./drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<boolean>} - Resolves with Whether migrations table exist.\n   */\n  async migrationsTableExist(db) {\n    const schemaTable = await db.getTableByName(\"schema_migrations\", {throwError: false})\n\n    if (!schemaTable) return false\n\n    return true\n  }\n\n  /**\n   * Runs execute require context.\n   * @param {import(\"./migrator/types.js\").RequireMigrationContextType} requireContext - Require context.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async executeRequireContext(requireContext) {\n    const migrationFiles = requireContext.keys()\n\n    /**\n     * Files.\n      @type {import(\"./migrator/types.js\").MigrationObjectType[]} */\n    let files = []\n\n    for (const file of migrationFiles) {\n      const match = file.match(/^(\\d{14})-(.+)\\.js$/)\n\n      if (!match) continue\n\n      const date = parseInt(match[1])\n      const migrationName = match[2]\n      const migrationClassName = inflection.camelize(migrationName)\n\n      const migrationObject = /**\n                               * Narrows the runtime value to the documented type.\n                                @type {import(\"./migrator/types.js\").MigrationObjectType} */ ({\n        file,\n        date,\n        migrationClassName\n      })\n\n      files.push(migrationObject)\n    }\n\n    files = files.sort((migration1, migration2) => migration1.date - migration2.date)\n\n    for (const migration of files) {\n      await this.runMigrationFile({\n        migration,\n        requireMigration: async () => requireContext(migration.file).default\n      })\n    }\n  }\n\n  /**\n   * Runs reset.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async reset() {\n    const dbs = await this.configuration.getCurrentConnections()\n\n    for (const dbIdentifier in dbs) {\n      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue\n\n      const db = dbs[dbIdentifier]\n\n      await db.withDisabledForeignKeys(async () => {\n        while (true) {\n          const errors = []\n          let anyTableDropped = false\n\n          try {\n            for (const table of await db.getTables()) {\n              this.logger.info(`Dropping table ${table.getName()}`)\n\n              try {\n                await db.dropTable(table.getName(), {cascade: true})\n                anyTableDropped = true\n              } catch (error) {\n                errors.push(error)\n              }\n            }\n\n            break\n          } catch (error) { // eslint-disable-line no-unused-vars\n            if (errors.length > 0 && anyTableDropped) {\n              // Retry\n            } else {\n              throw errors[0]\n            }\n          }\n        }\n      })\n    }\n  }\n\n  /**\n   * Runs rollback.\n   * @param {import(\"./migrator/types.js\").MigrationObjectType[]} files - Files.\n   * @param {import(\"./migrator/types.js\").ImportFullpathCallbackType} importCallback Function to import a file\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async rollback(files, importCallback) {\n    const latestMigrationVersion = await this._latestMigrationVersion()\n\n    if (!latestMigrationVersion) {\n      throw new Error(\"No migrations have been run yet\")\n    }\n\n    const latestMigrationVersionNumber = parseInt(latestMigrationVersion)\n    const migration = files.find((file) => file.date == latestMigrationVersionNumber)\n\n    if (!migration) {\n      throw new Error(`Migration file for version ${latestMigrationVersionNumber} not found`)\n    }\n\n    await this.runMigrationFile({\n      migration,\n      requireMigration: async () => {\n        if (!migration.fullPath) throw new Error(`Migration didn't have a fullPath key: ${Object.keys(migration).join(\", \")}`)\n\n        return await importCallback(migration.fullPath)\n      },\n      direction: \"down\"\n    })\n  }\n\n  /**\n   * Runs latest migration version.\n   * @returns {Promise<string | undefined>} The latest migration version\n   */\n  async _latestMigrationVersion() {\n    if (!this.migrationsVersions) await this.loadMigrationsVersions()\n\n    /**\n     * Defines highestVersion.\n      @type {string | undefined} */\n    let highestVersion\n\n    for (const dbIdentifier in this.migrationsVersions) {\n      for (const migrationVersion in this.migrationsVersions[dbIdentifier]) {\n        if (!highestVersion || migrationVersion > highestVersion) {\n          highestVersion = migrationVersion\n        }\n      }\n    }\n\n    return highestVersion\n  }\n\n  /**\n   * Runs run migration file.\n   * @param {object} args - Options object.\n   * @param {import(\"./migrator/types.js\").MigrationObjectType} args.migration - Migration.\n   * @param {import(\"./migrator/types.js\").RequireMigrationType} args.requireMigration - Require migration.\n   * @param {string} [args.direction] - Direction.\n   * @returns {Promise<boolean>} - Whether the migration ran on at least one database (false if skipped as already-run everywhere).\n   */\n  async runMigrationFile({migration, requireMigration, direction = \"up\"}) {\n    if (!this.configuration) throw new Error(\"No configuration set\")\n    if (!this.configuration.isDatabasePoolInitialized()) await this.configuration.initializeDatabasePool()\n    if (!this.migrationsVersions) await this.loadMigrationsVersions()\n\n    let applied = false\n    const dbs = await this.configuration.getCurrentConnections()\n\n    /**\n     * Db identifiers needing migration versions.\n      @type {string[]} */\n    const dbIdentifiersNeedingMigrationVersions = []\n\n    // migrateFiles() wraps execution in ensureConnections(), so the current\n    // async context can expose DB identifiers not loaded by prepare().\n    for (const dbIdentifier in dbs) {\n      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue\n\n      const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)\n\n      if (!databaseConfiguration.migrations) continue\n      if (this.migrationsVersions[dbIdentifier]) continue\n\n      dbIdentifiersNeedingMigrationVersions.push(dbIdentifier)\n    }\n\n    for (const dbIdentifier of dbIdentifiersNeedingMigrationVersions) {\n      const db = dbs[dbIdentifier]\n\n      await this.createMigrationsTableForDatabase({dbIdentifier, db})\n      await this.loadMigrationsVersionsForDatabase({dbIdentifier, db})\n    }\n\n    const migrationClass = await requireMigration()\n\n    if (!migrationClass || typeof migrationClass !== \"function\") {\n      throw new Error(`Migration ${migration.file} must export a default migration class. Type: ${typeof migrationClass}`)\n    }\n\n    const migrationDatabaseIdentifiers = migrationClass.getDatabaseIdentifiers() || [\"default\"]\n\n    for (const dbIdentifier in dbs) {\n      if (!this.handlesDatabaseIdentifier(dbIdentifier)) continue\n\n      const databaseConfiguration = this.configuration.getDatabaseIdentifier(dbIdentifier)\n\n      if (!databaseConfiguration.migrations) {\n        this.logger.debug(`${dbIdentifier} isn't configured for migrations - skipping migration ${digg(migration, \"date\")}`)\n        continue\n      }\n\n      if (!migrationDatabaseIdentifiers.includes(dbIdentifier)) {\n        this.logger.debug(`${dbIdentifier} shouldn't run migration ${migration.file}`, {migrationDatabaseIdentifiers})\n        continue\n      }\n\n      if (direction == \"up\") {\n        if (this.hasRunMigrationVersion(dbIdentifier, migration.date)) {\n          this.logger.debug(`${dbIdentifier} has already run migration ${migration.file}`)\n          continue\n        }\n      } else if (direction == \"down\") {\n        if (!this.hasRunMigrationVersion(dbIdentifier, migration.date)) {\n          this.logger.debug(`${dbIdentifier} hasn't run migration ${migration.file}`)\n          continue\n        }\n      } else {\n        throw new Error(`Unknown direction: ${direction}`)\n      }\n\n      this.logger.debug(`Running migration on ${dbIdentifier}: ${migration.file}`, {migrationDatabaseIdentifiers})\n\n      applied = true\n      const db = dbs[dbIdentifier]\n      const MigrationClass = migrationClass\n      const migrationInstance = new MigrationClass({\n        configuration: this.configuration,\n        databaseIdentifier: dbIdentifier,\n        db\n      })\n      const dateString = `${digg(migration, \"date\")}`\n\n      if (direction == \"up\") {\n        try {\n          await migrationInstance.change()\n        } catch (changeError) {\n          if (changeError instanceof NotImplementedError) {\n            try {\n              await migrationInstance.up()\n            } catch (upError) {\n              if (upError instanceof NotImplementedError) {\n                throw new Error(`'change' or 'up' didn't exist on migration: ${migration.file}`, {cause: upError})\n              } else {\n                throw upError\n              }\n            }\n          } else {\n            throw changeError\n          }\n        }\n\n        const existingSchemaMigrations = await db.newQuery()\n          .from(\"schema_migrations\")\n          .where({version: dateString})\n          .results()\n\n        if (existingSchemaMigrations.length == 0) {\n          await db.insert({tableName: \"schema_migrations\", data: {version: dateString}})\n        }\n      } else if (direction == \"down\") {\n        try {\n          await migrationInstance.down()\n        } catch (downError) {\n          if (downError instanceof NotImplementedError) {\n            throw new Error(`'down' didn't exist on migration: ${migration.file} or migrating down with a change method isn't currently supported`, {cause: downError})\n          } else {\n            throw downError\n          }\n        }\n\n        await db.delete({tableName: \"schema_migrations\", conditions: {version: dateString}})\n      } else {\n        throw new Error(`Unknown direction: ${direction}`)\n      }\n    }\n\n    return applied\n  }\n}\n"]}