db-migrate 1.0.0-beta.9 → 1.0.0

package/lib/walker.js

@@ -6,36 +6,38 @@ const log = require('db-migrate-shared').log;
 const Promise = require('bluebird');
 const File = require('./file.js');
 
-// Not sure what will happen to this yet
-function SeedLink (driver, internals) {
-  this.seeder = require('./seeder.js')(
-    driver,
-    internals.argv['vcseeder-dir'],
-    true,
-    internals
-  );
-  this.internals = internals;
-  this.links = [];
-}
-
 const INTERFACES = {
   migration: require('./interface/migratorInterface.js'),
   seed: require('./interface/seederInterface.js'),
   'static-seed': require('./interface/seederInterface.js')
 };
 
-const Walker = function (driver, directory, mode, intern, prefix) {
+/**
+ * Name the migration an error belongs to, for the error output.
+ */
+const failedIn = file => err => {
+  if (err && typeof err === 'object' && err.migration === undefined) {
+    err.migration = file.name;
+  }
+
+  throw err;
+};
+
+const Walker = function (driver, directory, mode, intern, prefix, opts = {}) {
   this.driver = dbmUtil.reduceToInterface(driver, INTERFACES[prefix]);
   this._driver = driver;
+  this._pdriver = opts.db2;
   Promise.promisifyAll(this._driver);
+  Promise.promisifyAll(this._pdriver);
   this.directory = directory;
   this.internals = intern;
   /**
    * i: index
    * c: schema
    * f: foreignKey
+   * e: extra items for the schema (like ENUM types)
    */
-  this.internals.schema = { i: {}, c: {}, f: {} };
+  this.internals.schema = { i: {}, c: {}, f: {}, e: {} };
   /**
    * s: commands
    * i: index
@@ -51,19 +53,17 @@ const Walker = function (driver, directory, mode, intern, prefix) {
   this.title = `[${prefix}] `;
 
   // keep it until we decide how we do the cross linking
-  if (intern.linked === false) {
-    this.seedLink = new SeedLink(driver, intern);
-    intern.linked = true;
-  }
 };
 
 Walker.prototype = {
-  createTables: async function () {
-    await State.init(this._driver, this.internals);
-    return this._driver._createList(this.internals.migrationTable);
+  createTables: async function (options) {
+    await State.init(this._pdriver, this.internals, options);
+    return State.createConcurrently(() =>
+      this._driver._createList(this.internals.migrationTable)
+    );
   },
 
-  createMigrationsTable: function () {
+  createMigrationsTable: function (options = {}) {
     if (
       typeof this._driver._createList !== 'function' ||
       typeof this._driver._getList !== 'function' ||
@@ -84,7 +84,53 @@ Walker.prototype = {
       }
     }
 
-    return this.createTables();
+    return this.createTables(options);
+  },
+
+  /**
+   * Determine what to run first, only lock when there is actually something
+   * to run. If another process holds the lock, wait for its release and
+   * determine again, the other process might have done the work already.
+   * Once we hold the lock, state and pending migrations are read again.
+   */
+  _withLock: async function (determine, run) {
+    if (this.prefix !== 'migration' || this.internals.dryRun) {
+      return run(await determine());
+    }
+
+    if (!State.supportsLock(this._pdriver)) {
+      log.warn(
+        this.title +
+          'Your database driver does not support migration locking, ' +
+          'concurrent processes are not prevented from migrating at the ' +
+          'same time. Update your driver to a version supporting it.'
+      );
+      return run(await determine());
+    }
+
+    let stale = null;
+    let toRun = await determine();
+
+    while (toRun.length > 0) {
+      if (await State.acquire(this._pdriver, this.internals, stale)) {
+        break;
+      }
+
+      log.info(this.title + 'Waiting for the migration lock of another process');
+      stale = await State.waitForRelease(this._pdriver, this.internals);
+      toRun = await determine();
+    }
+
+    if (toRun.length === 0) {
+      return run(toRun);
+    }
+
+    try {
+      await State.reloadSchema(this._pdriver, this.internals);
+      return await run(await determine());
+    } finally {
+      await State.release(this._pdriver, this.internals);
+    }
   },
 
   writeMigrationRecord: function (migration, callback) {
@@ -146,96 +192,156 @@ Walker.prototype = {
   up: function (options, callback) {
     const partialName = options.destination;
     const count = options.count;
-    const files = Promise.all([
-      File.loadFromFileystem(this.directory, this.prefix, this.internals),
+    const determine = () =>
+      Promise.all([
+        File.loadFromFileystem(this.directory, this.prefix, this.internals),
+        File.loadFromDatabase(
+          this.directory,
+          this.prefix,
+          this._driver,
+          this.internals
+        )
+      ]).spread((allFiles, completedFiles) =>
+        dbmUtil.filterUp(allFiles, completedFiles, partialName, count)
+      );
+
+    if (this.internals.check) {
+      return determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
+    }
+
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
+        }
+
+        return Promise.each(toRun, file => {
+          log.verbose(this.title + 'preparing to run up:', file.name);
+          const _meta = file.get()._meta || {};
+          const version = _meta.version || 1;
+          this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+          return Promise.resolve(
+            require(`./executors/versioned/v${version}`).up(
+              this,
+              this.driver,
+              file
+            )
+          ).catch(failedIn(file));
+        });
+      })
+    ).nodeify(callback);
+  },
+
+  down: function (options, callback) {
+    const partialName = options.destination;
+    const count = options.count;
+    const determine = () =>
       File.loadFromDatabase(
         this.directory,
         this.prefix,
         this._driver,
         this.internals
-      )
-    ]).spread((allFiles, completedFiles) => {
-      const toRun = dbmUtil.filterUp(
-        allFiles,
-        completedFiles,
-        partialName,
-        count
+      ).then(completedFiles =>
+        dbmUtil.filterDown(completedFiles, partialName, count)
       );
 
-      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 determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
     }
 
-    return files
-      .each(file => {
-        log.verbose(this.title + 'preparing to run up:', file.name);
-        const _meta = file.get()._meta || {};
-        const version = _meta.version || 1;
-        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
-        return require(`./executors/versioned/v${version}`).up(
-          this,
-          this.driver,
-          file
-        );
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
+        }
+
+        return Promise.each(toRun, file => {
+          log.verbose(this.title + 'preparing to run down:', file.name);
+          const _meta = file.get()._meta || {};
+          const version = _meta.version || 1;
+          this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
+          return Promise.resolve(
+            require(`./executors/versioned/v${version}`).down(
+              this,
+              this.driver,
+              file
+            )
+          ).catch(failedIn(file));
+        });
       })
-      .nodeify(callback);
+    ).nodeify(callback);
   },
 
