db-migrate 1.0.0-beta.16

package/lib/commands/db.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var log = require('db-migrate-shared').log;
+var assert = require('assert');
+
+function executeDB (internals, config, callback) {
+  var index = require('../../connect');
+
+  if (internals.argv._.length > 0) {
+    internals.argv.dbname = internals.argv._.shift().toString();
+  } else {
+    log.info('Error: You must enter a database name!');
+    return;
+  }
+
+  delete config.getCurrent().settings.database;
+
+  index.driver(config.getCurrent().settings, function (err, db) {
+    assert.ifError(err);
+
+    if (internals.mode === 'create') {
+      db.createDatabase(
+        internals.argv.dbname,
+        {
+          ifNotExists: true
+        },
+        function (err) {
+          if (err) {
+            if (err.error) err = err.error;
+            log.error('Error: Failed to create database!', err);
+          } else {
+            log.info('Created database "' + internals.argv.dbname + '"');
+          }
+
+          db.close();
+          if (typeof callback === 'function') callback(err);
+          else process.exit(err ? 1 : 0);
+        }
+      );
+    } else if (internals.mode === 'drop') {
+      db.dropDatabase(
+        internals.argv.dbname,
+        {
+          ifExists: true
+        },
+        function (err) {
+          if (err) {
+            if (err.error) err = err.error;
+            log.error('Error: Failed to drop database!', err);
+          } else {
+            log.info('Deleted database "' + internals.argv.dbname + '"');
+          }
+
+          db.close();
+          if (typeof callback === 'function') callback(err);
+          else process.exit(err ? 1 : 0);
+        }
+      );
+    }
+  });
+}
+
+module.exports = executeDB;

package/lib/commands/down.js

@@ -0,0 +1,45 @@
+var path = require('path');
+var log = require('db-migrate-shared').log;
+var migrationHook = require('./helper/migration-hook.js');
+
+async function prepare (internals, config) {
+  try {
+    await migrationHook(internals);
+    var Migrator = require('../walker.js');
+    var index = require('../../connect');
+
+    if (!internals.argv.count) {
+      log.info('Defaulting to running 1 down migration.');
+      internals.argv.count = 1;
+    }
+
+    const migrator = await index.connect(
+      {
+        config: config.getCurrent().settings,
+        internals: internals,
+        prefix: 'migration'
+      },
+      Migrator
+    );
+
+    migrator.migrationsDir = path.resolve(internals.argv['migrations-dir']);
+
+    await migrator.createMigrationsTable();
+    log.verbose('migration table created');
+
+    return migrator;
+  } catch (err) {
+    throw err;
+  }
+}
+
+module.exports = async function (internals, config) {
+  const migrator = await prepare(internals, config);
+
+  try {
+    const res = await migrator.down(internals.argv);
+    return internals.onComplete(migrator, internals, null, res);
+  } catch (err) {
+    return internals.onComplete(migrator, internals, err);
+  }
+};

package/lib/commands/dump.js

@@ -0,0 +1,22 @@
+const path = require('path');
+const log = require('db-migrate-shared').log;
+
+async function prepare (internals, config) {
+  const index = require('../../connect');
+
+  return index.driver({
+    config: config.getCurrent().settings,
+    internals: internals
+  });
+}
+
+module.exports = async function (internals, config) {
+  const driver = await prepare(internals, config);
+
+  try {
+    const res = await driver.backupGet(internals.argv);
+    return internals.onComplete(driver, internals, null, res);
+  } catch (err) {
+    return internals.onComplete(driver, internals, err);
+  }
+};

package/lib/commands/fn/plugin.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const log = require('db-migrate-shared').log;
+
+function registerPluginLoader (plugins) {
+  return {
+    overwrite: function (name) {
+      if (plugins[name] && plugins[name].length) {
+        var plugin = plugins[name];
+
+        if (plugin.length !== 1) {
+          log.warn(
+            'Attention, multiple overwrites registered for %s, we are ' +
+              'only loading the first plugin %s!',
+            name,
+            plugin.name
+          );
+        }
+
+        plugin = plugin[0];
+        if (typeof plugin.loadPlugin === 'function') plugin.loadPlugin();
+
+        return plugin;
+      }
+
+      return false;
+    },
+
+    hook: function (name) {
+      if (plugins[name] && plugins[name].length) {
+        var plugin = plugins[name];
+
+        plugin.map(function (plugin) {
+          if (typeof plugin.loadPlugin === 'function') plugin.loadPlugin();
+        });
+
+        return plugin;
+      }
+
+      return false;
+    }
+  };
+}
+
+module.exports = registerPluginLoader;

package/lib/commands/generated.js

