db-migrate 1.0.0-beta.16

package/get.js

@@ -0,0 +1,67 @@
+exports.migrate = async (db, opt) => {
+  await db.get('test', {
+    columns: ['column1']
+  });
+
+  /**
+   * columns can be aliased
+   */
+  await db.get('test', {
+    columns: {
+      column1: 'maxima'
+    }
+  });
+
+  /**
+   * We avoid tapping into complicated languages to define
+   * the where clause. Instead you just use SQL or mongo schema
+   * depending on the db you use. If you want to provide genericity we will
+   * suggest using helper libraries like sql2mongo or vice versa. This allows
+   * flexibility and avoids also the need to learn to many new things and
+   * reinventing the weel just for a translation layer in this case.
+   */
+  await db.get('test', {
+    columns: {
+      column1: 'maxima',
+      column2: 'something'
+    },
+    search: 'maxima >= 12'
+  });
+
+  /**
+   * However, the most simple operation we will support upfront. Everything
+   * else can use tooling. We will provide a plugin hook so this can be in
+   * doubt tightly integrated into the migrations.
+   */
+  await db.get('test', {
+    columns: {
+      column1: 'maxima',
+      column2: 'something'
+    },
+    search: {
+      maxima: 15
+    }
+  });
+
+  /**
+   * when doing more then searching, you want to access it in query mode.
+   * You will have to write the whole definition by hand. This guarantees
+   * that we still understand what is happening (type of operation), but
+   * gives ultimate flexibility.
+   *
+   * The table param is optional, when using for example SQL it will not be
+   * needed, databases like mongodb will need it however, so it might be
+   * recommended as a best practice to not omit it, depending on how ultimate
+   * the decision of the db is yet.
+   *
+   * Adding LIMITS yourself is possible, but leave this to db-migrate in doubt.
+   */
+  await db.get('test', {
+    query: 'DISTINCT value1 FROM test' // select will be forcefully prepended so we always know this will only get data
+  });
+};
+
+exports._meta = {
+  version: 2,
+  DML: true
+};

package/index.js

@@ -0,0 +1,85 @@
+module.exports.version = require('./package.json').version;
+
+var fs = require('fs');
+var path = require('path');
+var log = require('db-migrate-shared').log;
+
+exports.dataType = require('db-migrate-shared').dataType;
+
+function loadPluginList (options) {
+  try {
+    fs.accessSync(path.join(options.cwd, 'package.json'), fs.constants.R_OK);
+  } catch (err) {
+    throw new Error(
+      'There was no package.json found in the current working dir!',
+      options.cwd
+    );
+  }
+
+  try {
+    var plugins = JSON.parse(
+      fs.readFileSync(path.join(options.cwd, 'package.json'), 'utf-8')
+    );
+  } catch (err) {
+    throw new Error('Error parsing package.json', err);
+  }
+
+  var targets = [];
+
+  plugins = Object.assign(
+    plugins.dependencies || {},
+    plugins.devDependencies || {}
+  );
+
+  for (var plugin in plugins) {
+    if (plugin.startsWith('db-migrate-plugin')) targets.push(plugin);
+  }
+
+  return targets;
+}
+
+function loadPlugins (options) {
+  var plugins = loadPluginList(options);
+  var i = 0;
+  var length = plugins.length;
+  var hooks = {};
+
+  for (; i < length; ++i) {
+    var plugin = require(path.join(options.cwd, 'node_modules', plugins[i]));
+
+    if (!plugin.hooks || !plugin.loadPlugin) {
+      continue;
+    }
+
+    // name is now derived from package name
+    plugin.name = plugins[i];
+
+    plugin.hooks.forEach(function (hook) {
+      hooks[hook] = hooks[hook] || [];
+      hooks[hook].push(plugin);
+    });
+  }
+
+  return hooks;
+}
+
+module.exports.getInstance = function (isModule, options = {}, callback) {
+  delete require.cache[require.resolve('./api.js')];
+  delete require.cache[require.resolve('yargs')];
+  var Mod = require('./api.js');
+  var plugins = {};
+  options.cwd = options.cwd || process.cwd();
+
+  try {
+    if (!options || !options.noPlugins) plugins = loadPlugins(options);
+  } catch (ex) {
+    log.verbose('No plugin could be loaded!');
+    log.verbose(ex);
+  }
+
+  if (options && options.plugins) {
+    plugins = Object.assign(plugins, options.plugins);
+  }
+
+  return new Mod(plugins, isModule, options, callback);
+};

