db-migrate 1.0.0-beta.9 → 1.0.0

package/lib/format-error.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const util = require('util');
+
+/**
+ * Diagnostic fields drivers set on their errors (pg, cockroachdb, mysql2,
+ * sqlite3), printed when present. Everything else, like the server source
+ * location of pg errors, is only printed verbose.
+ */
+const FIELDS = [
+  'code',
+  'errno',
+  'sqlState',
+  'sqlMessage',
+  'detail',
+  'hint',
+  'where',
+  'schema',
+  'table',
+  'column',
+  'dataType',
+  'constraint'
+];
+
+const indent = (text, prefix) =>
+  String(text)
+    .split('\n')
+    .map(line => prefix + line)
+    .join('\n');
+
+/**
+ * The SQL with a marker below the position reported by the database.
+ * Without parameters only, drivers rewrite their placeholders before
+ * sending, so the position would be off otherwise.
+ */
+const formatSql = err => {
+  // the position refers to the statement as sent, so nothing is trimmed
+  // before locating it, leading blank lines are only dropped for display
+  const sql = String(err.sql).replace(/\s+$/, '');
+  const lines = sql.split('\n');
+  let first = 0;
+  while (first < lines.length - 1 && lines[first].trim() === '') first++;
+
+  const position = Number(err.position);
+  let marker = null;
+
+  if (Number.isInteger(position) && position >= 1 && position <= sql.length + 1) {
+    if (err.sqlParams) {
+      marker = { text: `position: ${position}` };
+    } else {
+      const before = sql.slice(0, position - 1);
+      const row = before.split('\n').length - 1;
+      const column = before.length - (before.lastIndexOf('\n') + 1);
+      // keep tabs, so the marker lines up with the statement
+      marker = {
+        row,
+        text: '     ' + lines[row].slice(0, column).replace(/[^\t]/g, ' ') + '^'
+      };
+    }
+  }
+
+  const out = [];
+  lines.slice(first).forEach((line, i) => {
+    out.push((i === 0 ? 'SQL: ' : '     ') + line);
+    if (marker && marker.row === first + i) out.push(marker.text);
+  });
+
+  if (marker && marker.row === undefined) out.push(marker.text);
+
+  return out;
+};
+
+/**
+ * Format an error of a failed migration for the log: what failed, the SQL
+ * and the diagnostic fields of the driver, and always the stack.
+ */
+module.exports = function formatError (err, { verbose = false } = {}) {
+  if (!err || typeof err !== 'object') {
+    return String(err);
+  }
+
+  const message = err.message || String(err);
+  const lines = [
+    err.migration
+      ? `Migration "${err.migration}" failed` +
+        (err.instruction ? ` ${err.instruction}` : '') +
+        `: ${message}`
+      : message
+  ];
+
+  if (err.sql) {
+    lines.push(indent(formatSql(err).join('\n'), '    '));
+  }
+
+  FIELDS.forEach(field => {
+    const value = err[field];
+
+    if (
+      value !== undefined &&
+      value !== null &&
+      value !== '' &&
+      !(field === 'sqlMessage' && value === message)
+    ) {
+      lines.push(`    ${field}: ${value}`);
+    }
+  });
+
+  if (err.position !== undefined && !err.sql) {
+    lines.push(`    position: ${err.position}`);
+  }
+
+  lines.push(indent(err.stack || `${err.name}: ${message}`, '    '));
+
+  if (verbose) {
+    lines.push(indent(util.inspect(err, { depth: 4 }), '    '));
+  }
+
+  return lines.join('\n');
+};

package/lib/interface/seederInterface.js

@@ -34,7 +34,7 @@
   * To note: If you rollback a migration, linked to a seeder, db-migrate will
   * also rollback the seed. This is also a reason why you can't rollback a
   * specific migration, you would going to break that much, you probably loose
-  * a bunch of valueable time.
+  * a bunch of valuable time.
   */
 
 var Promise = require('bluebird');

package/lib/learn.js