@@ -0,0 +1,32 @@
+
+'use strict';
+
+const path = require('path');
+
+const files = {
+  "check": require('./check.js'),
+  "create-migration": require('./create-migration.js'),
+  "db": require('./db.js'),
+  "down": require('./down.js'),
+  "dump": require('./dump.js'),
+  "fn/plugin": require('./fn/plugin.js'),
+  "generated": require('./generated.js'),
+  "helper/assert": require('./helper/assert.js'),
+  "helper/load-config": require('./helper/load-config.js'),
+  "helper/migration-hook": require('./helper/migration-hook.js'),
+  "helper/register-events": require('./helper/register-events.js'),
+  "index": require('./index.js'),
+  "on-complete": require('./on-complete.js'),
+  "run": require('./run.js'),
+  "seed": require('./seed.js'),
+  "set-default-argv": require('./set-default-argv.js'),
+  "sync": require('./sync.js'),
+  "undo-seed": require('./undo-seed.js'),
+  "up": require('./up.js')
+}
+
+function register (module) {
+  return files[module];
+}
+
+module.exports = register;

package/lib/commands/helper/assert.js

@@ -0,0 +1,15 @@
+var assert = require('assert');
+
+module.exports = function (err, callback) {
+  if (err) {
+    if (typeof (callback) === 'function') {
+      callback(err);
+      return false;
+    } else {
+      assert.ifError(err);
+      return false;
+    }
+  }
+
+  return true;
+};

package/lib/commands/helper/load-config.js

@@ -0,0 +1,26 @@
+'use strict';
+
+var log = require('db-migrate-shared').log;
+
+function loadConfig (config, internals) {
+  var out;
+  var currentEnv = internals.currentEnv || internals.argv.env;
+
+  if (internals.configObject) {
+    out = config.loadObject(internals.configObject, currentEnv);
+  } else {
+    out = config.loadFile(internals.argv.config, currentEnv, internals.plugins);
+  }
+  if (internals.verbose) {
+    var current = out.getCurrent();
+    var s = JSON.parse(JSON.stringify(current.settings));
+
+    if (s.password) s.password = '******';
+
+    log.info('Using', current.env, 'settings:', s);
+  }
+
+  return out;
+}
+
+module.exports = loadConfig;

package/lib/commands/helper/migration-hook.js

@@ -0,0 +1,4 @@
+module.exports = function (internals) {
+  var Migration = require('../../file.js');
+  return Migration.registerHook(internals.plugins, internals);
+};

package/lib/commands/helper/register-events.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var log = require('db-migrate-shared').log;
+
+function registerEvents () {
+  process.on('uncaughtException', function (err) {
+    log.error('uncaughtException');
+    log.error(err.stack || err);
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', function (reason) {
+    log.error('unhandledRejection');
+    log.error(reason.stack || reason);
+    process.exit(1);
+  });
+}
+
+module.exports = registerEvents;

package/lib/commands/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var path = require('path');
+
+function register (module) {
+  return require(path.resolve(__dirname, module));
+}
+
+module.exports = register;

package/lib/commands/on-complete.js

@@ -0,0 +1,28 @@
+var assert = require('assert');
+var log = require('db-migrate-shared').log;
+
+const Promise = require('bluebird');
+
+module.exports = function (migrator, internals, originalErr, results) {
+  return Promise.fromCallback(callback => {
+    migrator.driver.close(function (err) {
+      if ((err || originalErr) && typeof callback === 'function') {
+        callback(originalErr || err);
+        return;
+      } else {
+        assert.ifError(originalErr);
+        assert.ifError(err);
+        log.info('Done');
+      }
+
+      if (internals.argv['force-exit']) {
+        log.verbose('Forcing exit');
+        return process.exit(0);
+      }
+
+      if (typeof callback === 'function') {
+        callback(null, results);
+      }
+    });
+  });
+};

package/lib/commands/run.js