-  down: function (options, 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('-'));
 
-    const files = File.loadFromDatabase(
-      this.directory,
-      this.prefix,
-      this._driver,
-      this.internals
-    ).then(completedFiles => {
-      const toRun = dbmUtil.filterDown(completedFiles, partialName, count);
-
-      if (toRun.length === 0) {
-        log.info(this.title + 'Nothing to run');
+      if (!isNaN(a)) {
+        return a - b;
       }
 
-      if (this.internals.check) {
-        const toRunNames = toRun.map(migration => migration.name);
-        log.info(this.title + 'run:', toRunNames);
-        return toRunNames;
-      }
+      return a.localeCompare(b);
+    };
 
-      return toRun;
-    });
+    const determine = () =>
+      File.loadFromDatabase(
+        this.directory,
+        this.prefix,
+        this._driver,
+        this.internals
+      ).then(completedFiles =>
+        dbmUtil.filterDown(completedFiles, partialName, count).sort(sortFn)
+      );
 
     if (this.internals.check) {
-      return files.nodeify(callback);
+      return determine()
+        .then(toRun => this._checkResult(toRun))
+        .nodeify(callback);
     }
 
-    return files
-      .each(file => {
-        log.verbose(this.title + 'preparing to run down:', file.name);
-        const _meta = file.get()._meta || {};
-        const version = _meta.version || 1;
-        this.internals.modSchema = { i: {}, c: {}, f: {}, s: [] };
-        return require(`./executors/versioned/v${version}`).down(
-          this,
-          this.driver,
-          file
-        );
+    return Promise.resolve(
+      this._withLock(determine, toRun => {
+        if (toRun.length === 0) {
+          log.info(this.title + 'Nothing to run');
+        }
+
+        return Promise.each(toRun, 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 Promise.resolve(
+            require(`./executors/versioned/v${version}`).fix(
+              this,
+              this.driver,
+              file
+            )
+          ).catch(failedIn(file));
+        });
       })
-      .nodeify(callback);
+    ).nodeify(callback);
+  },
+
+  _checkResult: function (toRun) {
+    if (toRun.length === 0) {
+      log.info(this.title + 'Nothing to run');
+    }
+
+    const toRunNames = toRun.map(migration => migration.name);
+    log.info(this.title + 'run:', toRunNames);
+    return toRunNames;
   },
 
   check: function (options, callback) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "db-migrate",
   "description": "Database migration framework for node.js",
