db-migrate 1.0.0-beta.16

package/lib/commands/sync.js

@@ -0,0 +1,52 @@
+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) {
+      internals.argv.count = Number.MAX_VALUE;
+    }
+    const migrator = await index.connect(
+      {
+        config: config.getCurrent().settings,
+        internals: internals,
+        prefix: 'migration'
+      },
+      Migrator
+    );
+
+    if (internals.locTitle) {
+      migrator.migrationsDir = path.resolve(
+        internals.argv['migrations-dir'],
+        internals.locTitle
+      );
+    } else {
+      migrator.migrationsDir = path.resolve(internals.argv['migrations-dir']);
+    }
+
+    internals.migrationsDir = migrator.migrationsDir;
+
+    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.sync(internals.argv);
+    return internals.onComplete(migrator, internals, null, res);
+  } catch (err) {
+    return internals.onComplete(migrator, internals, err);
+  }
+};

package/lib/commands/undo-seed.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var assert = require('assert');
+var path = require('path');
+var log = require('db-migrate-shared').log;
+var _assert = require('./helper/assert');
+
+function executeUndoSeed (internals, config, callback) {
+  var index = require('./connect');
+  var Seeder = require('./lib/walker.js');
+
+  if (!internals.argv.count) {
+    log.info('Defaulting to running 1 down seed.');
+    internals.argv.count = 1;
+  }
+
+  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') {
+        internals.onComplete(seeder, callback, {
+          stack: "Static seeders can't be undone. Use VC Seeders instead!"
+        });
+      } else {
+        seeder.createSeedsTable(function (err) {
+          if (_assert(err, callback)) {
+            seeder.down(
+              internals.argv,
+              internals.onComplete.bind(this, seeder, internals, callback)
+            );
+          }
+        });
+      }
+    }
+  );
+}
+
+module.exports = executeUndoSeed;

package/lib/commands/up.js

@@ -0,0 +1,52 @@
+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) {
+      internals.argv.count = Number.MAX_VALUE;
+    }
+    const migrator = await index.connect(
+      {
+        config: config.getCurrent().settings,
+        internals: internals,
+        prefix: 'migration'
+      },
+      Migrator
+    );
+
+    if (internals.locTitle) {
+      migrator.migrationsDir = path.resolve(
+        internals.argv['migrations-dir'],
+        internals.locTitle
+      );
+    } else {
+      migrator.migrationsDir = path.resolve(internals.argv['migrations-dir']);
+    }
+
+    internals.migrationsDir = migrator.migrationsDir;
+
+    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.up(internals.argv);
+    return internals.onComplete(migrator, internals, null, res);
+  } catch (err) {
+    return internals.onComplete(migrator, internals, err);
+  }
+};

package/lib/config.js