@@ -0,0 +1,122 @@
+'use strict';
+
+var log = require('db-migrate-shared').log;
+var yargs = require('yargs');
+
+function run (internals, config) {
+  const { load } = internals;
+  var action = internals.argv._.shift();
+  var folder = action.split(':');
+
+  action = folder[0];
+
+  switch (action) {
+    case 'create':
+      if (folder[1]) {
+        internals.matching = folder[1];
+        internals.migrationMode = folder[1];
+      }
+      load('create-migration')(internals, config);
+      break;
+    case 'sync':
+      var executeSync = load('sync');
+
+      if (internals.argv._.length === 0) {
+        log.error('Missing sync destination!');
+        process.exit(1);
+      }
+
+      internals.argv.count = Number.MAX_VALUE;
+      internals.argv.destination = internals.argv._.shift().toString();
+
+      if (folder[1]) {
+        internals.matching = folder[1];
+        internals.migrationMode = folder[1];
+      }
+
+      executeSync(internals, config);
+      break;
+    case 'up':
+    case 'down':
+    case 'reset':
+      if (action === 'reset') internals.argv.count = Number.MAX_VALUE;
+
+      if (internals.argv._.length > 0) {
+        if (action === 'down') {
+          internals.argv.count = internals.argv.count || Number.MAX_VALUE;
+          internals.argv.destination = internals.argv._.shift().toString();
+        } else {
+          internals.argv.destination = internals.argv._.shift().toString();
+        }
+      }
+
+      if (folder[1]) {
+        internals.matching = folder[1];
+        internals.migrationMode = folder[1];
+      }
+
+      if (action === 'up') {
+        var executeUp = load('up');
+        executeUp(internals, config);
+      } else {
+        var executeDown = load('down');
+        executeDown(internals, config);
+      }
+      break;
+
+    case 'check':
+      var executeCheck = load('check');
+
+      if (folder[1]) {
+        internals.matching = folder[1];
+        internals.migrationMode = folder[1];
+      }
+
+      executeCheck(internals, config);
+      break;
+    case 'db':
+      if (folder.length < 1) {
+        log.info('Please enter a valid command, i.e. db:create|db:drop');
+      } else {
+        internals.mode = folder[1];
+        load('db')(internals, config);
+      }
+      break;
+    case 'seed':
+      internals.mode = folder[1] || 'vc';
+      internals.migrationMode = folder[2];
+
+      if (internals.argv._[0] === 'down' || internals.argv._[0] === 'reset') {
+        if (internals.argv._[0] === 'reset') {
+          internals.argv.count = Number.MAX_VALUE;
+        }
+
+        internals.argv._.shift();
+        load('undo-seed')(internals, config);
+      } else {
+        load('seed')(internals, config);
+      }
+      break;
+
+    default:
+      var plugins = internals.plugins;
+      var plugin = plugins.overwrite(
+        'run:default:action:' + action + ':overwrite'
+      );
+      if (plugin) {
+        plugin['run:default:action:' + action + ':overwrite'](
+          internals,
+          config
+        );
+      } else {
+        log.error(
+          'Invalid Action: Must be [up|down|check|create|reset|sync|db].'
+        );
+        yargs.showHelp();
+        process.exit(1);
+      }
+      break;
+  }
+}
+
+module.exports = run;

package/lib/commands/seed.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var assert = require('assert');
+var path = require('path');
+var _assert = require('./helper/assert');
+
+function executeSeed (internals, config, callback) {
+  var index = require('../../connect');
+  var Seeder = require('../walker.js');
+
+  if (internals.argv._.length > 0) {
+    internals.argv.destination = internals.argv._.shift().toString();
+  }
+
+  index.connect(
+    {
+      config: config.getCurrent().settings,
+      internals: internals,
+      prefix: 'seed'
+    },
+    Seeder,
+    function (err, seeder) {
+      assert.ifError(err);
+      var seedDir =
+        internals.mode !== 'static' ? 'vcseeder-dir' : 'staticseeder-dir';
+
+      seeder.seedDir = path.resolve(internals.argv[seedDir]);
+
+      if (internals.mode === 'static') {
+        seeder.seed(
+          internals.argv,
+          internals.onComplete.bind(this, seeder, internals, callback)
+        );
+      } else {
+        seeder.createSeedsTable(function (err) {
+          if (_assert(err, callback)) {
+            seeder.seed(
+              internals.argv,
+              internals.onComplete.bind(this, seeder, internals, callback)
+            );
+          }
+        });
+      }
+    }
+  );
+}
+
+module.exports = executeSeed;

package/lib/commands/set-default-argv.js

