knex-migrator 5.4.0 → 6.0.0

package/bin/knex-migrator-migrate

@@ -1,38 +1,44 @@
 #!/usr/bin/env node
 
-var program = require('commander');
-var utils = require('../lib/utils');
-
-var logging = require('@tryghost/logging');
-var knexMigrator;
-
-utils.getKnexMigrator({path: process.cwd()})
-    .then(function (KnexMigrator) {
-        program
-            .option('--v <item>')
-            .option('--only <item>')
-            .option('--mgpath <path>')
-            .option('--force')
-            .option('--init')
-            .parse(process.argv);
-
-        try {
-            knexMigrator = new KnexMigrator({knexMigratorFilePath: program.mgpath, executedFromShell: true});
-        } catch (err) {
-            logging.error(err);
-            process.exit(1);
-        }
-
-        return knexMigrator.migrate({
-            version: program.v,
-            only: program.only,
-            force: program.force,
-            init: program.init
-        }).then(function () {
-            logging.info('Finished database migration!');
+const program = require('commander').program;
+const utils = require('../lib/utils');
+
+const logging = require('@tryghost/logging');
+
+async function main() {
+    const KnexMigrator = await utils.getKnexMigrator({path: process.cwd()});
+
+    program
+        .option('--v <item>')
+        .option('--only <item>')
+        .option('--mgpath <path>')
+        .option('--force')
+        .option('--init')
+        .parse(process.argv);
+
+    const options = program.opts();
+    let knexMigrator;
+
+    try {
+        knexMigrator = new KnexMigrator({
+            knexMigratorFilePath: options.mgpath,
+            executedFromShell: true,
         });
-    })
-    .catch(function (err) {
+    } catch (err) {
+        logging.error(err);
+        process.exit(1);
+    }
+
+    await knexMigrator.migrate({
+        version: options.v,
+        only: options.only,
+        force: options.force,
+        init: options.init,
+    });
+    logging.info('Finished database migration!');
+}
+
+main().catch(function (err) {
         logging.error(err);
         process.exit(1);
     });

package/bin/knex-migrator-reset

@@ -1,31 +1,36 @@
 #!/usr/bin/env node
 
-var program = require('commander');
-var utils = require('../lib/utils');
-
-var logging = require('@tryghost/logging');
-var knexMigrator;
-
-utils.getKnexMigrator({path: process.cwd()})
-    .then(function (KnexMigrator) {
-        program
-            .option('--mgpath <path>')
-            .option('--force')
-            .parse(process.argv);
-
-        try {
-            knexMigrator = new KnexMigrator({knexMigratorFilePath: program.mgpath, executedFromShell: true});
-        } catch (err) {
-            logging.error(err);
-            process.exit(1);
-        }
-
-        return knexMigrator.reset({force: program.force})
-            .then(function () {
-                logging.info('Finished database reset!');
-            });
-    })
-    .catch(function (err) {
+const program = require('commander').program;
+const utils = require('../lib/utils');
+
+const logging = require('@tryghost/logging');
+
+async function main() {
+    const KnexMigrator = await utils.getKnexMigrator({path: process.cwd()});
+
+    program
+        .option('--mgpath <path>')
+        .option('--force')
+        .parse(process.argv);
+
+    const options = program.opts();
+    let knexMigrator;
+
+    try {
+        knexMigrator = new KnexMigrator({
+            knexMigratorFilePath: options.mgpath,
+            executedFromShell: true,
+        });
+    } catch (err) {
+        logging.error(err);
+        process.exit(1);
+    }
+
+    await knexMigrator.reset({force: options.force});
+    logging.info('Finished database reset!');
+}
+
+main().catch(function (err) {
         logging.error(err);
         process.exit(1);
     });

package/bin/knex-migrator-rollback

@@ -1,32 +1,37 @@
 #!/usr/bin/env node
 
-const program = require('commander');
+const program = require('commander').program;
 const utils = require('../lib/utils');
 
 const logging = require('@tryghost/logging');
-let knexMigrator;
-
-utils.getKnexMigrator({path: process.cwd()})
-    .then(function (KnexMigrator) {
-        program
-            .option('--mgpath <path>')
-            .option('--force')
-            .option('--v <version>', 'The version to rollback to.')
-            .parse(process.argv);
-
-        try {
-            knexMigrator = new KnexMigrator({knexMigratorFilePath: program.mgpath, executedFromShell: true});
-        } catch (err) {
-            logging.error(err);
-            process.exit(1);
-        }
 
-        return knexMigrator.rollback({force: program.force, version: program.v})
-            .then(function () {
-                logging.info('Rollback was successful.');
-            });
-    })
-    .catch(function (err) {
+async function main() {
+    const KnexMigrator = await utils.getKnexMigrator({path: process.cwd()});
+
+    program
+        .option('--mgpath <path>')
+        .option('--force')
+        .option('--v <version>', 'The version to rollback to.')
+        .parse(process.argv);
+
+    const options = program.opts();
+    let knexMigrator;
+
+    try {
+        knexMigrator = new KnexMigrator({
+            knexMigratorFilePath: options.mgpath,
+            executedFromShell: true,
+        });
+    } catch (err) {
+        logging.error(err);
+        process.exit(1);
+    }
+
+    await knexMigrator.rollback({force: options.force, version: options.v});
+    logging.info('Rollback was successful.');
+}
+
+main().catch(function (err) {
         logging.error(err.message);
 
         if (err.help) {

package/lib/database.js

@@ -1,9 +1,51 @@
-const knex = require('knex'),
+const path = require('path'),
+    bundledKnex = require('knex'),
     omit = require('lodash/omit'),
     debug = require('debug')('knex-migrator:database'),
     errors = require('./errors');
 const DatabaseInfo = require('@tryghost/database-info');
-const {sequence} = require('@tryghost/promise');
+const { sequence } = require('@tryghost/promise');
+
+function destroyConnection(connection) {
+    return new Promise(function (resolve, reject) {
+        connection.destroy(function (err) {
+            if (err) {
+                reject(err);
+                return;
+            }
+
+            resolve();
+        });
+    });
+}
+
+function loadKnex(options) {
+    options = options || {};
+
+    if (options.knexModulePath) {
+        let resolvedKnexPath;
+
+        try {
+            resolvedKnexPath = require.resolve('knex', {
+                paths: [path.resolve(options.knexModulePath)],
+            });
+        } catch (err) {
+            if (err.code !== 'MODULE_NOT_FOUND') {
+                throw err;
+            }
+
+            debug(
+                'Could not load project knex from ' + options.knexModulePath + ': ' + err.message,
+            );
+        }
+
+        if (resolvedKnexPath) {
+            return require(resolvedKnexPath);
+        }
+    }
+
+    return bundledKnex;
+}
 
 /**
  * @NOTE: Knex-migrator only supports knex query builder.
@@ -11,7 +53,7 @@ const {sequence} = require('@tryghost/promise');
  * @param options
  * @returns {Knex.QueryBuilder | Knex}
  */
-exports.connect = function connect(options) {
+exports.connect = function connect(options, connectionOptions) {
     options = options || {};
 
     // Alias `mysql` to `mysql2` so we can maintain backwards compatibility
@@ -19,9 +61,14 @@ exports.connect = function connect(options) {
         options.client = 'mysql2';
     }
 
+    // Alias `sqlite3` to `better-sqlite3` so we can maintain backwards compatibility
+    if (options.client === 'sqlite3') {
+        options.client = 'better-sqlite3';
+    }
+
     const client = options.client;
 
-    if (client === 'sqlite3') {
+    if (client === 'better-sqlite3') {
         options.useNullAsDefault = options.useNullAsDefault || false;
     }
 
@@ -33,7 +80,7 @@ exports.connect = function connect(options) {
         delete options.connection.filename;
     }
 
-    return knex(options);
+    return loadKnex(connectionOptions)(options);
 };
 
 /**
@@ -43,23 +90,24 @@ exports.connect = function connect(options) {
  * @param connection
  * @returns {Promise<R> | Promise<any> | Promise<T>}
  */
-exports.ensureConnectionWorks = (connection) => {
-    return connection.raw('SELECT 1+1 as RESULT;')
-        .catch((err) => {
-            if (err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT' || err.code === 'EAI_AGAIN') {
-                throw new errors.DatabaseError({
-                    message: 'Invalid database host.',
-                    help: 'Please double check your database config.',
-                    err: err
-                });
-            }
-
+exports.ensureConnectionWorks = async function ensureConnectionWorks(connection) {
+    try {
+        await connection.raw('SELECT 1+1 as RESULT;');
+    } catch (err) {
+        if (err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT' || err.code === 'EAI_AGAIN') {
             throw new errors.DatabaseError({
-                message: err.message,
-                help: 'Unknown database error',
-                err: err
+                message: 'Invalid database host.',
+                help: 'Please double check your database config.',
+                err: err,
             });
+        }
+
+        throw new errors.DatabaseError({
+            message: err.message,
+            help: 'Unknown database error',
+            err: err,
         });
+    }
 };
 
 /**
@@ -101,54 +149,52 @@ exports.createMigrationsTable = async function createMigrationsTable(connection)
  * @param dbConfig
  * @returns {*}
  */
-exports.createDatabaseIfNotExist = function createDatabaseIfNotExist(dbConfig) {
-    const name = dbConfig.connection.database,
-        charset = dbConfig.connection.charset || 'utf8mb4';
+exports.createDatabaseIfNotExist = async function createDatabaseIfNotExist(
+    dbConfig,
+    connectionOptions,
+) {
+    const name = dbConfig.connection.database;
+    const charset = dbConfig.connection.charset || 'utf8mb4';
 
     // @NOTE: Skip, because sqlite3 is a file based database.
     if (DatabaseInfo.isSQLiteConfig(dbConfig)) {
-        return Promise.resolve();
-    } else if (!DatabaseInfo.isMySQLConfig(dbConfig)) {
-        return Promise.reject(new errors.KnexMigrateError({
-            message: 'Database is not supported.'
-        }));
+        return;
     }
 
-    const connection = exports.connect({
-        client: dbConfig.client,
-        connection: omit(dbConfig.connection, ['database'])
-    });
+    if (!DatabaseInfo.isMySQLConfig(dbConfig)) {
+        throw new errors.KnexMigrateError({
+            message: 'Database is not supported.',
+        });
+    }
+
+    const connection = exports.connect(
+        {
+            client: dbConfig.client,
+            connection: omit(dbConfig.connection, ['database']),
+        },
+        connectionOptions,
+    );
 
     debug('Create database', name);
 
-    return exports.ensureConnectionWorks(connection)
-        .then(function () {
-            return connection.raw('CREATE DATABASE `' + name + '` CHARACTER SET ' + charset + ';');
-        })
-        .catch(function (err) {
-            // CASE: DB exists
-            if (err.errno === 1007) {
-                return Promise.resolve();
-            }
+    try {
+        await exports.ensureConnectionWorks(connection);
+        await connection.raw('CREATE DATABASE `' + name + '` CHARACTER SET ' + charset + ';');
+    } catch (err) {
+        // CASE: DB exists
+        if (err.errno === 1007) {
+            return;
+        }
 
-            throw new errors.DatabaseError({
-                message: err.message,
-                err: err,
-                code: 'DATABASE_CREATION_FAILED'
-            });
-        })
-        .finally(function () {
-            return new Promise(function (resolve, reject) {
-                connection.destroy(function (err) {
-                    if (err) {
-                        return reject(err);
-                    }
-
-                    debug('Destroy connection');
-                    resolve();
-                });
-            });
+        throw new errors.DatabaseError({
+            message: err.message,
+            err: err,
+            code: 'DATABASE_CREATION_FAILED',
         });
+    } finally {
+        await destroyConnection(connection);
+        debug('Destroy connection');
+    }
 };
 
 /**
@@ -157,54 +203,74 @@ exports.createDatabaseIfNotExist = function createDatabaseIfNotExist(dbConfig) {
  * @param options
  * @returns {*}
  */
-exports.drop = function drop(options) {
+exports.drop = async function drop(options) {
     options = options || {};
 
-    const connection = options.connection,
-        dbConfig = options.dbConfig;
+    const connection = options.connection;
+    const dbConfig = options.dbConfig;
 
     if (DatabaseInfo.isMySQL(connection)) {
         debug('Drop database: ' + dbConfig.connection.database);
 
-        return connection.raw('DROP DATABASE `' + dbConfig.connection.database + '`;')
-            .catch(function (err) {
-                // CASE: database does not exist, skip
-                if (err.errno === 1049) {
-                    return Promise.resolve();
-                }
+        try {
+            await connection.raw('DROP DATABASE `' + dbConfig.connection.database + '`;');
+        } catch (err) {
+            // CASE: database does not exist, skip
+            if (err.errno === 1049) {
+                return;
+            }
 
-                return Promise.reject(new errors.KnexMigrateError({
-                    err: err
-                }));
+            throw new errors.KnexMigrateError({
+                err: err,
             });
-    } else if (DatabaseInfo.isSQLite(connection)) {
-        // @NOTE: sqlite3 does not support "DROP DATABASE". We have to drop each table instead.
-        // @NOTE: We cannot just remove the sqlite3 file, because any database connection will get invalid.
-        return connection.raw(`SELECT name FROM sqlite_master WHERE type='table';`)
-            .then(function (tables) {
-                return sequence(tables.map(table => () => {
+        }
+
+        return;
+    }
+
+    if (DatabaseInfo.isSQLite(connection)) {
+        // @NOTE: SQLite does not support "DROP DATABASE". We have to drop each table instead.
+        // @NOTE: We cannot just remove the database file, because any database connection will get invalid.
+        // @NOTE: better-sqlite3 (which `sqlite3` is aliased to) enforces foreign key constraints, so
+        // dropping a parent table before its referencing children trips an FK error. Disable foreign
+        // keys for the duration of the drop and restore afterwards. SQLite uses a single connection
+        // here, so the PRAGMA persists across the drops.
+        try {
+            await connection.raw('PRAGMA foreign_keys = OFF;');
+
+            const tables = await connection.raw(
+                `SELECT name FROM sqlite_master WHERE type='table';`,
+            );
+
+            await sequence(
+                tables.map((table) => async () => {
                     if (table.name === 'sqlite_sequence') {
                         debug('Skip drop table: ' + table.name);
-                        return Promise.resolve();
+                        return;
                     }
 
                     debug('Drop table: ' + table.name);
-                    return connection.schema.dropTableIfExists(table.name);
-                }));
-            })
-            .catch(function (err) {
-                // CASE: database file was never initialised
-                if (err.errno === 10) {
-                    return Promise.resolve();
-                }
-
-                return Promise.reject(new errors.KnexMigrateError({
-                    err: err
-                }));
+                    await connection.schema.dropTableIfExists(table.name);
+                }),
+            );
+        } catch (err) {
+            // CASE: database file was never initialised
+            if (err.errno === 10) {
+                return;
+            }
+
+            throw new errors.KnexMigrateError({
+                err: err,
             });
-    } else {
-        return Promise.reject(new errors.KnexMigrateError({
-            message: 'Database client not supported: ' + dbConfig.client
-        }));
+        } finally {
+            // Best-effort restore; never let a failed PRAGMA mask the drop result.
+            await connection.raw('PRAGMA foreign_keys = ON;').catch(function () {});
+        }
+
+        return;
     }
+
+    throw new errors.KnexMigrateError({
+        message: 'Database client not supported: ' + dbConfig.client,
+    });
 };