package/lib/chain.js

@@ -0,0 +1,157 @@
+const DEFAULT = [
+  'renameCollection',
+  'dropCollection',
+  'createCollection',
+  'createTable',
+  'dropTable',
+  'renameTable',
+  'addColumn',
+  'removeColumn',
+  'renameColumn',
+  'changeColumn',
+  'addIndex',
+  'removeIndex',
+  'addForeignKey',
+  '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 = [];
+    this.it = 0;
+    this._step = null;
+    this._interface = null;
+
+    DEFAULT.concat(Object.keys(this.context.learnable || [])).forEach(
+      method => {
+        this[method] = function (...args) {
+          // 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);
+  }
+
+  step () {
+    this._step = this.chains[this.it];
+    if (!this._step) return null;
+    if (!this.interfaces[this.it]) {
+      this.interfaces[this.it] = this._step.getInterface(
+        this.context,
+        this.file,
+        this.udriver,
+        this.internals
+      );
+    }
+
+    this._interface = this.interfaces[this.it++];
+    return this._step;
+  }
+
+  reset () {
+    this.it = 0;
+  }
+
+  async exec (m, ...args) {
+    let ret;
+    const stat = [];
+    while (this.step()) {
+      ret = await this._interface[m].apply(this._interface, args);
+      stat.push(ret);
+
+      if (this._step.hasStateUsage) {
+        this._step.useState(ret);
+      }
+
+      if (this._step.hasModification) {
+        const ret = this._step.modify(
+          this.context,
+          this.udriver,
+          this.internals
+        );
+
+        if (ret.driver) {
+          this.udriver = ret.driver;
+        }
+      }
+    }
+
+    this.reset();
+    return ret;
+  }
+}
+
+module.exports = Chain;

package/lib/class.js

@@ -0,0 +1,75 @@
+/* Simple JavaScript Inheritance
+ * By John Resig http://ejohn.org/
+ * MIT Licensed.
+ */
+// Inspired by base2 and Prototype
+var initializing = false;
+
+/*eslint-disable */
+var fnTest = /xyz/.test(function() {
+  xyz; // lgtm [js/useless-expression]
+})
+  ? /\b_super\b/
+  : /.*/;
+/* eslint-enable */
+
+// The base Class implementation (does nothing)
+var Class = function () {};
+
+// Create a new Class that inherits from this class
+Class.extend = function ext (prop) {
+  var _super = this.prototype;
+
+  // Instantiate a base class (but only create the instance,
+  // don't run the init constructor)
+  initializing = true;
+  var prototype = new this();
+  initializing = false;
+
+  // Copy the properties over onto the new prototype
+  for (var name in prop) {
+    // Check if we're overwriting an existing function
+    prototype[name] =
+      typeof prop[name] === 'function' &&
+      typeof _super[name] === 'function' &&
+      fnTest.test(prop[name])
+        ? (function (name, fn) {
+          return function () {
+            var tmp = this._super;
+
+            // Add a new ._super() method that is the same method
+            // but on the super-class
+            this._super = _super[name];
+
+            // The method only need to be bound temporarily, so we
+            // remove it when we're done executing
+            var ret = fn.apply(this, arguments);
+            this._super = tmp;
+
+            return ret;
+          };
+        })(name, prop[name])
+        : prop[name];
+  }
+
+  // The dummy class constructor
+  function Class () {
+    // All construction is actually done in the init method
+    if (!initializing && this.init) {
+      this.init.apply(this, arguments);
+    }
+  }
+
+  // Populate our constructed prototype object
+  Class.prototype = prototype;
+
+  // Enforce the constructor to be what we expect
+  Class.prototype.constructor = Class;
+
+  // And make this class extendable
+  Class.extend = ext;
+
+  return Class;
+};
+
+module.exports = Class;

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

package/lib/commands/create-migration.js

@@ -0,0 +1,252 @@
+'use strict';
+
+const Promise = require('bluebird');
+const log = require('db-migrate-shared').log;
+const mkdirp = Promise.promisify(require('mkdirp'));
+const fs = require('fs');
+const stat = Promise.promisify(fs.stat);
+const writeFile = Promise.promisify(fs.writeFile);
+const yargs = require('yargs');
+const util = require('util');
+const path = require('path');
+
+async function createMigrationDir (dir) {
+  const res = await stat(dir).catch(_ => {
+    return { err: true };
+  });
+  if (res && res.err === true) {
+    await mkdirp(dir);
+  }
+
+  // Create migrations/package.json to ensure migration files are
+  // executed as CJS and not ESM
+  // https://github.com/db-migrate/node-db-migrate/issues/721
+  const packageJsonPath = path.resolve(dir, 'package.json');
+
+  await stat(packageJsonPath).then(
+    async () => {
+      const packageJson = require(packageJsonPath);
+      packageJson.type = 'commonjs';
+      const packageJsonStr = JSON.stringify(packageJson, null, 2);
+      await writeFile(packageJsonPath, packageJsonStr, 'utf-8');
+    },
+    async (err) => {
+      const packageJson = JSON.stringify({
+        type: 'commonjs'
+      }, null, 2)
+      await writeFile(packageJsonPath, packageJson, 'utf-8');
+    }
+  )
+}
+
+async function executeCreateMigration (internals, config) {
+  let migrationsDir = internals.argv['migrations-dir'];
+  let path;
+  let hooks = false;
+  let pluginTemplate = false;
+  let customWrite = false;
+  const { plugins } = internals;
+
+  internals.runTimestamp = new Date();
+
+  if (internals.migrationMode && internals.migrationMode !== 'all') {
+    migrationsDir =
+      internals.argv['migrations-dir'] + '/' + internals.migrationMode;
+  }
+
+  if (internals.argv._.length === 0) {
+    log.error("'migrationName' is required.");
+    if (!internals.isModule) {
+      yargs.showHelp();
+    }
+
+    throw new Error("'migrationName' is required.");
+  }
+
+  const Migration = require('../template.js');
+
+  internals.argv.title = internals.argv._.shift();
+  const folder = internals.argv.title.toString().split('/');
+
+  internals.argv.title = folder[folder.length - 1] || folder[0];
+  path = migrationsDir;
+
+  if (folder.length > 1) {
+    path += '/';
+
+    for (let i = 0; i < folder.length - 1; ++i) {
+      path += folder[i] + '/';
+    }
+  }
+  internals.argv['migrations-dir'] = path;
+
+  try {
+    await createMigrationDir(path);
+  } catch (err) {
+    log.error('Failed to create migration directory at ', migrationsDir, err);
+    throw new Error('Failed to create migration directory.');
+  }
+
+  let templateType = Migration.TemplateType.DEFAULT_JS;
+  if (
+    shouldCreateSqlFiles(internals, config) &&
+    shouldCreateCoffeeFile(internals, config)
+  ) {
+    templateType = Migration.TemplateType.COFFEE_SQL_FILE_LOADER;
+  } else if (
+    shouldCreateSqlFiles(internals, config) &&
+    shouldIgnoreOnInitFiles(internals, config)
+  ) {
+    templateType = Migration.TemplateType.SQL_FILE_LOADER_IGNORE_ON_INIT;
+  } else if (shouldCreateSqlFiles(internals, config)) {
+    templateType = Migration.TemplateType.SQL_FILE_LOADER;
+  } else if (shouldCreateCoffeeFile(internals, config)) {
+    templateType = Migration.TemplateType.DEFAULT_COFFEE;
+  } else if (shouldCreateV2File(internals, config)) {
+    templateType = Migration.TemplateType.V2_DEFAULT;
+  }
+  if (plugins) {
+    hooks = plugins.hook('create:template') || [];
+  }
+
+  if (hooks !== false) {
+    for (const plugin of hooks) {
+      const template = plugin['init:template']();
+
+      if (internals.argv[template.option] || config[template.option]) {
+        pluginTemplate = plugin;
+        customWrite = plugin['create:template:custom:write'] === true;
+
+        if (customWrite) {
+          templateType = `${plugin.name}${templateType}`;
+        } else {
+          templateType = template.type;
+        }
+
+        // no reason to continue processing here
+        break;
+      }
+    }
+  }
+
+  if (!pluginTemplate && !customWrite) {
+    const migration = new Migration(
+      internals.argv.title +
+        (shouldCreateCoffeeFile(internals, config) ? '.coffee' : '.js'),
+      path,
+      internals.runTimestamp,
+      templateType,
+      internals.plugins
+    );
+
+    await migration.write();
+    log.info(util.format('Created migration at %s', migration.file.path));
+    if (shouldCreateSqlFiles(internals, config)) {
+      return createSqlFiles(internals, config);
+    }
+  } else {
+    const plugin = pluginTemplate;
+
+    if (typeof plugin['write:template'] !== 'function') {
+      log.error(`Plugin ${plugin.name} does not have function write:template`);
+      throw new Error(`write:template not existent!`);
+    }
+
+    await plugin['write:template'](
+      { argv: { ...internals.argv }, config: { ...config } },
+      async opts => {
+        let title = internals.argv.title;
+        let _path = path;
+        const extension = opts.extension || '.js';
+
+        if (opts.suffix) {
+          title += opts.suffix;
+        }
+
+        if (opts.pathExtension) {
+          _path += opts.pathExtension;
+        }
+
+        const migration = new Migration(
+          title + extension,
+          _path,
+          internals.runTimestamp,
+          opts.type,
+          internals.plugins
+        );
+        await migration.write();
+      }
+    );
+  }
+
+  return Promise.resolve();
+}
+
+function shouldCreateSqlFiles (internals, config) {
+  return internals.argv['sql-file'] || config['sql-file'];
+}
+
+function shouldIgnoreOnInitFiles (internals, config) {
+  return internals.argv['ignore-on-init'] || config['ignore-on-init'];
+}
+
+function shouldCreateCoffeeFile (internals, config) {
+  return internals.argv['coffee-file'] || config['coffee-file'];
+}
+
+function shouldCreateV2File (internals, config) {
+  return internals.argv['v2-file'] || config['v2-file'];
+}
+
+async function createSqlFiles (internals, config) {
+  let migrationsDir = internals.argv['migrations-dir'];
+
+  if (internals.migrationMode && internals.migrationMode !== 'all') {
+    migrationsDir =
+      internals.argv['migrations-dir'] + '/' + internals.migrationMode;
+  }
+
+  const sqlDir = migrationsDir + '/sqls';
+  try {
+    await createMigrationDir(sqlDir);
+  } catch (err) {
+    log.error('Failed to create migration directory at ', sqlDir, err);
+
+    throw err;
+  }
+
+  const Migration = require('../template.js');
+
+  const templateTypeDefaultSQL = Migration.TemplateType.DEFAULT_SQL;
+  const migrationUpSQL = new Migration(
+    internals.argv.title + '-up.sql',
+    sqlDir,
+    internals.runTimestamp,
+    templateTypeDefaultSQL,
+    internals.plugins
+  );
+  await migrationUpSQL.write();
+
+  log.info(
+    util.format('Created migration up sql file at %s', migrationUpSQL.file.path)
+  );
+
+  const migrationDownSQL = new Migration(
+    internals.argv.title + '-down.sql',
+    sqlDir,
+    internals.runTimestamp,
+    templateTypeDefaultSQL,
+    internals.plugins
+  );
+  migrationDownSQL.write();
+  log.info(
+    util.format(
+      'Created migration down sql file at %s',
+      migrationDownSQL.file.path
+    )
+  );
+
+  return Promise.resolve();
+}
+
+module.exports = executeCreateMigration;