@@ -0,0 +1,207 @@
+var fs = require('fs');
+var path = require('path');
+var parseDatabaseUrl = require('parse-database-url');
+var dbmUtil = require('db-migrate-shared').util;
+var log = require('db-migrate-shared').log;
+
+var setCurrent = (exports.setCurrent = function (env) {
+  env = dbmUtil.isArray(env) ? env : [env];
+  env.forEach(
+    function (current) {
+      if (dbmUtil.isString(current) && this[current]) {
+        this.getCurrent = function () {
+          return {
+            env: current,
+            settings: this[current]
+          };
+        };
+      }
+    }.bind(this)
+  );
+
+  if (!this.getCurrent) {
+    throw new Error("Environment(s) '" + env.join(', ') + "' not found.");
+  }
+});
+
+function Config () {}
+
+Config.prototype = {
+  setCurrent: setCurrent
+};
+
+exports.load = function (config, currentEnv) {
+  if (typeof config === 'object') {
+    return exports.loadObject(config, currentEnv);
+  } else {
+    return exports.loadFile(config, currentEnv);
+  }
+};
+
+exports.loadFile = function (fileName, currentEnv, plugins) {
+  var config;
+
+  try {
+    fs.statSync(fileName);
+  } catch (e) {
+    if (!process.env.DATABASE_URL) {
+      throw new Error("Could not find database config file '" + fileName + "'");
+    } else {
+      return exports.loadUrl(process.env.DATABASE_URL, currentEnv);
+    }
+  }
+
+  try {
+    var plugin = false;
+
+    if (plugins) {
+      plugin = plugins.overwrite('init:config:overwrite:require');
+    }
+
+    if (plugin !== false) {
+      try {
+        config = plugin['init:config:overwrite:require'](fileName);
+      } catch (ex) {
+        log.warn(
+          'Plugin failure "' +
+            plugin.name +
+            '", falling back to default behavior!'
+        );
+        log.verbose(ex);
+
+        config = require(fileName);
+      }
+    } else {
+      config = require(fileName);
+    }
+  } catch (e) {
+    // distinguish broken files from missing ones
+    if (e instanceof SyntaxError) {
+      throw e;
+    }
+
+    try {
+      config = require(path.join(process.cwd(), fileName));
+    } catch (e) {
+      if (!process.env.DATABASE_URL) {
+        throw e;
+      } else {
+        return exports.loadUrl(process.env.DATABASE_URL, currentEnv);
+      }
+    }
+  }
+
+  return exports.loadObject(config, currentEnv);
+};
+
+function walkConfig (level) {
+  for (var configEntry in level) {
+    if (level[configEntry] && level[configEntry].ENV) {
+      if (!process.env[level[configEntry].ENV]) {
+        log.verbose(
+          'Environment variable ' + level[configEntry].ENV + ' is empty!'
+        );
+      }
+
+      level[configEntry] = process.env[level[configEntry].ENV];
+    } else if (level[configEntry] && typeof level[configEntry] === 'object') {
+      level[configEntry] = walkConfig(level[configEntry]);
+    }
+  }
+
+  return level;
+}
+
+exports.loadObject = function (_config, currentEnv) {
+  var out = new Config();
+  // do not overwrite the users config
+  var config = JSON.parse(JSON.stringify(_config));
+
+  for (var env in config) {
+    if (config[env].ENV) {
+      if (!process.env[config[env].ENV]) {
+        log.verbose('Environment variable ' + config[env].ENV + ' is empty!');
+      } else {
+        out[env] = parseDatabaseUrl(process.env[config[env].ENV]);
+      }
+    } else if (typeof config[env] === 'string') {
+      out[env] = parseDatabaseUrl(config[env]);
+    } else {
+      // Check config entry's for ENV objects
+      // which will tell us to grab configuration from the environment
+      config[env] = walkConfig(config[env]);
+      out[env] = config[env];
+    }
+
+    if (typeof config[env].url === 'string' || process.env.DATABASE_URL) {
+      if (typeof config[env].url !== 'string') {
+        config[env] = Object.assign(
+          config[env],
+          parseDatabaseUrl(process.env.DATABASE_URL)
+        );
+      } else {
+        config[env] = Object.assign(
+          config[env],
+          parseDatabaseUrl(config[env].url)
+        );
+      }
+      delete config[env].url;
+    } else if (config[env].url && config[env].url.value) {
+      config[env].url = config[env].url.value;
+    }
+
+    if (config[env].overwrite || config[env].addIfNotExists) {
+      var overwrite = config[env].overwrite || {};
+
+      if (config[env].addIfNotExists) {
+        var addIfNotExists = config[env].addIfNotExists;
+        Object.keys(addIfNotExists)
+          .filter(function (key) {
+            return !overwrite[key] && !config[env][key];
+          })
+          .forEach(function (key) {
+            config[env][key] = addIfNotExists[key];
+          });
+
+        delete config[env].addIfNotExists;
+      }
+
+      Object.keys(overwrite).forEach(function (key) {
+        config[env][key] = overwrite[key];
+      });
+
+      delete config[env].overwrite;
+    }
+  }
+
+  if (currentEnv) {
+    out.setCurrent(currentEnv);
+  } else if (config.default) {
+    out.setCurrent(config.default);
+  } else if (config.defaultEnv) {
+    if (config.defaultEnv.ENV) {
+      out.setCurrent(process.env[config.defaultEnv.ENV]);
+    } else {
+      out.setCurrent(config.defaultEnv);
+    }
+  } else {
+    out.setCurrent(['dev', 'development']);
+  }
+
+  return out;
+};
+
+exports.loadUrl = function (databaseUrl, currentEnv) {
+  var config = parseDatabaseUrl(databaseUrl);
+  var out = new Config();
+
+  if (currentEnv) {
+    out[currentEnv] = config;
+    out.setCurrent(currentEnv);
+  } else {
+    out.urlConfig = config;
+    out.setCurrent('urlConfig');
+  }
+
+  return out;
+};

