db-migrate 1.0.0-beta.22 → 1.0.0-beta.24

package/api.js

@@ -245,6 +245,31 @@ dbmigrate.prototype = {
     );
   },
 
+  fix: function (specification, opts, callback) {
+    var executeFix = load('fix');
+
+    if (arguments.length > 0) {
+      if (typeof specification === 'string') {
+        this.internals.argv.destination = specification;
+      } else if (typeof specification === 'number') {
+        this.internals.argv.count = specification;
+      } else if (typeof specification === 'function') {
+        callback = specification;
+      }
+
+      if (typeof opts === 'string') {
+        this.internals.migrationMode = opts;
+        this.internals.matching = opts;
+      } else if (typeof opts === 'function') {
+        callback = opts;
+      }
+    }
+
+    return Promise.resolve(executeFix(this.internals, this.config)).nodeify(
+      callback
+    );
+  },
+
   check: function (specification, opts, callback) {
     var executeCheck = load('check');
 

package/lib/commands/fix.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.directory = path.resolve(
+        internals.argv['migrations-dir'],
+        internals.locTitle
+      );
+    } else {
+      migrator.directory = path.resolve(internals.argv['migrations-dir']);
+    }
+
+    internals.migrationsDir = migrator.directory;
+
+    await migrator.createMigrationsTable({ emptyState: true });
+    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.fix(internals.argv);
+    return internals.onComplete(migrator, internals, null, res);
+  } catch (err) {
+    return internals.onComplete(migrator, internals, err);
+  }
+};

package/lib/commands/generated.js

@@ -9,6 +9,7 @@ const files = {
   "db": require('./db.js'),
   "down": require('./down.js'),
   "dump": require('./dump.js'),
+  "fix": require('./fix.js'),
   "fn/plugin": require('./fn/plugin.js'),
   "generated": require('./generated.js'),
   "helper/assert": require('./helper/assert.js'),

package/lib/commands/run.js

@@ -36,6 +36,7 @@ function run (internals, config) {
 
       executeSync(internals, config);
       break;
+    case 'fix':
     case 'up':
     case 'down':
     case 'reset':
@@ -58,6 +59,9 @@ function run (internals, config) {
       if (action === 'up') {
         var executeUp = load('up');
         executeUp(internals, config);
+      } else if (action === 'fix') {
+        var executeFix = load('fix');
+        executeFix(internals, config);
       } else {
         var executeDown = load('down');
         executeDown(internals, config);

package/lib/executors/versioned/v2.js

@@ -9,6 +9,7 @@ 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 util = require('util');
 
 const execUnit = {
   _extend: (context, type) => {
@@ -65,6 +66,45 @@ const execUnit = {
     // end migration, same as start migration
   },
 
+  fix: 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);
+
+    await State.startMigration(context._driver, file, context.internals);
+    // startMigration - needs secondary instance since we can not afford to
+    // loose state and the transaction start will include these for roll back
+    // we will disable them probably at all from DDL when the driver does not
+    // explicitly signal DDL transaction support (like crdb)
+    try {
+      await _file.migrate(chain, {
+        options: context.internals.safeOptions,
+        seedLink: context.seedLink,
+        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
+      );
+      await execUnit.down(context, driver, file);
+      throw err;
+    }
+    await Promise.promisify(context.writeMigrationRecord.bind(context))(file);
+    await State.endMigration(context._driver, file, context.internals);
+    log.verbose(`[fix] current schema`, util.inspect(context.internals.schema, false, null, true));
+    // end migration, same as start migration
+  },
+
   down: async function (context, driver, file) {
     // start migration, see up comments
     await State.startMigration(context._driver, file, context.internals);

package/lib/state.js

@@ -29,12 +29,12 @@ module.exports = {
     }
   },
 
-  init: async function (driver, internals) {
+  init: async function (driver, internals, { emptyState }) {
     await driver._createKV(internals.migrationState);
-    const schema = await driver._getKV(internals.migrationState, SSTATE);
+    const schema = emptyState ? await driver._getKV(internals.migrationState, SSTATE) : null;
     if (schema) {
       internals.schema = JSON.parse(schema.value);
-    } else {
+    } else if (!emptyState) {
       await driver._insertKV(internals.migrationState, SSTATE, '{}');
     }
 

package/lib/walker.js

@@ -59,12 +59,12 @@ const Walker = function (driver, directory, mode, intern, prefix) {
 };
 
 Walker.prototype = {
-  createTables: async function () {
-    await State.init(this._driver, this.internals);
+  createTables: async function (options) {
+    await State.init(this._driver, this.internals, options);
     return this._driver._createList(this.internals.migrationTable);
   },
 
-  createMigrationsTable: function () {
+  createMigrationsTable: function (options) {
     if (
       typeof this._driver._createList !== 'function' ||
       typeof this._driver._getList !== 'function' ||
@@ -85,7 +85,7 @@ Walker.prototype = {
       }
     }
 
-    return this.createTables();
+    return this.createTables(options);
   },
 
   writeMigrationRecord: function (migration, callback) {
@@ -239,6 +239,65 @@ Walker.prototype = {
       .nodeify(callback);
   },
 
+  fix: function (options, callback) {
+    const partialName = options.destination;
+    const count = options.count;
+    const sortFn = function (a, b) {
+      a = a.name.slice(0, a.name.indexOf('-'));
+      b = b.name.slice(0, b.name.indexOf('-'));
+
+      if (!isNaN(a)) {
+        return a - b;
+      }
+
+      return a.localeCompare(b);
+    };
+
+    const files = File.loadFromDatabase(
+      this.directory,
+      this.prefix,
+      this._driver,
+      this.internals
+    ).then(completedFiles => {
+      const toRun = dbmUtil.filterDown(completedFiles, partialName, count).sort(sortFn);
+
+      if (toRun.length === 0) {
+        log.info(this.title + 'Nothing to run');
+      }
+
+      if (this.internals.check) {
+        const toRunNames = toRun.map(migration => migration.name);
+        log.info(this.title + 'run:', toRunNames);
+        return toRunNames;
+      }
+
+      return toRun;
+    });
+
+    if (this.internals.check) {
+      return files.nodeify(callback);
+    }
+
+    return files
+      .each(file => {
+        log.verbose(this.title + 'preparing to run fix:', file.name);
+        const _meta = file.get()._meta || {};
+        const version = _meta.version || 1;
+        if (version < 2) {
+          log.warn(`${this.title} skipping "${file.name}" as v1 migrations do not maintain a schema`);
+          return Promise.resolve();
+        }
+
+        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+        return require(`./executors/versioned/v${version}`).fix(
+          this,
+          this.driver,
+          file
+        );
+      })
+      .nodeify(callback);
+  },
+
   check: function (options, callback) {
     return Promise.all([
       File.loadFromDatabase(

package/package.json

@@ -31,7 +31,7 @@
     "programable",
     "api"
   ],
-  "version": "1.0.0-beta.22",
+  "version": "1.0.0-beta.24",
   "engines": {
     "node": ">=8.0.0"
   },