knex-migrator 4.0.5

package/bin/knex-migrator-rollback

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+const program = require('commander');
+const utils = require('../lib/utils');
+
+const logging = require('../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) {
+        logging.error(err.message);
+
+        if (err.help) {
+            logging.info(err.help);
+        }
+
+        process.exit(1);
+    });

package/lib/database.js

@@ -0,0 +1,204 @@
+const knex = require('knex'),
+    Promise = require('bluebird'),
+    omit = require('lodash/omit'),
+    debug = require('debug')('knex-migrator:database'),
+    errors = require('./errors');
+
+/**
+ * @NOTE: Knex-migrator only supports knex query builder.
+ *
+ * @param options
+ * @returns {Knex.QueryBuilder | Knex}
+ */
+exports.connect = function connect(options) {
+    options = options || {};
+    const client = options.client;
+
+    if (client === 'sqlite3') {
+        options.useNullAsDefault = options.useNullAsDefault || false;
+    }
+
+    if (client === 'mysql') {
+        options.connection.timezone = options.connection.timezone || 'UTC';
+        options.connection.charset = options.connection.charset || 'utf8mb4';
+        options.connection.collation = options.connection.collation || 'utf8mb4_general_ci';
+    }
+
+    return knex(options);
+};
+
+/**
+ * If you instantiate knex, you won't know if the connection works.
+ * This helper functions is used to test the connection. It's basically a "test query".
+ *
+ * @param connection
+ * @returns {Bluebird<R> | Bluebird<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
+                });
+            }
+
+            throw new errors.DatabaseError({
+                message: err.message,
+                help: 'Unknown database error',
+                err: err
+            });
+        });
+};
+
+/**
+ * @description Helper to create a transaction.
+ * @param callback
+ * @returns {*}
+ */
+module.exports.createTransaction = function (connection, callback) {
+    return connection.transaction(callback);
+};
+
+/**
+ * @description Helper to create the migration table.
+ *
+ * @TODO: https://github.com/TryGhost/knex-migrator/issues/118
+ * @TODO: https://github.com/TryGhost/knex-migrator/issues/91
+ * @returns {Bluebird<R> | Bluebird<any> | * | Promise<T>}
+ */
+exports.createMigrationsTable = function createMigrationsTable(connection) {
+    return connection('migrations')
+        .catch(function (err) {
+            // CASE: table does not exist
+            if (err.errno === 1 || err.errno === 1146) {
+                debug('Creating table: migrations');
+
+                return connection.schema.createTable('migrations', function (table) {
+                    table.increments().primary();
+                    table.string('name');
+                    table.string('version');
+                    table.string('currentVersion');
+                });
+            }
+
+            throw err;
+        });
+};
+
+/**
+ * Knex-migrator has an inbuilt feature to create a database if it does not exist yet.
+ *
+ * @param dbConfig
+ * @returns {*}
+ */
+exports.createDatabaseIfNotExist = function createDatabaseIfNotExist(dbConfig) {
+    const name = dbConfig.connection.database,
+        charset = dbConfig.connection.charset || 'utf8mb4',
+        collation = dbConfig.connection.collation || 'utf8mb4_general_ci';
+
+    // @NOTE: Skip, because sqlite3 is a file based database.
+    if (dbConfig.client === 'sqlite3') {
+        return Promise.resolve();
+    } else if (dbConfig.client !== 'mysql') {
+        return Promise.reject(new errors.KnexMigrateError({
+            message: 'Database is not supported.'
+        }));
+    }
+
+    const connection = exports.connect({
+        client: dbConfig.client,
+        connection: omit(dbConfig.connection, ['database'])
+    });
+
+    debug('Create database', name);
+
+    return exports.ensureConnectionWorks(connection)
+        .then(function () {
+            return connection.raw('CREATE DATABASE `' + name + '` CHARACTER SET ' + charset + ' COLLATE ' + collation + ';');
+        })
+        .catch(function (err) {
+            // CASE: DB exists
+            if (err.errno === 1007) {
+                return Promise.resolve();
+            }
+
+            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();
+                });
+            });
+        });
+};
+
+/**
+ * Drops a database. Is called when you call `knex-migrator reset`.
+ *
+ * @param options
+ * @returns {*}
+ */
+exports.drop = function drop(options) {
+    options = options || {};
+
+    const connection = options.connection,
+        dbConfig = options.dbConfig;
+
+    if (dbConfig.client === 'mysql') {
+        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();
+                }
+
+                return Promise.reject(new errors.KnexMigrateError({
+                    err: err
+                }));
+            });
+    } else if (dbConfig.client === 'sqlite3') {
+        // @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 Promise.each(tables, function (table) {
+                    if (table.name === 'sqlite_sequence') {
+                        debug('Skip drop table: ' + table.name);
+                        return Promise.resolve();
+                    }
+
+                    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
+                }));
+            });
+    } else {
+        return Promise.reject(new errors.KnexMigrateError({
+            message: 'Database client not supported: ' + dbConfig.client
+        }));
+    }
+};

package/lib/errors.js

@@ -0,0 +1,84 @@
+const util = require('util');
+const each = require('lodash/each');
+const errors = require('ghost-ignition').errors;
+
+function KnexMigrateError(options) {
+    options = options || {};
+    errors.IgnitionError.call(this, options);
+}
+
+const knexMigratorErrors = {
+    MigrationExistsError: function MigrationExistsError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 100,
+            errorType: 'MigrationExistsError'
+        }, options));
+    },
+    DatabaseIsNotOkError: function DatabaseIsNotOkError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 200,
+            errorType: 'DatabaseIsNotOkError',
+            help: 'If knex-migrator is not installed, please run "npm install -g knex-migrator" \nRead more here: https://github.com/TryGhost/knex-migrator'
+        }, options));
+    },
+    MigrationScriptError: function MigrationScriptError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 300,
+            errorType: 'MigrationScriptError'
+        }, options));
+    },
+    RollbackError: function RollbackError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 400,
+            errorType: 'RollbackError'
+        }, options));
+    },
+    MigrationsAreLockedError: function MigrationsAreLockedError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 500,
+            errorType: 'MigrationsAreLockedError'
+        }, options));
+    },
+    LockError: function LockError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 500,
+            errorType: 'LockError'
+        }, options));
+    },
+    UnlockError: function UnlockError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 500,
+            errorType: 'UnlockError'
+        }, options));
+    },
+    DatabaseError: function DatabaseError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 500,
+            errorType: 'DatabaseError'
+        }, options));
+    },
+    IrreversibleMigrationError: function IrreversibleMigrationError(options) {
+        KnexMigrateError.call(this, Object.assign({
+            id: 500,
+            errorType: 'IrreversibleMigrationError'
+        }, options));
+    }
+};
+
+util.inherits(KnexMigrateError, errors.IgnitionError);
+
+each(knexMigratorErrors, function (error) {
+    util.inherits(error, KnexMigrateError);
+});
+
+// we need to inherit all general errors from KnexMigrateError, otherwise we have to check instanceof IgnitionError
+each(errors, function (error) {
+    if (error.name === 'IgnitionError' || typeof error === 'object') {
+        return;
+    }
+
+    util.inherits(error, KnexMigrateError);
+});
+
+module.exports = Object.assign(knexMigratorErrors, errors);
+module.exports.KnexMigrateError = KnexMigrateError;