package/lib/driver/index.js

@@ -0,0 +1,156 @@
+var internals = {};
+
+internals.mod = {};
+internals.mod.log = require('db-migrate-shared').log;
+internals.mod.type = require('db-migrate-shared').dataType;
+var Shadow = require('./shadow');
+var log = internals.mod.log;
+var Promise = require('bluebird');
+var SeederInterface = require('../interface/seederInterface.js');
+var MigratorInterface = require('../interface/migratorInterface.js');
+var resolve = require('resolve');
+
+var ShadowProto = {
+  createTable: function () {
+    return Promise.resolve();
+  }
+};
+
+exports.connect = function (config, intern, callback) {
+  var driver, req;
+  let plugin = false;
+  const { plugins } = intern;
+
+  var mod = internals.mod;
+  internals = intern;
+  internals.mod = mod;
+
+  // add interface extensions to allow drivers to add new methods
+  internals.interfaces = {
+    SeederInterface: SeederInterface.extending,
+    MigratorInterface: MigratorInterface.extending
+  };
+
+  if (!config.user && config.username) {
+    config.user = config.username;
+  }
+
+  if (config.driver === undefined) {
+    throw new Error(
+      'config must include a driver key specifing which driver to use'
+    );
+  }
+
+  if (config.driver && typeof config.driver === 'object') {
+    log.verbose('require:', config.driver.require);
+    driver = require(config.driver.require);
+  } else {
+    switch (config.driver) {
+      case 'sqlite':
+        config.driver = 'sqlite3';
+        break;
+
+      case 'postgres':
+      case 'postgresql':
+        config.driver = 'pg';
+        break;
+    }
+
+    try {
+      req = 'db-migrate-' + config.driver;
+      log.verbose('require:', req);
+      try {
+        driver = require(resolve.sync(req, { basedir: process.cwd() }));
+      } catch (e1) {
+        try {
+          driver = require(req);
+        } catch (e2) {
+          driver = require('../../../' + req);
+        }
+      }
+    } catch (e3) {
+      try {
+        // Fallback to internal drivers, while moving drivers to new repos
+        req = './' + config.driver;
+        log.verbose('require:', req);
+        driver = require(req);
+      } catch (e4) {
+        return callback(
+          new Error(
+            'No such driver found, please try to install it via ' +
+              'npm install db-migrate-' +
+              config.driver +
+              ' or ' +
+              'npm install -g db-migrate-' +
+              config.driver
+          )
+        );
+      }
+    }
+  }
+
+  log.verbose('connecting');
+
+  var connect = function (config) {
+    driver.connect(config, intern, function (err, db) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      log.verbose('connected');
+
+      if (!global.immunity) {
+        db = Shadow.infect(db, internals, ShadowProto);
+      }
+
+      callback(null, db);
+    });
+  };
+
+  if (config.tunnel) {
+    var tunnel = require('tunnel-ssh');
+    var tunnelConfig = JSON.parse(JSON.stringify(config.tunnel));
+    const { tunnelType } = tunnelConfig;
+
+    if (plugins) {
+      plugin = plugins.overwrite(
+        `connection:tunnel:${
+          tunnelType && tunnelType !== 'ssh' ? tunnelType : 'ssh'
+        }`
+      );
+    }
+
+    tunnelConfig.dstHost = config.host;
+    tunnelConfig.dstPort = config.port;
+
+    if (plugin) {
+      tunnel = plugin[
+        `connection:tunnel:${
+          tunnelType && tunnelType !== 'ssh' ? tunnelType : 'ssh'
+        }`
+      ](tunnelConfig);
+    }
+
+    if (tunnelConfig.privateKeyPath) {
+      tunnelConfig.privateKey = require('fs').readFileSync(
+        tunnelConfig.privateKeyPath
+      );
+    }
+
+    // Reassign the db host/port to point to our local ssh tunnel
+    config.host = '127.0.0.1';
+    config.port = tunnelConfig.localPort;
+
+    tunnel(tunnelConfig, function (err) {
+      if (err) {
+        callback(err);
+        return;
+      }
+      log.verbose('SSH tunnel connected on port ', tunnelConfig.localPort);
+
+      connect(config);
+    });
+  } else {
+    connect(config);
+  }
+};

