db-migrate 1.0.0-beta.2 → 1.0.0-beta.20

package/lib/commands/run.js

@@ -1,20 +1,16 @@
 'use strict';
 
 var log = require('db-migrate-shared').log;
-var optimist = require('optimist');
-var load = require('./');
-var transition = load('transition');
+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 'transition':
-      transition(internals);
-      break;
     case 'create':
       if (folder[1]) {
         internals.matching = folder[1];
@@ -114,10 +110,9 @@ function run (internals, config) {
         );
       } else {
         log.error(
-          'Invalid Action: Must be [up|down|check|create|reset|sync|' +
-            'db|transition].'
+          'Invalid Action: Must be [up|down|check|create|reset|sync|db].'
         );
-        optimist.showHelp();
+        yargs.showHelp();
         process.exit(1);
       }
       break;

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

@@ -1,4 +1,4 @@
-var optimist = require('optimist');
+var yargs = require('yargs');
 var log = require('db-migrate-shared').log;
 
 module.exports = function (internals, isModule) {
@@ -20,10 +20,10 @@ module.exports = function (internals, isModule) {
   };
 
   if (!isModule) {
-    internals.argv = optimist
+    internals.argv = yargs
       .default(defaultConfig)
       .usage(
-        'Usage: db-migrate [up|down|check|reset|sync|create|db|transition] ' +
+        'Usage: db-migrate [up|down|check|reset|sync|create|db] ' +
           '[[dbname/]migrationName|all] [options]'
       )
       .describe(
@@ -64,6 +64,8 @@ module.exports = function (internals, isModule) {
       .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 ' +
@@ -110,29 +112,25 @@ module.exports = function (internals, isModule) {
       .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');
+      .string('log-level')
+      .parse();
   } else {
-    const _internalsArgv = Object.assign(defaultConfig, internals.cmdOptions);
-    internals.argv = {
-      get argv () {
-        return _internalsArgv;
-      }
-    };
+    internals.argv = Object.assign(defaultConfig, internals.cmdOptions);
   }
 
   var plugins = internals.plugins;
   var plugin = plugins.hook('init:cli:config:hook');
-  var _config = internals.argv.argv.config;
+  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 optimist first
+      // hook not yet used, we look into migrating away from yargs first
     });
   }
 
-  internals.argv = deepExtend(internals.argv.argv, rc('db-migrate', {}));
+  internals.argv = deepExtend(internals.argv, rc('db-migrate', {}));
   internals.argv.rcconfig = internals.argv.config;
   internals.argv.config = internals.argv.configFile || _config;
 
@@ -142,7 +140,7 @@ module.exports = function (internals, isModule) {
   }
 
   if (!isModule && (internals.argv.help || internals.argv._.length === 0)) {
-    optimist.showHelp();
+    yargs.showHelp();
     process.exit(1);
   }
 
@@ -160,7 +158,7 @@ module.exports = function (internals, isModule) {
   internals.notransactions = internals.argv['non-transactional'];
   internals.dryRun = internals.argv['dry-run'];
   global.dryRun = internals.dryRun;
-  internals.check = internals.argv['check'];
+  internals.check = internals.argv.check;
 
   if (internals.dryRun) {
     log.info('dry run');

package/lib/commands/sync.js

@@ -21,15 +21,15 @@ async function prepare (internals, config) {
     );
 
     if (internals.locTitle) {
-      migrator.migrationsDir = path.resolve(
+      migrator.directory = path.resolve(
         internals.argv['migrations-dir'],
         internals.locTitle
       );
     } else {
-      migrator.migrationsDir = path.resolve(internals.argv['migrations-dir']);
+      migrator.directory = path.resolve(internals.argv['migrations-dir']);
     }
 
-    internals.migrationsDir = migrator.migrationsDir;
+    internals.migrationsDir = migrator.directory;
 
     await migrator.createMigrationsTable();
     log.verbose('migration table created');

package/lib/commands/up.js

@@ -21,15 +21,15 @@ async function prepare (internals, config) {
     );
 
     if (internals.locTitle) {
-      migrator.migrationsDir = path.resolve(
+      migrator.directory = path.resolve(
         internals.argv['migrations-dir'],
         internals.locTitle
       );
     } else {
-      migrator.migrationsDir = path.resolve(internals.argv['migrations-dir']);
+      migrator.directory = path.resolve(internals.argv['migrations-dir']);
     }
 
-    internals.migrationsDir = migrator.migrationsDir;
+    internals.migrationsDir = migrator.directory;
 
     await migrator.createMigrationsTable();
     log.verbose('migration table created');

package/lib/config.js

@@ -176,8 +176,8 @@ exports.loadObject = function (_config, currentEnv) {
 
   if (currentEnv) {
     out.setCurrent(currentEnv);
-  } else if (config['default']) {
-    out.setCurrent(config['default']);
+  } else if (config.default) {
+    out.setCurrent(config.default);
   } else if (config.defaultEnv) {
     if (config.defaultEnv.ENV) {
       out.setCurrent(process.env[config.defaultEnv.ENV]);

package/lib/driver/index.js

@@ -18,6 +18,8 @@ var ShadowProto = {
 
 exports.connect = function (config, intern, callback) {
   var driver, req;
+  let plugin = false;
+  const { plugins } = intern;
 
   var mod = internals.mod;
   internals = intern;
@@ -90,27 +92,51 @@ exports.connect = function (config, intern, callback) {
   log.verbose('connecting');
 
   var connect = function (config) {
-    driver.connect(config, intern, function (err, db) {
-      if (err) {
-        callback(err);
-        return;
-      }
-      log.verbose('connected');
+    driver.connect(
+      // safe disconnect of our config object into userspace
+      JSON.parse(JSON.stringify(config)),
+      intern,
+      function (err, db) {
+        if (err) {
+          callback(err);
+          return;
+        }
+        log.verbose('connected');
 
-      if (!global.immunity) {
-        db = Shadow.infect(db, internals, ShadowProto);
-      }
+        if (!global.immunity) {
+          db = Shadow.infect(db, internals, ShadowProto);
+        }
 
-      callback(null, db);
-    });
+        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

package/lib/executors/versioned/v2.js

@@ -8,13 +8,14 @@ const Chain = require('../../chain');
 const StateTravel = require('../../methods/v2/statetravel');
 const Migrate = require('../../methods/v2/migrate');
 const TranslateState = require('../../methods/v2/translatestate');
+const AddConventions = require('../../methods/v2/conventions');
 
 const execUnit = {
   _extend: (context, type) => {
     return {
       atomic: function (actions) {
-        let action = actions[type];
-        let reverse = actions[type === 'up' ? 'up' : 'down'];
+        const action = actions[type];
+        const reverse = actions[type === 'up' ? 'up' : 'down'];
 
         if (!action || !reverse) {
           return Promise.reject(new Error('invalid operation'));
@@ -28,6 +29,9 @@ const execUnit = {
   up: async function (context, driver, file) {
     const _file = file.get();
     const chain = new Chain(context._driver, file, driver, context.internals);
+    if (!_file._meta.noDefaultColumn) {
+      chain.addChain(AddConventions);
+    }
     chain.addChain(Learn);
     chain.addChain(StateTravel);
     chain.addChain(Migrate);
@@ -44,6 +48,11 @@ const execUnit = {
         dbm: context.internals.safeOptions.dbmigrate
       });
     } catch (err) {
+      context.internals.rollback = true;
+
+      // transfer last state
+      chain.transferInt();
+
       log.error(
         'An error occured. No alternative failure strategy defined. Rolling back!',
         err
@@ -51,7 +60,8 @@ const execUnit = {
       await execUnit.down(context, driver, file);
       throw err;
     }
-    return Promise.promisify(context.writeMigrationRecord.bind(context))(file);
+    await Promise.promisify(context.writeMigrationRecord.bind(context))(file);
+    return State.endMigration(context._driver, file, context.internals);
     // end migration, same as start migration
   },
 

package/lib/file.js

@@ -38,7 +38,7 @@ function formatTitle (title) {
 }
 
 function parseDate (name) {
-  let date = new Date();
+  const date = new Date();
   const match = name.match(/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})-[^.]+/);
   date.setUTCFullYear(match[1]);
   date.setUTCDate(match[3]);
@@ -125,9 +125,7 @@ File.registerHook = function (Plugin, internals) {
 
         if (plugin.maintainer && plugin.maintainer.repository) {
           log.verbose(
-            `The repo of the ${plugin.name} plugin is ${
-              plugin.maintainer.repository
-            }!`
+            `The repo of the ${plugin.name} plugin is ${plugin.maintainer.repository}!`
           );
         }
         return plugin['migrator:migration:hook:require']();

package/lib/learn.js

@@ -8,7 +8,7 @@ class STD {
         throw new Error(`There is no ${t} table in schema!`);
       }
 
-      if (!this.schema[t][c]) {
+      if (!this.schema[t][c] && !this.schema[t].columns[c]) {
         throw new Error(`There is no ${c} column in schema!`);
       }
     };
@@ -17,6 +17,10 @@ class STD {
     this.indizies = schema.i;
     this.schema = schema.c;
     this.foreign = schema.f;
+    if (!schema.e) {
+      schema.e = {};
+    }
+    this.extra = schema.e;
     this.modS = mod.c;
     this.modI = mod.i;
     this.modF = mod.f;
@@ -87,6 +91,16 @@ class STD {
       delete this.schema[t];
     }
 
+    if (this.foreign[t]) {
+      this.modF[n] = this.foreign[n];
+      delete this.foreign[t];
+    }
+
+    if (this.indizies[t]) {
+      this.modI[n] = this.indizies[t];
+      delete this.indizies[t];
+    }
+
     this.modC.push({ t: 0, a: 'renameTable', c: [n, t] });
 
     return Promise.resolve();
@@ -104,11 +118,13 @@ class STD {
     return this.createTable.apply(this, args);
   }
 
-  removeColumn (t, c, o) {
-    let alter = {};
+  removeColumn (t, c, o = {}) {
+    const alter = {};
     this.checkColumn(t, c);
+    const hasColumns = this.schema[t].columns !== undefined;
+    const columns = hasColumns ? this.schema[t].columns : this.schema[t];
 
-    if (this.schema[t][c].notNull === true) {
+    if (columns[c].notNull === true) {
       if (this.validations.columnStrategies !== true) {
         if (
           this.driver._meta &&
@@ -134,9 +150,7 @@ class STD {
                 );
               }
               throw new Error(
-                `There is no such column recreation strategy "${
-                  o.columnStrategy
-                }!"`
+                `There is no such column recreation strategy "${o.columnStrategy}!"`
               );
           }
         } else {
@@ -158,30 +172,41 @@ class STD {
 
     this.modS[t] = {};
 
-    switch (o.columnStrategies) {
-      case 'delay':
-        this.modS[t][c] = this.schema[t][c];
-
-        o.passthrough = o.passthrough || {};
-        o.passthrough.column =
-          o.passthrough.column || `__dbmrn_${c}_${new Date().toString()}__`;
-
-        this.modC.push({
-          t: 1,
-          a: 'renameColumn',
-          c: [t, o.passthrough.column, c]
-        });
-
-        break;
-      case 'defaultValue':
-        this.modS[t][c] = this.schema[t][c];
-        this.modS[t][c].defaultValue = o.passthrough.defaultValue;
+    if (columns[c].notNull === true) {
+      switch (o.columnStrategy) {
+        case 'delay':
+          this.modS[t][c] = columns[c];
+
+          o.passthrough = o.passthrough || {};
+          o.passthrough.column =
+            o.passthrough.column ||
+            `__dbmrn_${c}_${new Date().toISOString()}__`;
+
+          this.modC.push({
+            t: 0,
+            a: 'renameColumn',
+            c: [t, o.passthrough.column, c]
+          });
+
+          break;
+        case 'defaultValue':
+          this.modS[t][c] = columns[c];
+          this.modS[t][c].defaultValue = o.passthrough.defaultValue;
+
+          this.modC.push({ t: 1, a: 'addColumn', c: [t, c, o] });
+          break;
+      }
+    } else {
+      this.modS[t][c] = columns[c];
 
-        this.modC.push({ t: 1, a: 'addColumn', c: [t, c, o] });
-        break;
+      this.modC.push({ t: 1, a: 'addColumn', c: [t, c, o] });
     }
 
-    delete this.schema[t][c];
+    if (hasColumns) {
+      delete this.schema[t].columns[c];
+    } else {
+      delete this.schema[t][c];
+    }
 
     return Promise.resolve(alter);
   }
@@ -202,7 +227,10 @@ class STD {
       throw new Error(`There is no ${t} table in schema!`);
     }
     this.schema[t] = this.schema[t] || {};
-    this.schema[t][c] = s;
+    const hasColumns = this.schema[t].columns !== undefined;
+    const columns = hasColumns ? this.schema[t].columns : this.schema[t];
+
+    columns[c] = s;
 
     this.modC.push({ t: 0, a: 'removeColumn', c: [t, c] });
 
@@ -212,8 +240,13 @@ class STD {
   changeColumn (t, c, s) {
     this.checkColumn(t, c);
 
-    this.modS[t][c] = this.schema[t][c];
-    this.schema[t][c] = Object.assign(this.schema[t][c], s);
+    if (!this.modS[t]) this.modS[t] = {};
+
+    const hasColumns = this.schema[t].columns !== undefined;
+    const columns = hasColumns ? this.schema[t].columns : this.schema[t];
+
+    this.modS[t][c] = columns[c];
+    columns[c] = Object.assign(columns[c], s);
 
     this.modC.push({ t: 1, a: 'changeColumn', c: [t, c] });
 

package/lib/methods/v2/conventions.js

@@ -0,0 +1,47 @@
+const Shadow = require('../../driver/shadow');
+
+class AddConventions {
+  constructor (internals, file, driver) {
+    this.file = file;
+    this.internals = internals;
+    this.driver = driver;
+    this._counter = 0;
+  }
+
+  createTable (t, d) {
+    d.__dbmigrate__flag = {
+      type: 'string'
+    };
+
+    return Promise.resolve();
+  }
+
+  createCollection (...args) {
+    return this.createTable.apply(this, args);
+  }
+}
+
+const noAction = prop => {
+  return function () {
+    return Promise.resolve();
+  };
+};
+
+module.exports = {
+  getInterface: (context, file, driver, internals) => {
+    if (context.conventions) {
+      const st = new AddConventions(internals, file, context);
+      return Shadow.overshadow(
+        driver,
+        Object.assign(st, context.conventions),
+        noAction
+      );
+    }
+
+    return Shadow.overshadow(
+      driver,
+      new AddConventions(internals, file, context),
+      noAction
+    );
+  }
+};

package/lib/methods/v2/statetravel.js

@@ -23,20 +23,22 @@ class StateTravel {
     this.internals = internals;
     this.driver = driver;
     this._counter = 0;
+    this._default = async function _default () {
+      await State.step(this.driver, ++this._counter, this.internals);
+
+      return State.update(
+        this.driver,
+        this.file,
+        this.internals.modSchema,
+        this.internals
+      );
+    };
   }
 }
 
 Object.keys(DEFAULT).forEach(m => {
   StateTravel.prototype[m] = async function (...args) {
-    await State.step(this.driver, ++this._counter, this.internals);
-    const res = await State.update(
-      this.driver,
-      this.file,
-      this.internals.modSchema,
-      this.internals
-    );
-
-    return res;
+    return this._default();
   };
 });
 

package/lib/methods/v2/translatestate.js

@@ -2,7 +2,7 @@ const Promise = require('bluebird');
 const State = require('../../state');
 const Chain = require('../../chain');
 const Migrate = require('./migrate');
-const Learn = require('../../learn');
+const log = require('db-migrate-shared').log;
 
 const methods = {
   createTable: async (driver, [t], internals) => {
@@ -43,6 +43,26 @@ const methods = {
 
   changeColumn: async (driver, [t, c], internals) => {
     return driver.changeColumn(t, c, internals.modSchema.c[t][c]);
+  },
+
+  addIndex: async (driver, [t, i], internals) => {
+    if (!internals.modSchema.i[t][i]) {
+      log.warn(
+        `There was an attempt to create the index "${i}" in the table "${t}".`
+      );
+      log.warn(
+        `This index did not exist at the time of deleting it. ` +
+          `This can happen if an index was created by hand and then deleted ` +
+          `by db-migrate. Make sure to recreate it by hand to avoid any problems.`
+      );
+      return Promise.resolve();
+    }
+    return driver.addIndex(
+      t,
+      i,
+      internals.modSchema.i[t][i].c,
+      internals.modSchema.i[t][i].u ? true : undefined
+    );
   }
 };
 
@@ -53,17 +73,30 @@ async function processEntry (
   internals,
   { t: type, a: action, c: args }
 ) {
-  const f = Object.assign(methods, context.reverse);
-  switch (type) {
-    case 0:
-      await driver[action].apply(driver, args);
-      break;
-    case 1:
-      await f[action](driver, args, internals);
-      break;
+  let skip = false;
 
-    default:
-      throw new Error(`Invalid state record, of type ${type}`);
+  if (
+    internals.rollback === true &&
+    internals.rollbackContinue !== true &&
+    driver.udriver._meta.signalColumns.indexOf(action) !== -1
+  ) {
+    internals.rollbackContinue = true;
+    skip = driver.udriver._counter.previousSignal() === null;
+  }
+
+  if (!skip) {
+    const f = Object.assign(methods, context.reverse);
+    switch (type) {
+      case 0:
+        await driver[action].apply(driver, args);
+        break;
+      case 1:
+        await f[action](driver, args, internals);
+        break;
+
+      default:
+        throw new Error(`Invalid state record, of type ${type}`);
+    }
   }
 
   internals.modSchema.s.shift();
@@ -74,7 +107,7 @@ module.exports = async (context, file, driver, internals) => {
   const mod = internals.modSchema;
 
   const chain = new Chain(context, file, driver, internals);
-  chain.addChain(Learn);
+  // chain.addChain(Learn);
   chain.addChain(Migrate);
   await Promise.resolve(mod.s.reverse()).each(args =>
     processEntry(context, file, chain, internals, args)

package/lib/state.js

@@ -31,7 +31,7 @@ module.exports = {
 
   init: async function (driver, internals) {
     await driver._createKV(internals.migrationState);
-    let schema = await driver._getKV(internals.migrationState, SSTATE);
+    const schema = await driver._getKV(internals.migrationState, SSTATE);
     if (schema) {
       internals.schema = JSON.parse(schema.value);
     } else {
@@ -39,7 +39,7 @@ module.exports = {
     }
 
     if (!internals.dryRun) {
-      let state = await driver._getKV(internals.migrationState, MSTATE);
+      const state = await driver._getKV(internals.migrationState, MSTATE);
       return module.exports.lockState(driver, state, internals);
     }
 
@@ -47,10 +47,10 @@ module.exports = {
   },
 
   startMigration: async function (driver, file, internals) {
-    let state = await driver._getKV(internals.migrationState, MSTATE);
-    let mig = await driver._getKV(internals.migrationState, file.name);
+    const state = await driver._getKV(internals.migrationState, MSTATE);
+    const mig = await driver._getKV(internals.migrationState, file.name);
 
-    if (mig) {
+    if (mig && mig.value !== '{}') {
       internals.modSchema = JSON.parse(mig.value);
     }