db-migrate 1.0.0-beta.16

package/lib/learn.js

@@ -0,0 +1,369 @@
+const Promise = require('bluebird');
+const Shadow = require('./driver/shadow');
+
+class STD {
+  constructor ({ schema, modSchema: mod }, 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]) {
+        throw new Error(`There is no ${c} column in schema!`);
+      }
+    };
+    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;
+    this.modS = mod.c;
+    this.modI = mod.i;
+    this.modF = mod.f;
+    this.modC = mod.s;
+  }
+
+  dropTable (t) {
+    let alter = {};
+    alter = { c: {}, i: {}, f: {} };
+
+    if (this.schema[t]) {
+      alter.c[t] = this.schema[t];
+      this.modS[t] = this.schema[t];
+      delete this.schema[t];
+    }
+
+    if (this.foreign[t]) {
+      alter.f[t] = this.foreign[t];
+      this.modF[t] = this.foreign[t];
+      delete this.foreign[t];
+    }
+
+    if (this.indizies[t]) {
+      alter.i[t] = this.indizies[t];
+      this.modI[t] = this.indizies[t];
+      delete this.indizies[t];
+    }
+
+    this.modC.push({ t: 1, a: 'createTable', c: [t] });
+
+    return Promise.resolve(alter);
+  }
+
+  createTable (t, s) {
+    this.schema[t] = Object.assign({}, s);
+
+    Object.keys(s).forEach(k => {
+      const key = s[k];
+
+      if (key.foreignKey) {
+        if (!this.foreign[t]) this.foreign[t] = {};
+
+        this.foreign[t][key.foreignKey.name] = { t, rt: key.foreignKey.table };
+        if (key.foreignKey.rules) {
+          this.foreign[t][key.foreignKey.name].r = key.foreignKey.rules;
+        }
+
+        let mapping = {};
+
+        if (typeof key.foreignKey.mapping === 'string') {
+          mapping[k] = key.foreignKey.mapping;
+        } else {
+          mapping = Object.assign({}, key.foreignKey.mapping);
+        }
+
+        this.foreign[t][key.foreignKey.name].m = mapping;
+      }
+    });
+
+    this.modC.push({ t: 0, a: 'dropTable', c: [t] });
+
+    return Promise.resolve();
+  }
+
+  renameTable (t, n) {
+    if (this.schema[t]) {
+      this.schema[n] = this.schema[t];
+      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();
+  }
+
+  renameCollection (...args) {
+    return this.renameTable.apply(this, args);
+  }
+
+  dropCollection (...args) {
+    return this.dropTable.apply(this, args);
+  }
+
+  createCollection (...args) {
+    return this.createTable.apply(this, args);
+  }
+
+  removeColumn (t, c, o = {}) {
+    const alter = {};
+    this.checkColumn(t, c);
+
+    if (this.schema[t][c].notNull === true) {
+      if (this.validations.columnStrategies !== true) {
+        if (
+          this.driver._meta &&
+          this.driver._meta.supports &&
+          this.driver._meta.supports.optionParam === true
+        ) {
+          /**
+           * This is a validation only, no action will be taken unless throwing
+           * errors.
+           *
+           * The driver needs to respect the options properly.
+           */
+          switch (o.columnStrategy) {
+            case 'defaultValue':
+              break;
+            case 'delay':
+              break;
+            default:
+              if (!o.columnStrategy) {
+                throw new Error(
+                  'Can not drop a notNull column without providing a' +
+                    ' recreation strategy.'
+                );
+              }
+              throw new Error(
+                `There is no such column recreation strategy "${o.columnStrategy}!"`
+              );
+          }
+        } else {
+          throw new Error(
+            'This driver does not support optionParameters which are' +
+              ' required to provide a recreation strategy.'
+          );
+        }
+
+        if (!this.driver._meta.supports.columnStrategies) {
+          throw new Error(
+            'This driver does not support column recreation strategies.'
+          );
+        }
+
+        this.validations.columnStrategies = true;
+      }
+    }
+
+    this.modS[t] = {};
+
+    if (this.schema[t][c].notNull === true) {
+      switch (o.columnStrategy) {
+        case 'delay':
+          this.modS[t][c] = this.schema[t][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] = this.schema[t][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];
+
+      this.modC.push({ t: 1, a: 'addColumn', c: [t, c, o] });
+    }
+
+    delete this.schema[t][c];
+
+    return Promise.resolve(alter);
+  }
+
+  renameColumn (t, o, n) {
+    if (this.schema[t]) {
+      this.schema[t][n] = this.schema[t][o];
+      delete this.schema[t][o];
+    }
+
+    this.modC.push({ t: 0, a: 'renameColumn', c: [t, n, o] });
+
+    return Promise.resolve();
+  }
+
+  addColumn (t, c, s) {
+    if (!this.schema[t]) {
+      throw new Error(`There is no ${t} table in schema!`);
+    }
+    this.schema[t] = this.schema[t] || {};
+    this.schema[t][c] = s;
+
+    this.modC.push({ t: 0, a: 'removeColumn', c: [t, c] });
+
+    return Promise.resolve();
+  }
+
+  changeColumn (t, c, s) {
+    this.checkColumn(t, c);
+
+    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);
+
+    this.modC.push({ t: 1, a: 'changeColumn', c: [t, c] });
+
+    return Promise.resolve();
+  }
+
+  addIndex (t, i, c, u) {
+    if (Array.isArray(c)) {
+      c.forEach(x => this.checkColumn(t, x));
+    } else {
+      this.checkColumn(t, c);
+    }
+
+    const index = { t, c };
+
+    if (u === true) {
+      index.u = true;
+    }
+
+    if (!this.indizies[t]) this.indizies[t] = {};
+    this.indizies[t][i] = index;
+
+    this.modC.push({ t: 0, a: 'removeIndex', c: [t, i] });
+
+    return Promise.resolve();
+  }
+
+  removeIndex (t, _i) {
+    let alter = {};
+    alter = { c: {}, i: {}, f: {} };
+
+    let i;
+    if (!_i) {
+      i = t;
+    } else {
+      i = _i;
+    }
+
+    if (!this.schema[t]) {
+      throw new Error(`There is no ${t} table in schema!`);
+    }
+
+    if (!this.indizies[t] || !this.indizies[t][i]) {
+      throw new Error(`There is no index ${i} in ${t} table!`);
+    }
+
+    alter.i[t] = {};
+    alter.i[t][i] = this.indizies[t][i];
+    this.modI[t] = {};
+    this.modI[t][i] = this.indizies[t][i];
+    delete this.indizies[t][i];
+
+    this.modC.push({ t: 1, a: 'addIndex', c: [t, i] });
+
+    return Promise.resolve(alter);
+  }
+
+  addForeignKey (t, rt, k, m, r) {
+    if (!this.schema[t]) {
+      throw new Error(`There is no ${t} table in schema!`);
+    }
+
+    if (!this.schema[rt]) {
+      throw new Error(`There is no ${rt} table in schema!`);
+    }
+
+    if (!this.foreign[t]) this.foreign[t] = {};
+
+    this.foreign[t][k] = { t, rt, m };
+
+    if (r) {
+      this.foreign[t][k].r = r;
+    }
+
+    this.modC.push({ t: 0, a: 'removeForeignKey', c: [t, k] });
+
+    return Promise.resolve();
+  }
+
+  removeForeignKey (t, k, o) {
+    let alter = {};
+    alter = { c: {}, i: {}, f: {} };
+
+    if (!this.schema[t]) {
+      throw new Error(`There is no ${t} table in schema!`);
+    }
+
+    if (!this.foreign[t] || !this.foreign[t][k]) {
+      throw new Error(`There is no foreign key ${k} in ${t} table!`);
+    }
+
+    alter.f[t] = {};
+    alter.f[t][k] = this.foreign[t][k];
+    this.modF[t] = {};
+    this.modF[t][k] = this.foreign[t][k];
+    delete this.foreign[t][k];
+
+    return Promise.resolve(alter);
+  }
+
+  //
+  //  checkDBMS: dummy,
+  //
+  //  createDatabase: dummy,
+  //
+  //  switchDatabase: dummy,
+  //
+  //  dropDatabase: dummy,
+  //
+  //  runSql: dummy,
+}
+
+const noLearnError = prop => {
+  return function () {
+    throw new Error(`Can't learn function ${prop}`);
+  };
+};
+
+module.exports = {
+  getInterface: (context, file, driver, internals) => {
+    if (context.learnable) {
+      const _std = new STD(internals, context);
+      return Shadow.overshadow(
+        driver,
+        Object.assign(_std, context.learnable),
+        noLearnError
+      );
+    }
+
+    return Shadow.overshadow(driver, new STD(internals, context), noLearnError);
+  }
+};

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/migrate.js