-  "author": "Tobias Gurtick",
+  "author": "Tobias Gurtzick",
   "bin": "./bin/db-migrate",
   "keywords": [
     "database",
@@ -27,14 +27,11 @@
     "seeds",
     "seeder",
     "migrator",
-    "programatic",
-    "programable",
+    "programmatic",
+    "programmable",
     "api"
   ],
-  "version": "1.0.0-beta.9",
-  "engines": {
-    "node": ">=8.0.0"
-  },
+  "version": "1.0.0",
   "bugs": {
     "url": "https://github.com/db-migrate/node-db-migrate/issues"
   },
@@ -44,32 +41,31 @@
     "url": "https://github.com/db-migrate/node-db-migrate.git"
   },
   "dependencies": {
-    "bluebird": "^3.1.1",
+    "bluebird": "^3.7.2",
     "db-migrate-shared": "^1.2.0",
     "deep-extend": "^0.6.0",
-    "dotenv": "^5.0.1",
+    "dotenv": "^16.3.1",
     "final-fs": "^1.6.0",
     "inflection": "^1.10.0",
-    "mkdirp": "~0.5.0",
     "parse-database-url": "~0.3.0",
     "rc": "^1.2.8",
-    "resolve": "^1.1.6",
-    "semver": "^5.3.0",
-    "tunnel-ssh": "^4.0.0",
-    "yargs": "^15.3.1"
+    "resolve": "^1.19.0",
+    "yargs": "^17.5.1"
   },
   "devDependencies": {
-    "@hapi/code": "5.x",
-    "@hapi/lab": "18.x",
+    "@babel/eslint-parser": "^7.21.8",
+    "@hapi/code": "9.x",
+    "@hapi/eslint-plugin": "^6.0.0",
+    "@hapi/lab": "25.x",
     "db-migrate-base": "^2.1.1",
-    "db-migrate-mysql": "^2.1.1",
-    "db-migrate-sqlite3": "^0.4.0",
-    "eslint": "^6.8.0",
+    "db-migrate-mysql": "^2.2.0",
+    "db-migrate-sqlite3": "^0.5.0",
+    "eslint": "^7.32.0",
     "eslint-config-standard": "^14.1.1",
-    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.1",
+    "eslint-plugin-promise": "^4.3.1",
+    "eslint-plugin-standard": "^4.1.0",
     "proxyquire": "^1.4.0",
     "rimraf": "^3.0.2",
     "sinon": "^9.0.2"