package/lib/driver/shadow.js

@@ -0,0 +1,74 @@
+/**
+ * The shadow driver is basically a MITM object. Or in other words:
+ *
+ * This shadow is very infectius. It infects other objects and overwrite their
+ * behavior. It gets a shadow part of this object and executes various
+ * actions.
+ *
+ * In our case, it records the execution of methods.
+ */
+
+/**
+ * 'Infect' the original class
+ */
+exports.infect = function (db, intern, ShadowProto) {
+  const newDb = {};
+  if (db._shadowsHost || db._shadowProto) {
+    throw new Error("Can't shadow a shadow!");
+  }
+  newDb._shadowsHost = {};
+  newDb._shadowProto = {};
+
+  for (var prop in db) {
+    if (
+      typeof ShadowProto[prop] === 'function' &&
+      typeof db[prop] === 'function'
+    ) {
+      newDb._shadowsHost[prop] = db[prop];
+      newDb._shadowProto[prop] = ShadowProto[prop];
+
+      (function (property) {
+        newDb[property] = function () {
+          var params = arguments;
+          var self = this;
+
+          return self._shadowProto[property]
+            .apply(self, params)
+            .then(function () {
+              return self._shadowsHost[property].apply(self, params);
+            });
+        };
+      })(prop);
+    } else {
+      newDb[prop] = db[prop];
+    }
+  }
+
+  return newDb;
+};
+
+/**
+ * 'Overshadow' the original class
+ *
+ * This basically overwrites methods existent from the original
+ * with a provided replacement. If no replacement was found, it will overwrite
+ * with an error instead, which needs to be supplied as a fallback.
+ */
+
+exports.overshadow = function (db, ShadowProto, ShadowError) {
+  const newDb = Object.assign({}, ShadowProto);
+  newDb.prototype = Object.assign({}, ShadowProto.prototype);
+
+  for (var prop in db) {
+    if (
+      typeof ShadowProto[prop] === 'function' &&
+      typeof db[prop] === 'function'
+    ) {
+      newDb[prop] = ShadowProto[prop];
+    } else if (typeof db[prop] === 'function') {
+      newDb[prop] = ShadowError(prop);
+    }
+  }
+
+  return newDb;
+};

package/lib/executors/versioned/v1.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const Promise = require('bluebird');
+const maybePromised = require('../../temputils.js').maybePromised;
+
+const execUnit = {
+  up: function (context, driver, file) {
+    return context.driver
+      .startMigration()
+      .then(() => {
+        const _file = file.get();
+
+        if (typeof _file.setup === 'function') {
+          _file.setup(context.internals.safeOptions, context.seedLink);
+        }
+
+        return maybePromised(file, _file.up, [context.driver]);
+      })
+      .then(() => {
+        return Promise.promisify(context.writeMigrationRecord.bind(context))(
+          file
+        );
+      })
+      .then(context.driver.endMigration.bind(context.driver));
+  },
+
+  down: function (context, driver, file) {
+    return driver
+      .startMigration()
+      .then(() => {
+        const _file = file.get();
+
+        if (typeof _file.setup === 'function') {
+          _file.setup(context.internals.safeOptions, context.seedLink);
+        }
+
+        return maybePromised(file, _file.down, [context.driver]);
+      })
+      .then(() => {
+        return Promise.promisify(context.deleteMigrationRecord.bind(context))(
+          file
+        );
+      })
+      .then(context.driver.endMigration.bind(context.driver));
+  }
+};
+
+module.exports = execUnit;