@@ -0,0 +1,5 @@
+module.exports = {
+  getInterface (context, file, driver) {
+    return driver;
+  }
+};

package/lib/methods/v2/statetravel.js

@@ -0,0 +1,86 @@
+const Shadow = require('../../driver/shadow');
+const State = require('../../state');
+const DEFAULT = {
+  renameCollection: 'renameCollection',
+  dropCollection: 'createCollection',
+  createCollection: 'dropCollection',
+  createTable: 'dropTable',
+  dropTable: 'createTable',
+  renameTable: 'renameTable',
+  addColumn: 'removeColumn',
+  removeColumn: 'addColumn',
+  renameColumn: 'renameColumn',
+  changeColumn: 'changeColumn',
+  addIndex: 'removeIndex',
+  removeIndex: 'addIndex',
+  addForeignKey: 'removeForeignKey',
+  removeForeignKey: 'addForeignKey'
+};
+
+class StateTravel {
+  constructor (internals, file, driver) {
+    this.file = file;
+    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) {
+    return this._default();
+  };
+});
+
+const noTravelError = prop => {
+  return function () {
+    throw new Error(`Can't state travel function ${prop}`);
+  };
+};
+
+module.exports = {
+  getInterface: (context, file, driver, internals) => {
+    if (context.learnable) {
+      const st = new StateTravel(internals, file, context);
+      return Shadow.overshadow(
+        driver,
+        Object.assign(st, context.statechanger),
+        noTravelError
+      );
+    }
+
+    return Shadow.overshadow(
+      driver,
+      new StateTravel(internals, file, context),
+      noTravelError
+    );
+  }
+
+  /* hasModification: true,
+
+  modify: (context, driver, internals) => {
+    let _driver = Object.assign({}, driver);
+    _driver.host = {};
+    // Inject into chained operations, in this case
+    // we directly process information from the major
+    // creation object, so this serves only as an example currently.
+    // ['addForeignKey'].forEach(m => {
+    //  _driver.host[m] = _driver[m];
+    //  _driver[m] = function (...args) {
+    //    return _driver.host[m].apply(_driver, args);
+    //  };
+    // });
+
+    return { driver: _driver };
+  } */
+};

