knex-migrator 4.0.5 → 4.1.3

package/lib/index.js

@@ -155,30 +155,33 @@ KnexMigrator.prototype.init = function init(options) {
                                 throw err;
                             }
 
-                            return database.createTransaction(self.connection, function (transacting) {
+                            return database.createTransaction(self.connection, async function (transacting) {
+                                const existingMigrations = await transacting('migrations').select('name');
+                                const existingMigrationsNames = existingMigrations.map(m => m.name);
+                                const migrationsToAdd = [];
+
                                 // CASE: Run over all migration scripts and add the file name to the database.
-                                return Promise.each(versionsToMigrateTo, function (versionToMigrateTo) {
+                                for (const versionToMigrateTo of versionsToMigrateTo) {
                                     let versionPath = path.join(self.migrationPath, self.subfolder, versionToMigrateTo);
                                     let filesToMigrateTo = utils.listFiles(versionPath) || [];
 
-                                    return Promise.each(filesToMigrateTo, function (fileToMigrateTo) {
-                                        // CASE: check if migration exists, do not insert twice
-                                        return transacting('migrations')
-                                            .where('name', fileToMigrateTo)
-                                            .then(function (migrationExists) {
-                                                if (migrationExists.length) {
-                                                    return Promise.resolve();
-                                                }
-
-                                                return transacting('migrations')
-                                                    .insert({
-                                                        name: fileToMigrateTo,
-                                                        version: versionToMigrateTo,
-                                                        currentVersion: self.currentVersion
-                                                    });
-                                            });
-                                    });
-                                });
+                                    // CASE: check if migration exists, do not insert twice
+                                    for (const name of filesToMigrateTo) {
+                                        if (existingMigrationsNames.includes(name)) {
+                                            continue;
+                                        }
+
+                                        migrationsToAdd.push({
+                                            name,
+                                            version: versionToMigrateTo,
+                                            currentVersion: self.currentVersion
+                                        });
+                                    }
+                                }
+
+                                await self.connection
+                                    .batchInsert('migrations', migrationsToAdd)
+                                    .transacting(transacting);
                             });
                         })
                         .then(function () {
@@ -286,11 +289,10 @@ KnexMigrator.prototype.init = function init(options) {
  * @param {Object} options - Custom options you can pass in (version, force, init, only, skip)
  * @returns {Bluebird<any>}
  */
-KnexMigrator.prototype.migrate = function migrate(options) {
+KnexMigrator.prototype.migrate = async function migrate(options) {
     options = options || {};
 
-    let self = this,
-        onlyVersion = options.version,
+    let onlyVersion = options.version,
         force = options.force,
         init = options.init,
         onlyFile = options.only,
@@ -308,14 +310,11 @@ KnexMigrator.prototype.migrate = function migrate(options) {
 
     // CASE: `--init` flag is passed. Combo feature.
     if (init) {
-        return this.init()
-            .then(function () {
-                return self.migrate(_.omit(options, 'init'));
-            });
+        await this.init();
     }
 
     try {
-        hooks = require(path.join(self.migrationPath, '/hooks/migrate'));
+        hooks = require(path.join(this.migrationPath, '/hooks/migrate'));
     } catch (err) {
         debug('Hook Error: ' + err.message);
         debug('No hooks found, no problem.');
@@ -323,152 +322,130 @@ KnexMigrator.prototype.migrate = function migrate(options) {
 
     this.connection = database.connect(this.dbConfig);
 
-    return database.ensureConnectionWorks(this.connection)
-        .then(function () {
-            return migrations.run(self.connection);
-        })
-        .then(function () {
-            return locking.lock(self.connection);
-        })
-        .then(function () {
-            return self._integrityCheck({
-                force: force
-            });
-        })
-        .then(function (result) {
-            _.each(result, function (value, version) {
-                // CASE: Log which versions won't be executed based on the "only" flag
-                if (onlyVersion && version !== onlyVersion) {
-                    debug('Do not execute: ' + version);
-                    return;
-                }
-            });
+    try {
+        await database.ensureConnectionWorks(this.connection);
 
-            if (onlyVersion) {
-                // CASE: filter out versions which should not run
-                let containsVersion = _.find(result, function (obj, key) {
-                    return key === onlyVersion;
-                });
+        await migrations.run(this.connection);
 
-                if (!containsVersion) {
-                    logging.warn('Cannot find requested version: ' + onlyVersion);
-                }
+        await locking.lock(this.connection);
+
+        const result = await this._integrityCheck({force});
+
+        _.each(result, function (_value, version) {
+            // CASE: Log which versions won't be executed based on the "only" flag
+            if (onlyVersion && version !== onlyVersion) {
+                debug('Do not execute: ' + version);
+                return;
             }
+        });
 
-            _.each(result, function (value, version) {
-                // CASE: compare files on disk with files in database
-                if (value.expected !== value.actual) {
-                    debug('Need to execute migrations for: ' + version);
-                    versionsToMigrate.push(version);
-                }
+        if (onlyVersion) {
+            // CASE: filter out versions which should not run
+            let containsVersion = _.find(result, function (_obj, key) {
+                return key === onlyVersion;
             });
-        })
-        .then(function executeBeforeHook() {
-            if (!versionsToMigrate.length) {
-                return;
+
+            if (!containsVersion) {
+                logging.warn('Cannot find requested version: ' + onlyVersion);
             }
+        }
 
+        _.each(result, function (value, version) {
+            // CASE: compare files on disk with files in database
+            if (value.expected !== value.actual) {
+                debug('Need to execute migrations for: ' + version);
+                versionsToMigrate.push(version);
+            }
+        });
+
+        if (versionsToMigrate.length) {
             if (hooks.before) {
                 debug('Before hook');
-                return hooks.before({
-                    connection: self.connection
+                await hooks.before({
+                    connection: this.connection
                 });
             }
-        })
-        .then(function executeMigrations() {
-            if (!versionsToMigrate.length) {
-                return;
-            }
 
-            return Promise.each(versionsToMigrate, function (versionToMigrate) {
-                return self._migrateTo({
-                    version: versionToMigrate,
-                    only: onlyFile,
-                    hooks: hooks
-                });
-            });
-        })
-        .then(function executeAfterHook() {
-            if (!versionsToMigrate.length) {
-                return;
-            }
+            logging.info('Running migrations.');
 
-            if (hooks.after) {
-                debug('After hook');
-                return hooks.after({
-                    connection: self.connection
-                });
-            }
-        })
-        .then(function () {
-            return locking.unlock(self.connection);
-        })
-        .catch(function (err) {
-            // CASE: Do not rollback if migrations are locked
-            if (err instanceof errors.MigrationsAreLockedError) {
-                throw err;
-            }
+            for (const versionToMigrate of versionsToMigrate) {
+                try {
+                    await this._migrateTo({
+                        version: versionToMigrate,
+                        only: onlyFile,
+                        hooks: hooks
+                    });
+                } catch (err) {
+                    // CASE: Do not rollback if migrations are locked
+                    if (err instanceof errors.MigrationsAreLockedError) {
+                        throw err;
+                    }
 
-            // CASE: Do not rollback migration scripts, if lock error
-            if (err instanceof errors.LockError) {
-                throw err;
-            }
+                    // CASE: Do not rollback migration scripts, if lock error
+                    if (err instanceof errors.LockError) {
+                        throw err;
+                    }
 
-            // CASE: ETIMEDOUT, ENOTFOUND
-            if (err instanceof errors.DatabaseError) {
-                throw err;
-            }
+                    // CASE: ETIMEDOUT, ENOTFOUND
+                    if (err instanceof errors.DatabaseError) {
+                        throw err;
+                    }
 
-            if (err.context && err.context.name) {
-                debug(`Task failed: ${err.context.name}`);
-            }
+                    if (err.context && err.context.name) {
+                        debug(`Task failed: ${err.context.name}`);
+                    }
 
-            debug(`Rolling back: ${err.message}`);
+                    logging.info(`Rolling back: ${err.message}.`);
 
-            versionsToMigrate.reverse();
+                    const versionsMigrated = versionsToMigrate.slice(
+                        0,
+                        versionsToMigrate.indexOf(versionToMigrate) + 1
+                    );
 
-            // CASE: rollback in reversed order
-            return Promise.each(versionsToMigrate, function (version) {
-                return self._rollback({version: version, task: err.context});
-            }).then(function () {
-                throw err;
-            }).catch(function (innerErr) {
-                if (errors.utils.isIgnitionError(innerErr)) {
-                    throw err;
-                }
+                    versionsMigrated.reverse();
 
-                throw new errors.RollbackError({
-                    message: innerErr.message,
-                    err: innerErr,
-                    context: `OuterError: ${err.message}`
-                });
-            }).finally(function () {
-                return locking.unlock(self.connection);
-            });
-        }).finally(function () {
-            let ops = [];
+                    try {
+                        for (const versionMigrated of versionsMigrated) {
+                            await this._rollback({version: versionMigrated, task: err.context});
+                        }
+                        logging.info(`Rollback was successful.`);
+                        throw err;
+                    } catch (innerErr) {
+                        if (errors.utils.isIgnitionError(innerErr)) {
+                            throw err;
+                        }
+
+                        throw new errors.RollbackError({
+                            message: innerErr.message,
+                            err: innerErr,
+                            context: `OuterError: ${err.message}`
+                        });
+                    } finally {
+                        await locking.unlock(this.connection);
+                    }
+                }
+            }
 
-            if (hooks.shutdown) {
-                ops.push(function shutdownHook() {
-                    debug('Shutdown hook');
-                    return hooks.shutdown({
-                        executedFromShell: self.executedFromShell
-                    });
+            if (hooks.after) {
+                debug('After hook');
+                await hooks.after({
+                    connection: this.connection
                 });
             }
-
-            ops.push(function destroyConnection() {
-                debug('Destroy connection');
-                return self.connection.destroy()
-                    .then(function () {
-                        debug('Destroyed connection');
-                    });
+        }
+        await locking.unlock(this.connection);
+    } finally {
+        if (hooks.shutdown) {
+            debug('Shutdown hook');
+            await hooks.shutdown({
+                executedFromShell: this.executedFromShell
             });
+        }
 
-            return Promise.each(ops, function (op) {
-                return op.bind(self)();
-            });
-        });
+        debug('Destroy connection');
+        await this.connection.destroy();
+        debug('Destroyed connection');
+    }
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knex-migrator",
-  "version": "4.0.5",
+  "version": "4.1.3",
   "description": "Database migrations with knex.",
   "keywords": [
     "ghost",
@@ -44,7 +44,7 @@
     "knex-migrator-rollback": "./bin/knex-migrator-rollback"
   },
   "engines": {
-    "node": "^12.10.0 || ^14.14.0"
+    "node": "^12.22.1 || ^14.17.0 || ^16.13.0"
   },
   "dependencies": {
     "bluebird": "3.7.2",