@@ -0,0 +1,169 @@
+var yargs = require('yargs');
+var log = require('db-migrate-shared').log;
+
+module.exports = function (internals, isModule) {
+  var rc = require('rc');
+  var deepExtend = require('deep-extend');
+  var defaultConfig = {
+    verbose: false,
+    state: 'migrations_state',
+    table: 'migrations',
+    'seeds-table': 'seeds',
+    'force-exit': false,
+    'sql-file': false,
+    'non-transactional': false,
+    config: internals.configFile || internals.cwd + '/database.json',
+    'migrations-dir': internals.cwd + '/migrations',
+    'vcseeder-dir': internals.cwd + '/VCSeeder',
+    'staticseeder-dir': internals.cwd + '/Seeder',
+    'ignore-completed-migrations': false
+  };
+
+  if (!isModule) {
+    internals.argv = yargs
+      .default(defaultConfig)
+      .usage(
+        'Usage: db-migrate [up|down|check|reset|sync|create|db] ' +
+          '[[dbname/]migrationName|all] [options]'
+      )
+      .describe(
+        'env',
+        'The environment to run the migrations under (dev, test, prod).'
+      )
+      .alias('e', 'env')
+      .string('e')
+      .describe(
+        'migrations-dir',
+        'The directory containing your migration files.'
+      )
+      .alias('m', 'migrations-dir')
+      .string('m')
+      .describe('count', 'Max number of migrations to run.')
+      .alias('c', 'count')
+      .string('c')
+      .describe('dry-run', "Prints the SQL but doesn't run it.")
+      .boolean('dry-run')
+      .describe(
+        'check',
+        'Prints the migrations to be run without running them.'
+      )
+      .boolean('check')
+      .describe(
+        'force-exit',
+        'Forcibly exit the migration process on completion.'
+      )
+      .boolean('force-exit')
+      .describe('verbose', 'Verbose mode.')
+      .alias('v', 'verbose')
+      .boolean('v')
+      .alias('h', 'help')
+      .alias('h', '?')
+      .boolean('h')
+      .describe('version', 'Print version info.')
+      .alias('i', 'version')
+      .boolean('version')
+      .describe('config', 'Location of the database.json file.')
+      .string('config')
+      .describe('v2-file', 'Create v2 schema migration')
+      .boolean('v2-file')
+      .describe(
+        'sql-file',
+        'Automatically create two sql files for up and down statements in ' +
+          '/sqls and generate the javascript code that loads them.'
+      )
+      .boolean('sql-file')
+      .describe('coffee-file', 'Create a coffeescript migration file')
+      .boolean('coffee-file')
+      .describe(
+        'ignore-on-init',
+        'Create files that will run only if ignore-on-init in the env is set ' +
+          'to false (currently works only with SQL)'
+      )
+      .boolean('ignore-on-init')
+      .describe(
+        'migration-table',
+        'Set the name of the migration table, which stores the migration history.'
+      )
+      .alias('table', 'migration-table')
+      .alias('t', 'table')
+      .string('t')
+      .describe(
+        'seeds-table',
+        'Set the name of the seeds table, which stores the seed history.'
+      )
+      .describe(
+        'state-table',
+        'Set the name of the migration state table, which stores the migration' +
+          ' state to coordinate concurrency and advanced features.'
+      )
+      .alias('state', 'state-table')
+      .alias('s', 'state')
+      .string('s')
+      .string('seeds-table')
+      .describe(
+        'vcseeder-dir',
+        'Set the path to the Version Controlled Seeder directory.'
+      )
+      .string('vcseeder-dir')
+      .describe('staticseeder-dir', 'Set the path to the Seeder directory.')
+      .string('staticseeder-dir')
+      .describe('non-transactional', 'Explicitly disable transactions')
+      .boolean('non-transactional')
+      .describe('ignore-completed-migrations', 'Start at the first migration')
+      .boolean('ignore-completed-migrations')
+      .describe('log-level', 'Set the log-level, for example sql|warn')
+      .string('log-level')
+      .parse();
+  } else {
+    internals.argv = Object.assign(defaultConfig, internals.cmdOptions);
+  }
+
+  var plugins = internals.plugins;
+  var plugin = plugins.hook('init:cli:config:hook');
+  var _config = internals.argv.config;
+
+  if (plugin) {
+    plugin.forEach(function (plugin) {
+      // var configs = plugin['init:cli:config:hook']();
+      // if (!configs) return;
+      // hook not yet used, we look into migrating away from yargs first
+    });
+  }
+
+  internals.argv = deepExtend(internals.argv, rc('db-migrate', {}));
+  internals.argv.rcconfig = internals.argv.config;
+  internals.argv.config = internals.argv.configFile || _config;
+
+  if (internals.argv.version) {
+    console.log(internals.dbm.version);
+    process.exit(0);
+  }
+
+  if (!isModule && (internals.argv.help || internals.argv._.length === 0)) {
+    yargs.showHelp();
+    process.exit(1);
+  }
+
+  if (internals.argv['log-level']) {
+    log.setLogLevel(internals.argv['log-level']);
+  }
+
+  internals.ignoreCompleted = internals.argv['ignore-completed-migrations'];
+  internals.migrationTable = internals.argv.table;
+  internals.migrationState = internals.argv.state;
+  internals.seedTable = internals.argv['seeds-table'];
+  internals.matching = '';
+  internals.verbose = internals.argv.verbose;
+  global.verbose = internals.verbose;
+  internals.notransactions = internals.argv['non-transactional'];
+  internals.dryRun = internals.argv['dry-run'];
+  global.dryRun = internals.dryRun;
+  internals.check = internals.argv.check;
+
+  if (internals.dryRun) {
+    log.info('dry run');
+  }
+  if (internals.check) {
+    log.info('check');
+  }
+};