@@ -2,25 +2,34 @@ const Promise = require('bluebird');
 const Shadow = require('./driver/shadow');
 
 class STD {
-  constructor ({ schema, modSchema: mod }, driver) {
+  constructor ({ schema, modSchema: mod, unlearn }, driver) {
     this.checkColumn = function (t, c) {
       if (!this.schema[t]) {
         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!`);
       }
     };
+    this.unlearn = unlearn;
     this.validations = {};
     this.driver = driver;
     this.indizies = schema.i;
     this.schema = schema.c;
     this.foreign = schema.f;
+    if (!schema.e) {
+      schema.e = {};
+    }
+    this.extra = schema.e;
+    if (unlearn) {
+      this.modC = [];
+    } else {
+      this.modC = mod.s;
+    }
     this.modS = mod.c;
     this.modI = mod.i;
     this.modF = mod.f;
-    this.modC = mod.s;
   }
 
   dropTable (t) {
@@ -87,6 +96,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();
@@ -107,8 +126,10 @@ class STD {
   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 && !this.unlearn) {
       if (this.validations.columnStrategies !== true) {
         if (
           this.driver._meta &&
@@ -154,12 +175,13 @@ class STD {
       }
     }
 
-    this.modS[t] = {};
+    // keep the columns removed before from the same table
+    if (!this.modS[t]) this.modS[t] = {};
 
-    if (this.schema[t][c].notNull === true) {
+    if (columns[c].notNull === true && !this.unlearn) {
       switch (o.columnStrategy) {
         case 'delay':
-          this.modS[t][c] = this.schema[t][c];
+          this.modS[t][c] = columns[c];
 
           o.passthrough = o.passthrough || {};
           o.passthrough.column =
@@ -174,19 +196,23 @@ class STD {
 
           break;
         case 'defaultValue':
-          this.modS[t][c] = this.schema[t][c];
+          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] = this.schema[t][c];
+    } else if (!this.unlearn) {
+      this.modS[t][c] = columns[c];
 
       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);
   }
@@ -207,7 +233,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] });
 
@@ -219,8 +248,11 @@ class STD {
 
     if (!this.modS[t]) this.modS[t] = {};
 
-    this.modS[t][c] = this.schema[t][c];
-    this.schema[t][c] = Object.assign(this.schema[t][c], s);
+    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] });
 
@@ -229,7 +261,7 @@ class STD {
 
   addIndex (t, i, c, u) {
     if (Array.isArray(c)) {
-      c.forEach(x => this.checkColumn(t, x));
+      c.forEach(x => this.checkColumn(t, typeof x === 'object' ? x.name : x));
     } else {
       this.checkColumn(t, c);
     }
@@ -269,7 +301,7 @@ class STD {
 
     alter.i[t] = {};
     alter.i[t][i] = this.indizies[t][i];
-    this.modI[t] = {};
+    if (!this.modI[t]) this.modI[t] = {};
     this.modI[t][i] = this.indizies[t][i];
     delete this.indizies[t][i];
 
@@ -314,10 +346,12 @@ class STD {
 
     alter.f[t] = {};
     alter.f[t][k] = this.foreign[t][k];
-    this.modF[t] = {};
+    if (!this.modF[t]) this.modF[t] = {};
     this.modF[t][k] = this.foreign[t][k];
     delete this.foreign[t][k];
 
+    this.modC.push({ t: 1, a: 'addForeignKey', c: [t, k] });
+
     return Promise.resolve(alter);
   }
 
@@ -340,6 +374,9 @@ const noLearnError = prop => {
 };
 
 module.exports = {
+  // learns the schema and records the reverse operations
+  learns: true,
+
   getInterface: (context, file, driver, internals) => {
     if (context.learnable) {
       const _std = new STD(internals, context);

package/lib/methods/v2/statedone.js

@@ -0,0 +1,18 @@
+const Shadow = require('../../driver/shadow');
+const State = require('../../state');
+
+/**
+ * Records a step as done, after it was executed on the database.
+ */
+module.exports = {
+  getInterface: (context, file, driver, internals, pdriver) => {
+    const done = () =>
+      function () {
+        // in memory first, a failing write must not hide the executed step
+        internals.migrationDone = internals.migrationOp;
+        return State.done(pdriver, internals.migrationOp, internals);
+      };
+
+    return Shadow.overshadow(driver, {}, done);
+  }
+};

package/lib/methods/v2/statetravel.js

@@ -17,41 +17,45 @@ const DEFAULT = {
   removeForeignKey: 'addForeignKey'
 };
 
+/**
+ * Persists the state around learning a step. Before learning (step) it
+ * records the step as started, afterwards it tags the recorded reverse
+ * operations with their step and records the step as learned.
+ */
 class StateTravel {
-  constructor (internals, file, driver) {
+  constructor (internals, file, driver, pdriver, step = true) {
     this.file = file;
     this.internals = internals;
     this.driver = driver;
-    this._counter = 0;
-  }
+    this.pdriver = pdriver;
+    this._default = async function _default () {
+      const op = this.internals.migrationOp;
 
-  async step () {
-    return State.step(this.driver, ++this._counter, this.internals);
-  }
+      if (step) {
+        await State.step(this.pdriver, op, this.internals);
+      } else {
+        this.internals.modSchema.s.forEach(entry => {
+          if (entry.n === undefined) entry.n = op;
+        });
+      }
 
-  async update () {
-    return State.update(
-      this.driver,
-      this.file,
-      this.internals.modSchema,
-      this.internals
-    );
-  }
-
-  async default () {
-    await this.step();
-    const res = await this.update();
+      await State.update(
+        this.pdriver,
+        this.file,
+        this.internals.modSchema,
+        this.internals
+      );
 
-    return res;
+      if (!step) {
+        await State.learned(this.pdriver, op, this.internals);
+      }
+    };
   }
 }
 
 Object.keys(DEFAULT).forEach(m => {
   StateTravel.prototype[m] = async function (...args) {
-    await this.step();
-    const res = await this.update();
-
-    return res;
+    return this._default();
   };
 });
 
@@ -61,24 +65,25 @@ const noTravelError = prop => {
   };
 };
 
-module.exports = {
-  getInterface: (context, file, driver, internals) => {
-    if (context.learnable) {
-      const st = new StateTravel(internals, file, context);
+module.exports = function (step = true) {
+  return {
+    getInterface: (context, file, driver, internals, pdriver) => {
+      if (context.learnable) {
+        const st = new StateTravel(internals, file, context, pdriver, step);
+        return Shadow.overshadow(
+          driver,
+          Object.assign(st, context.statechanger),
+          noTravelError
+        );
+      }
+
       return Shadow.overshadow(
         driver,
-        Object.assign(st, context.statechanger),
+        new StateTravel(internals, file, context, pdriver, step),
         noTravelError
       );
     }
 
-    return Shadow.overshadow(
-      driver,
-      new StateTravel(internals, file, context),
-      noTravelError
-    );
-  }
-
   /* hasModification: true,
 
   modify: (context, driver, internals) => {
@@ -96,4 +101,5 @@ module.exports = {
 
     return { driver: _driver };
   } */
+  };
 };

package/lib/methods/v2/translatestate.js

@@ -2,6 +2,8 @@ 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) => {
@@ -42,6 +44,31 @@ const methods = {
 
   changeColumn: async (driver, [t, c], internals) => {
     return driver.changeColumn(t, c, internals.modSchema.c[t][c]);
+  },
+
+  addForeignKey: async (driver, [t, k], internals) => {
+    const foreign = internals.modSchema.f[t][k];
+    return driver.addForeignKey(t, foreign.rt, k, foreign.m, foreign.r);
+  },
+
+  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
+    );
   }
 };
 
@@ -50,6 +77,7 @@ async function processEntry (
   file,
   driver,
   internals,
+  pdriver,
   { t: type, a: action, c: args }
 ) {
   let skip = false;
@@ -57,7 +85,7 @@ async function processEntry (
   if (
     internals.rollback === true &&
     internals.rollbackContinue !== true &&
-    driver.udriver._meta.signalColumns.indexOf(action) !== -1
+    driver.udriver._meta?.signalColumns?.indexOf(action) !== -1
   ) {
     internals.rollbackContinue = true;
     skip = driver.udriver._counter.previousSignal() === null;
@@ -78,19 +106,23 @@ async function processEntry (
     }
   }
 
-  internals.modSchema.s.shift();
-  await State.update(context, file, internals.modSchema, internals);
+  internals.modSchema.s.pop();
+  await State.update(pdriver, file, internals.modSchema, internals);
 }
 
-module.exports = async (context, file, driver, internals) => {
+module.exports = async (context, file, driver, internals, pdriver) => {
   const mod = internals.modSchema;
 
-  const chain = new Chain(context, file, driver, internals);
-  // chain.addChain(Learn);
+  const chain = new Chain(context, file, driver, internals, pdriver);
+  internals.unlearn = true;
+
+  chain.addChain(Learn);
   chain.addChain(Migrate);
-  await Promise.resolve(mod.s.reverse()).each(args =>
-    processEntry(context, file, chain, internals, args)
+  // the stored records keep their order, so an interrupted rollback can
+  // be continued
+  await Promise.resolve(mod.s.slice().reverse()).each(args =>
+    processEntry(context, file, chain, internals, pdriver, args)
   );
 
-  await State.deleteState(context, file, internals);
+  await State.deleteState(pdriver, file, internals);
 };