db-migrate 1.0.0-beta.16

package/api.js

@@ -0,0 +1,463 @@
+'use strict';
+
+module.exports.version = require('./package.json').version;
+
+let load;
+var log = require('db-migrate-shared').log;
+var Promise;
+let onComplete;
+var config = require('rc')('db-migrate');
+
+// constant hooks for this file
+var APIHooks = {
+  'init:api:addfunction:hook': function (name, fn) {
+    this[name] = fn;
+  },
+  'init:api:accessapi:hook': function (cb) {
+    return this;
+  }
+};
+
+function dbmigrate (plugins, isModule, options, callback) {
+  if (!options.staticLoader) load = require('./lib/commands');
+  else load = require('./lib/commands/generated.js');
+
+  onComplete = load('on-complete');
+
+  var dotenv = require('dotenv');
+  var setDefaultArgv = load('set-default-argv');
+
+  this.internals = {
+    onComplete: onComplete,
+    migrationProtocol: 1,
+    load
+  };
+  if (typeof isModule !== 'function') {
+    this.internals.isModule = isModule;
+  }
+  var internals = this.internals;
+
+  this.internals.plugins = load('fn/plugin')(plugins);
+
+  if (typeof callback === 'function') this.internals.onComplete = callback;
+  else if (typeof options === 'function') this.internals.onComplete = options;
+
+  this.internals.dbm = require('./');
+  this.dataType = this.internals.dbm.dataType;
+  this.version = this.internals.dbm.version;
+
+  var dotenvConfig = { silent: true };
+  if (config.dotenvCustomPath) {
+    dotenvConfig.path = config.dotenvCustomPath;
+  }
+  dotenv.load(dotenvConfig);
+
+  /* $lab:coverage:off$ */
+  if (!options || !options.throwUncatched) load('helper/register-events')();
+  /* $lab:coverage:on$ */
+
+  if (typeof options === 'object') {
+    if (typeof options.config === 'string') {
+      internals.configFile = options.config;
+    } else if (typeof options.config === 'object') {
+      internals.configObject = options.config;
+    }
+
+    if (typeof options.env === 'string') internals.currentEnv = options.env;
+
+    if (typeof options.cwd === 'string') internals.cwd = options.cwd;
+    else internals.cwd = process.cwd();
+
+    if (typeof options.cmdOptions === 'object') {
+      internals.cmdOptions = options.cmdOptions;
+    }
+  } else internals.cwd = process.cwd();
+
+  if (typeof isModule === 'function') {
+    this.internals.onComplete = isModule;
+    setDefaultArgv(this.internals);
+  } else setDefaultArgv(this.internals, isModule);
+
+  this.config = load('helper/load-config')(
+    require('./lib/config.js'),
+    this.internals
+  );
+
+  // delayed loading of bluebird
+  Promise = require('bluebird');
+  this.internals.migrationOptions = {
+    dbmigrate: {
+      version: this.internals.dbm.version,
+      dataType: this.internals.dbm.dataType
+    },
+    dryRun: this.internals.dryRun,
+    cwd: this.internals.cwd,
+    noTransactions: this.internals.notransactions,
+    verbose: this.internals.verbose,
+    type: this.internals.dbm.dataType,
+    log: log,
+    ignoreOnInit: this.internals.argv['ignore-on-init'],
+    Promise: Promise
+  };
+  this.internals.safeOptions = this.internals.migrationOptions;
+}
+
+dbmigrate.prototype = {
+  /**
+   * Add a global defined variable to db-migrate, to enable access from
+   * local migrations without configuring pathes.
+   *
+   * @return boolean
+   */
+  addGlobal: function (library) {
+    try {
+      require(library);
+    } catch (e) {
+      return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Registers and initializes hooks.
+   *
+   * @returns Promise
+   */
+  registerAPIHook: function (callback) {
+    var plugins = this.internals.plugins;
+    var self = this;
+
+    return Promise.resolve(Object.keys(APIHooks))
+      .each(function (hook) {
+        var plugin = plugins.hook(hook);
+        if (!plugin) return;
+
+        var APIHook = APIHooks[hook].bind(self);
+
+        return Promise.resolve(plugin)
+          .map(function (plugin) {
+            return plugin[hook]();
+          })
+          .each(function (args) {
+            return APIHook.apply(self, args);
+          });
+      })
+      .asCallback(callback);
+  },
+
+  _internals: this.internals,
+
+  /**
+   * Add a configuration option to dbmigrate.
+   *
+   * @return boolean
+   */
+  addConfiguration: function (description, args, type) {
+    var name = args.shift();
+    this.internals.argv.describe(name, description);
+
+    for (var i = 0; i < args.length; ++i) {
+      this.internals.argv.alias(args[i], name);
+    }
+
+    switch (type) {
+      case 'string':
+        this.internals.argv.string(name);
+        break;
+
+      case 'boolean':
+        this.internals.argv.boolean(name);
+        break;
+
+      default:
+        return false;
+    }
+
+    return true;
+  },
+
+  /**
+   * Resets and sets argv to a specified new argv.
+   */
+  resetConfiguration: function (argv) {
+    this.internals.argv = argv;
+  },
+
+  /**
+   * Executes up a given number of migrations or a specific one.
+   *
+   * Defaults to up all migrations if no count is given.
+   */
+  up: function (specification, opts, callback) {
+    var executeUp = load('up');
+
+    if (arguments.length > 0) {
+      if (typeof specification === 'string') {
+        this.internals.argv.destination = specification;
+      } else if (typeof specification === 'number') {
+        this.internals.argv.count = specification;
+      } else if (typeof specification === 'function') {
+        callback = specification;
+      }
+
+      if (typeof opts === 'string') {
+        this.internals.migrationMode = opts;
+        this.internals.matching = opts;
+      } else if (typeof opts === 'function') {
+        callback = opts;
+      }
+    }
+
+    return Promise.resolve(executeUp(this.internals, this.config)).nodeify(
+      callback
+    );
+  },
+
+  /**
+   * Executes up a given number of migrations or a specific one.
+   *
+   * Defaults to up all migrations if no count is given.
+   */
+  down: function (specification, opts, callback) {
+    var executeDown = load('down');
+
+    if (arguments.length > 0) {
+      if (typeof specification === 'number') {
+        this.internals.argv.count = arguments[0];
+      } else if (typeof specification === 'string') {
+        this.internals.argv.destination = specification;
+        this.internals.argv.count = Number.MAX_VALUE;
+      } else if (typeof specification === 'function') {
+        callback = specification;
+      }
+
+      if (typeof opts === 'string') {
+        this.internals.migrationMode = opts;
+        this.internals.matching = opts;
+      } else if (typeof opts === 'function') {
+        callback = opts;
+      }
+    }
+
+    return Promise.resolve(executeDown(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  check: function (specification, opts, callback) {
+    var executeCheck = load('check');
+
+    if (arguments.length > 0) {
+      if (typeof specification === 'number') {
+        this.internals.argv.count = arguments[0];
+      } else if (typeof specification === 'function') {
+        callback = specification;
+      }
+
+      if (typeof opts === 'string') {
+        this.internals.migrationMode = opts;
+        this.internals.matching = opts;
+      } else if (typeof opts === 'function') {
+        callback = opts;
+      }
+    }
+
+    return Promise.resolve(
+      executeCheck(this.internals, this.config)
+    ).asCallback(callback);
+  },
+
+  /**
+   * Executes up a given number of migrations or a specific one.
+   *
+   * Defaults to up all migrations if no count is given.
+   */
+  sync: function (specification, opts, callback) {
+    var executeSync = load('sync');
+
+    if (arguments.length > 0) {
+      if (typeof specification === 'string') {
+        this.internals.argv.destination = specification;
+      }
+
+      if (typeof opts === 'string') {
+        this.internals.migrationMode = opts;
+        this.internals.matching = opts;
+      } else if (typeof opts === 'function') {
+        callback = opts;
+      }
+    }
+
+    return Promise.resolve(executeSync(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  /**
+   * Executes down for all currently migrated migrations.
+   */
+  reset: function (scope, callback) {
+    var executeDown = load('down');
+
+    if (typeof scope === 'string') {
+      this.internals.migrationMode = scope;
+      this.internals.matching = scope;
+    } else if (typeof scope === 'function') {
+      callback = scope;
+    }
+
+    this.internals.argv.count = Number.MAX_VALUE;
+    return Promise.resolve(executeDown(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  /**
+   * Silence the log output completely.
+   */
+  silence: function (isSilent) {
+    return log.silence(isSilent);
+  },
+
+  /**
+   * Creates a correctly formatted migration
+   */
+  create: function (migrationName, scope, callback) {
+    var executeCreateMigration = load('create-migration');
+    if (typeof scope === 'function') {
+      callback = scope;
+    } else if (scope) {
+      this.internals.migrationMode = scope;
+      this.internals.matching = scope;
+    }
+
+    this.internals.argv._.unshift(migrationName);
+    return Promise.resolve(
+      executeCreateMigration(this.internals, this.config)
+    ).asCallback(callback);
+  },
+
+  /**
+   * Creates a database of the given dbname.
+   */
+  createDatabase: function (dbname, callback) {
+    var executeDB = load('db');
+    this.internals.argv._.push(dbname);
+    this.internals.mode = 'create';
+    return Promise.resolve(executeDB(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  /**
+   * Drops a database of the given dbname.
+   */
+  dropDatabase: function (dbname, callback) {
+    var executeDB = load('db');
+    this.internals.argv._.push(dbname);
+    this.internals.mode = 'drop';
+    return Promise.resolve(executeDB(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  /**
+   * Sets a config variable to the given value.
+   *
+   * @return value
+   */
+  setConfigParam: function (param, value) {
+    return (this.internals.argv[param] = value);
+  },
+
+  /**
+   * Sets the callback to the default onComplete
+   */
+  setDefaultCallback: function () {
+    this.internals.onComplete = onComplete;
+  },
+
+  /**
+   * Let's the user customize the callback, which gets called after all
+   * migrations have been done.
+   */
+  setCustomCallback: function (callback) {
+    this.internals.onComplete = callback;
+  },
+
+  /**
+   * Seeds either the static or version controlled seeders, controlled by
+   * the passed mode.
+   */
+  seed: function (mode, scope, callback) {
+    var executeSeed = load('seed');
+    if (scope) {
+      this.internals.migrationMode = scope;
+      this.internals.matching = scope;
+    }
+
+    this.internals.mode = mode || 'vc';
+    return Promise.resolve(executeSeed(this.internals, this.config)).asCallback(
+      callback
+    );
+  },
+
+  /**
+   * Execute the down function of currently executed seeds.
+   */
+  undoSeed: function (specification, scope, callback) {
+    var executeUndoSeed = load('undo-seed');
+    if (arguments.length > 0) {
+      if (typeof specification === 'number') {
+        this.internals.argv.count = specification;
+
+        if (scope) {
+          this.internals.migrationMode = scope;
+          this.internals.matching = scope;
+        }
+      } else if (typeof specification === 'string') {
+        this.internals.migrationMode = scope;
+        this.internals.matching = scope;
+      }
+    }
+
+    return Promise.resolve(
+      executeUndoSeed(this.internals, this.config)
+    ).asCallback(callback);
+  },
+
+  /**
+   * Execute the reset function of currently executed seeds.
+   */
+  resetSeed: function (specification, scope, callback) {
+    var executeUndoSeed = load('undo-seed');
+    if (arguments.length > 0) {
+      if (typeof specification === 'number') {
+        this.internals.argv.count = specification;
+
+        if (scope) {
+          this.internals.migrationMode = scope;
+          this.internals.matching = scope;
+        }
+      } else if (typeof specification === 'string') {
+        this.internals.migrationMode = scope;
+        this.internals.matching = scope;
+      }
+    }
+
+    this.internals.argv.count = Number.MAX_VALUE;
+    return Promise.resolve(
+      executeUndoSeed(this.internals, this.config)
+    ).asCallback(callback);
+  },
+
+  /**
+   * Executes the default routine.
+   */
+  run: function () {
+    load('run')(this.internals, this.config);
+  }
+};
+
+module.exports = dbmigrate;

package/bin/db-migrate

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+var resolve = require('resolve');
+var log = require('db-migrate-shared').log;
+
+process.title = 'db-migrate';
+if (process.argv.indexOf('--verbose') !== -1 ||
+     process.argv.indexOf('-v') !== -1
+) { global.verbose = true; }
+
+resolve('db-migrate', {
+
+  basedir: process.cwd()
+}, function (error, localModule) {
+  var DBMigrate, dbmigrate;
+
+  if (error) {
+    DBMigrate = require('../');
+  } else {
+    DBMigrate = require(localModule);
+    log.verbose('Detected and using the projects local version of db-migrate. ' +
+      '\'' + localModule + '\'');
+  }
+
+  if (typeof (DBMigrate.getInstance) !== 'function') {
+    DBMigrate = require('../');
+
+    log.warn('Using global instead of local detected version as you have a ' +
+      'version older than 0.10.0 in your projects package.json!');
+  }
+
+  dbmigrate = DBMigrate.getInstance();
+  if (dbmigrate.registerAPIHook) {
+    dbmigrate.registerAPIHook()
+      .then(function () {
+        dbmigrate.run();
+      });
+  } else { dbmigrate.run(); }
+});

package/connect.js

@@ -0,0 +1,198 @@
+/**
+ * This file is going to disappear.
+ * Only still here for backwards compatibility.
+ * */
+var recursive = require('final-fs').readdirRecursive;
+var fs = require('fs');
+var driver = require('./lib/driver');
+var path = require('path');
+var log = require('db-migrate-shared').log;
+const Promise = require('bluebird');
+
+exports.connect = function (config, PassedClass) {
+  var internals = {};
+  var prefix = 'migration';
+  if (config.config) {
+    prefix = config.prefix || prefix;
+    internals = config.internals;
+    config = config.config;
+  }
+
+  return Promise.fromCallback(callback => {
+    driver.connect(config, internals, function (err, db) {
+      if (err) {
+        callback(err);
+        return;
+      }
+
+      var dirPath = path.resolve(
+        internals.argv['migrations-dir'] || 'migrations'
+      );
+      if (internals.migrationMode) {
+        if (internals.migrationMode !== 'all') {
+          var switched = false;
+          var newConf;
+
+          try {
+            newConf = require(path.resolve(
+              internals.argv['migrations-dir'] || 'migrations',
+              internals.migrationMode
+            ) + '/config.json');
+            log.info(
+              'loaded extra config for migration subfolder: "' +
+                internals.migrationMode +
+                '/config.json"'
+            );
+            switched = true;
+          } catch (e) {}
+
+          if (switched) {
+            db.switchDatabase(newConf, function (err) {
+              if (err) {
+                return callback(err);
+              }
+              internals.locTitle = internals.migrationMode;
+              callback(
+                null,
+                new PassedClass(
+                  db,
+                  dirPath,
+                  internals.mode !== 'static',
+                  internals,
+                  prefix
+                )
+              );
+            });
+          } else {
+            internals.locTitle = internals.migrationMode;
+            callback(
+              null,
+              new PassedClass(
+                db,
+                dirPath,
+                internals.mode !== 'static',
+                internals,
+                prefix
+              )
+            );
+          }
+        } else {
+          recursive(
+            dirPath,
+            false,
+            internals.argv['migrations-dir'] || 'migrations'
+          ).then(function (files) {
+            var oldClose = db.close;
+
+            files = files.filter(function (file) {
+              return file !== 'migrations' && fs.statSync(file).isDirectory();
+            });
+
+            files.push('');
+
+            db.close = function (cb) {
+              migrationFiles(
+                files,
+                callback,
+                config,
+                internals,
+                PassedClass,
+                db,
+                oldClose,
+                prefix,
+                cb
+              );
+            };
+
+            db.close();
+          });
+        }
+      } else {
+        callback(
+          null,
+          new PassedClass(
+            db,
+            dirPath,
+            internals.mode !== 'static',
+            internals,
+            prefix
+          )
+        );
+      }
+    });
+  });
+};
+
+exports.driver = function (config, callback) {
+  var internals = {};
+  if (config.config) {
+    internals = config.internals;
+    config = config.config;
+  }
+
+  driver.connect(config, internals, callback);
+};
+
+function migrationFiles (
+  files,
+  callback,
+  config,
+  internals,
+  PassedClass,
+  db,
+  close,
+  prefix,
+  cb
+) {
+  var file;
+  var switched = false;
+  var newConf;
+
+  if (files.length === 1) {
+    db.close = close;
+  }
+
+  file = files.pop();
+  log.info('Enter scope "' + (file !== '' ? file : '/') + '"');
+
+  if (file !== '') {
+    try {
+      fs.statSync(path.resolve(file + '/config.json'));
+      newConf = require(path.resolve(file + '/config.json'));
+      log.info(
+        'loaded extra config for migration subfolder: "' +
+          file +
+          '/config.json"'
+      );
+      switched = true;
+    } catch (e) {}
+  }
+
+  db.switchDatabase(switched ? newConf : config.database, function () {
+    internals.matching = file.substr(
+      file.indexOf(internals.argv['migrations-dir'] || 'migrations') +
+        (internals.argv['migrations-dir'] || 'migrations').length +
+        1
+    );
+
+    if (internals.matching.length === 0) {
+      internals.matching = '';
+    }
+
+    internals.locTitle = internals.matching;
+    callback(
+      null,
+      new PassedClass(
+        db,
+        internals.argv['migrations-dir'],
+        internals.mode !== 'static',
+        internals,
+        prefix
+      )
+    );
+
+    if (typeof cb === 'function') {
+      cb();
+    }
+  });
+}