package/lib/methods/v2/translatestate.js

@@ -0,0 +1,117 @@
+const Promise = require('bluebird');
+const State = require('../../state');
+const Chain = require('../../chain');
+const Migrate = require('./migrate');
+const log = require('db-migrate-shared').log;
+
+const methods = {
+  createTable: async (driver, [t], internals) => {
+    const mod = internals.modSchema;
+    const schema = mod.c[t];
+    await driver.createTable(t, schema);
+
+    Object.keys(schema).forEach(key => {
+      if (schema[key].foreignKey) {
+        delete mod.f[t][schema[key].foreignKey.name];
+      }
+    });
+
+    if (mod.i[t]) {
+      await Promise.resolve(Object.keys(mod.i[t])).each(i => {
+        const index = mod.i[t][i];
+        return driver.addIndex(t, i, index.c, index.u);
+      });
+    }
+
+    if (mod.f[t]) {
+      await Promise.resolve(Object.keys(mod.f[t])).each(f => {
+        const foreign = mod.f[t][f];
+        return driver.addForeignKey(
+          t,
+          foreign.rt,
+          foreign.k,
+          foreign.m,
+          foreign.r
+        );
+      });
+    }
+  },
+
+  addColumn: async (driver, [t, c], internals) => {
+    return driver.addColumn(t, c, internals.modSchema.c[t][c]);
+  },
+
+  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
+    );
+  }
+};
+
+async function processEntry (
+  context,
+  file,
+  driver,
+  internals,
+  { t: type, a: action, c: args }
+) {
+  let skip = false;
+
+  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();
+  await State.update(context, file, internals.modSchema, internals);
+}
+
+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)
+  );
+
+  await State.deleteState(context, file, internals);
+};

package/lib/relation.js

@@ -0,0 +1,37 @@
+var fs = require('fs');
+var log = require('db-migrate-shared').log;
+
+function Relation () {
+  this.relations = {};
+}
+
+Relation.prototype = {
+  addRelation: function (table, column, relatedTable, relatedColumn) {
+    this.relations[table] = this.relations[table] || {};
+    this.relations[table][column] = relatedColumn;
+  },
+
+  getRelation: function (table, column) {
+    return this.relations[table][column];
+  },
+
+  fromJson: function (file) {
+    // Relation = require(file);
+
+    log.info('Read Relations from file ' + file);
+  },
+
+  toJson: function (file) {
+    fs.writeFile(file, JSON.stringify(this.relations), function (err) {
+      if (err) {
+        throw err;
+      }
+
+      log.info('Wrote Relations to file ' + file);
+    });
+  },
+
+  clearRelations: function () {
+    this.relations = {};
+  }
+};