fix(v2): handle reversing of history sensitive operations better

fixes db-migrate#666

Signed-off-by: Tobias Gurtzick <[email protected]>

Author: wzrdtales

lib/chain.js

@@ -16,12 +16,65 @@ const DEFAULT = [
   'removeForeignKey'
 ];
 
+let rollbackCounter = 0;
+let rollbackSignal = null;
+let signal = null;
+let counter = 0;
+
+const dbmControl = {
+  inc: () => {
+    ++counter;
+  },
+
+  signal: () => {
+    signal = true;
+  },
+
+  hasSignaled: () => {
+    return signal;
+  },
+
+  previousSignal: () => {
+    const r = rollbackSignal;
+    // we reset on retrieval and mark as retrieved
+    rollbackSignal = rollbackSignal === null ? null : false;
+    return r;
+  },
+
+  get: () => {
+    return counter;
+  },
+
+  getPrevious: () => {
+    const r = rollbackCounter;
+
+    // we reset on retrieval and mark as retrieved
+    rollbackCounter = rollbackCounter > 0 ? false : 0;
+
+    return r;
+  }
+};
+
 class Chain {
   constructor (context, file, driver, internals) {
     this.file = file;
     this.context = context;
     this.driver = context;
     this.udriver = driver;
+    if (this.udriver._dbmControl !== true) {
+      this.udriver._counter = dbmControl;
+      this.udriver._dbmControl = true;
+      const runSql = this.udriver.runSql;
+      this.udriver._dbmControlRSQL = runSql;
+
+      // couple runSql
+      this.udriver.runSql = function (...args) {
+        return runSql.apply(this, args).then(x => {
+          ++counter;
+          return x;
+        });
+      };
+    }
     this.internals = internals;
     this.chains = [];
     this.interfaces = [];
@@ -32,20 +85,23 @@ class Chain {
     DEFAULT.concat(Object.keys(this.context.learnable || [])).forEach(
       method => {
         this[method] = function (...args) {
-          let cb = args.pop();
-          if (typeof cb !== 'function') {
-            args.push(cb);
-            cb = undefined;
-          }
-
-          return Promise.resolve(
-            this.exec.apply(this, [method].concat(args))
-          ).asCallback(cb);
+          // we don't handle any callbacks here, v2 ultimately deprecates them
+
+          this.transferInt();
+
+          return this.exec.apply(this, [method].concat(args));
         };
       }
     );
   }
 
+  transferInt () {
+    rollbackCounter = counter;
+    counter = 0;
+    rollbackSignal = signal;
+    signal = null;
+  }
+
   addChain (chain) {
     this.chains.push(chain);
   }

lib/commands/helper/register-events.js

@@ -4,11 +4,13 @@ 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);
   });

lib/executors/versioned/v2.js

@@ -48,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
@@ -61,8 +66,6 @@ const execUnit = {
   },
 
   down: async function (context, driver, file) {
-    context.internals.backwards = true;
-
     // start migration, see up comments
     await State.startMigration(context._driver, file, context.internals);
     await TranslateState(context._driver, file, driver, context.internals);

lib/methods/v2/translatestate.js

@@ -52,17 +52,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();
@@ -73,6 +86,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(Migrate);
   await Promise.resolve(mod.s.reverse()).each(args =>
     processEntry(context, file, chain, internals, args)

lib/walker.js

@@ -30,7 +30,18 @@ const Walker = function (driver, directory, mode, intern, prefix) {
   Promise.promisifyAll(this._driver);
   this.directory = directory;
   this.internals = intern;
+  /**
+   * i: index
+   * c: schema
+   * f: foreignKey
+   */
   this.internals.schema = { i: {}, c: {}, f: {} };
+  /**
+   * s: commands
+   * i: index
+   * f: foreignKey
+   * c: schema
+   */
   this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
   this.mode = mode;
 
@@ -241,7 +252,10 @@ Walker.prototype = {
         // Requires pr to export filterCompleted from db-migrate-shared
         const toRun = dbmUtil.filterCompleted(allFiles, completedFiles);
 
-        log.info('Files to run:', toRun.map(migration => migration.name));
+        log.info(
+          'Files to run:',
+          toRun.map(migration => migration.name)
+        );
         return toRun;
       })
       .nodeify(callback);