db-migrate 1.0.0-beta.16

package/lib/state.js

@@ -0,0 +1,154 @@
+const MSTATE = '__dbmigrate_state__';
+const SSTATE = '__dbmigrate_schema__';
+const log = require('db-migrate-shared').log;
+
+module.exports = {
+  lockState: async function (driver, state, internals) {
+    if (!state) {
+      return driver._insertKV(
+        internals.migrationState,
+        MSTATE,
+        JSON.stringify({
+          s: {
+            step: 0,
+            fin: 0,
+            date: new Date()
+          }
+        })
+      );
+    } else {
+      state = state.value;
+      state = JSON.parse(state);
+      state.s.date = new Date();
+      return driver._updateKV(
+        internals.migrationState,
+        MSTATE,
+
+        JSON.stringify(state)
+      );
+    }
+  },
+
+  init: async function (driver, internals) {
+    await driver._createKV(internals.migrationState);
+    const schema = await driver._getKV(internals.migrationState, SSTATE);
+    if (schema) {
+      internals.schema = JSON.parse(schema.value);
+    } else {
+      await driver._insertKV(internals.migrationState, SSTATE, '{}');
+    }
+
+    if (!internals.dryRun) {
+      const state = await driver._getKV(internals.migrationState, MSTATE);
+      return module.exports.lockState(driver, state, internals);
+    }
+
+    return Promise.resolve();
+  },
+
+  startMigration: async function (driver, file, internals) {
+    const state = await driver._getKV(internals.migrationState, MSTATE);
+    const mig = await driver._getKV(internals.migrationState, file.name);
+
+    if (mig && mig.value !== '{}') {
+      internals.modSchema = JSON.parse(mig.value);
+    }
+
+    if (internals.dryRun) {
+      return Promise.resolve();
+    }
+
+    await module.exports.lockState(driver, state, internals);
+
+    if (!mig) {
+      return driver._insertKV(
+        internals.migrationState,
+        file.name,
+        JSON.stringify({})
+      );
+    } else {
+      return Promise.resolve();
+    }
+  },
+
+  update: async function (driver, file, state, internals) {
+    log.verbose(`[state] update state`);
+    if (internals.dryRun) {
+      return Promise.resolve();
+    }
+
+    await driver._updateKV(internals.migrationState, SSTATE, internals.schema);
+
+    return driver._updateKV(
+      internals.migrationState,
+      file.name,
+      JSON.stringify(state)
+    );
+  },
+
+  get: function (driver, file, internals) {
+    return driver._getKV(internals.migrationState, file.name);
+  },
+
+  tick: async function (driver, internals) {
+    if (internals.dryRun) {
+      return Promise.resolve();
+    }
+
+    let { value: state } = await driver._getKV(
+      internals.migrationState,
+      MSTATE
+    );
+    state = JSON.parse(state);
+    state.s.date = new Date();
+    return driver._updateKV(
+      internals.migrationState,
+      MSTATE,
+      JSON.stringify(state)
+    );
+  },
+
+  step: async function (driver, step, internals) {
+    log.verbose(`[state] proceeded to step ${step}`);
+    if (internals.dryRun) {
+      return Promise.resolve();
+    }
+
+    let { value: state } = await driver._getKV(
+      internals.migrationState,
+      MSTATE
+    );
+    state = JSON.parse(state);
+    state.s.date = new Date();
+    state.s.step = step;
+    return driver._updateKV(
+      internals.migrationState,
+      MSTATE,
+      JSON.stringify(state)
+    );
+  },
+
+  deleteState: function (driver, file, internals) {
+    return driver._deleteKV(internals.migrationState, file.name);
+  },
+
+  endMigration: async function (driver, file, internals) {
+    if (internals.dryRun) {
+      return Promise.resolve();
+    }
+
+    let { value: state } = await driver._getKV(
+      internals.migrationState,
+      MSTATE
+    );
+    state = JSON.parse(state);
+    state.s.date = new Date();
+    state.s.fin = 1;
+
+    return driver._updateKV(
+      internals.migrationState,
+      MSTATE,
+      JSON.stringify(state)
+    );
+  }
+};

package/lib/template.js

@@ -0,0 +1,312 @@
+'use strict';
+
+const File = require('./file.js');
+const { util: dbmUtil, log } = require('db-migrate-shared');
+
+const Template = function () {
+  if (arguments[4] && typeof arguments[4].overwrite === 'function') {
+    this.plugins = arguments[4];
+    arguments[4] = undefined;
+    arguments.length--;
+  }
+  this.templateType = arguments[3];
+  // this is a tweak for node 4 this can be translated
+  // to ...arguments instead in upcoming node versions
+  const Comp = File.bind.apply(File, [null].concat(dbmUtil.toArray(arguments)));
+  this.file = new Comp();
+};
+
+Template.prototype.defaultCoffeeTemplate = function () {
+  return [
+    "'use strict';",
+    '',
+    'dbm = undefined',
+    'type = undefined',
+    'seed = undefined',
+    '',
+    'exports.setup = (options, seedLink) ->',
+    '  dbm = options.dbmigrate',
+    '  type = dbm.dataType',
+    '  seed = seedLink',
+    '',
+    'exports.up = (db) ->',
+    '  null',
+    '',
+    'exports.down = (db) ->',
+    '  null',
+    '',
+    ''
+  ].join('\n');
+};
+
+Template.prototype.defaultJsTemplate = function () {
+  return [
+    "'use strict';",
+    '',
+    'var dbm;',
+    'var type;',
+    'var seed;',
+    '',
+    '/**',
+    '  * We receive the dbmigrate dependency from dbmigrate initially.',
+    '  * This enables us to not have to rely on NODE_PATH.',
+    '  */',
+    'exports.setup = function(options, seedLink) {',
+    '  dbm = options.dbmigrate;',
+    '  type = dbm.dataType;',
+    '  seed = seedLink;',
+    '};',
+    '',
+    'exports.up = function(db) {',
+    '  return null;',
+    '};',
+    '',
+    'exports.down = function(db) {',
+    '  return null;',
+    '};',
+    '',
+    'exports._meta = {',
+    '  "version": 1',
+    '};',
+    ''
+  ].join('\n');
+};
+
+Template.prototype.defaultSqlTemplate = function () {
+  return '/* Replace with your SQL commands */';
+};
+
+Template.prototype.sqlFileLoaderTemplate = function () {
+  return [
+    "'use strict';",
+    '',
+    'var dbm;',
+    'var type;',
+    'var seed;',
+    "var fs = require('fs');",
+    "var path = require('path');",
+    'var Promise;',
+    '',
+    '/**',
+    '  * We receive the dbmigrate dependency from dbmigrate initially.',
+    '  * This enables us to not have to rely on NODE_PATH.',
+    '  */',
+    'exports.setup = function(options, seedLink) {',
+    '  dbm = options.dbmigrate;',
+    '  type = dbm.dataType;',
+    '  seed = seedLink;',
+    '  Promise = options.Promise;',
+    '};',
+    '',
+    'exports.up = function(db) {',
+    "  var filePath = path.join(__dirname, 'sqls', '" +
+      this.file.name.replace('.js', '') +
+      "-up.sql');",
+    '  return new Promise( function( resolve, reject ) {',
+    "    fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){",
+    '      if (err) return reject(err);',
+    "      console.log('received data: ' + data);",
+    '',
+    '      resolve(data);',
+    '    });',
+    '  })',
+    '  .then(function(data) {',
+    '    return db.runSql(data);',
+    '  });',
+    '};',
+    '',
+    'exports.down = function(db) {',
+    "  var filePath = path.join(__dirname, 'sqls', '" +
+      this.file.name.replace('.js', '') +
+      "-down.sql');",
+    '  return new Promise( function( resolve, reject ) {',
+    "    fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){",
+    '      if (err) return reject(err);',
+    "      console.log('received data: ' + data);",
+    '',
+    '      resolve(data);',
+    '    });',
+    '  })',
+    '  .then(function(data) {',
+    '    return db.runSql(data);',
+    '  });',
+    '};',
+    '',
+    'exports._meta = {',
+    '  "version": 1',
+    '};',
+    ''
+  ].join('\n');
+};
+
+Template.prototype.sqlFileLoaderIgnoreOnInitTemplate = function () {
+  return [
+    "'use strict';",
+    '',
+    'var dbm;',
+    'var type;',
+    'var seed;',
+    "var fs = require('fs');",
+    "var path = require('path');",
+    'var ignoreOnInit = false;',
+    'var Promise;',
+    '',
+    '/**',
+    '  * We receive the dbmigrate dependency from dbmigrate initially.',
+    '  * This enables us to not have to rely on NODE_PATH.',
+    '  */',
+    'exports.setup = function(options, seedLink) {',
+    '  dbm = options.dbmigrate;',
+    '  ignoreOnInit = options.ignoreOnInit;',
+    '  type = dbm.dataType;',
+    '  seed = seedLink;',
+    '  Promise = options.Promise;',
+    '};',
+    '',
+    'exports.up = function(db, callback) {',
+    "  var filePath = path.join(__dirname + '/sqls/" +
+      this.file.name.replace('.js', '') +
+      "-up.sql');",
+    '  if (!ignoreOnInit) {',
+    '    return new Promise( function( resolve, reject ) {',
+    "       fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){",
+    '         if (err) return reject(err);',
+    "         console.log('received data: ' + data);",
+    '',
+    '         resolve(data);',
+    '       });',
+    '    })',
+    '    .then(function(data) {',
+    '      return db.runSql(data);',
+    '    });',
+    '  }',
+    '  else {',
+    "   console.log('ignoring on init: ' + filePath)",
+    '   return null;',
+    '  }',
+    '};',
+    '',
+    'exports.down = function(db, callback) {',
+    "  var filePath = path.join(__dirname + '/sqls/" +
+      this.file.name.replace('.js', '') +
+      "-down.sql');",
+    '  return new Promise( function( resolve, reject ) {',
+    "    fs.readFile(filePath, {encoding: 'utf-8'}, function(err,data){",
+    '      if (err) return reject(err);',
+    "      console.log('received data: ' + data);",
+    '',
+    '      resolve(data);',
+    '    });',
+    '  })',
+    '  .then(function(data) {',
+    '    return db.runSql(data);',
+    '  });',
+    '};',
+    '',
+    'exports._meta = {',
+    '  "version": 1',
+    '};',
+    ''
+  ].join('\n');
+};
+
+Template.prototype.coffeeSqlFileLoaderTemplate = function () {
+  return [
+    "'use strict';",
+    '',
+    'dbm = undefined',
+    'type = undefined',
+    'seed = undefined',
+    "fs = require 'fs'",
+    "path = require 'path'",
+    '',
+    '#',
+    '# We receive the dbmigrate dependency from dbmigrate initially.',
+    '# This enables us to not have to rely on NODE_PATH.',
+    '#',
+    'exports.setup = (options, seedLink) ->',
+    '  dbm = options.dbmigrate',
+    '  type = dbm.dataType',
+    '  seed = seedLink',
+    '',
+    '',
+    'exports.up = (db, callback) ->',
+    '  filePath = path.join "#{__dirname}/sqls/' +
+      this.file.name.replace('.coffee', '') +
+      '-up.sql"',
+    "  fs.readFile filePath, {encoding: 'utf-8'}, (err,data) ->",
+    '    return callback err if err',
+    '',
+    '    db.runSql data, callback',
+    '',
+    'exports.down = (db, callback) ->',
+    '  filePath = path.join "#{__dirname}/sqls/' +
+      this.file.name.replace('.coffee', '') +
+      '-down.sql"',
+
+    "  fs.readFile filePath, {encoding: 'utf-8'}, (err,data) ->",
+    '    return callback err if err',
+    '',
+    '    db.runSql data, callback',
+    ''
+  ].join('\n');
+};
+
+Template.TemplateType = {
+  DEFAULT_JS: 0,
+  DEFAULT_SQL: 1,
+  SQL_FILE_LOADER: 2,
+  DEFAULT_COFFEE: 3,
+  COFFEE_SQL_FILE_LOADER: 4,
+  SQL_FILE_LOADER_IGNORE_ON_INIT: 5,
+  V2_DEFAULT: 6
+};
+
+Template.prototype.getTemplate = function () {
+  let plugin = false;
+
+  switch (this.templateType) {
+    case Template.TemplateType.DEFAULT_SQL:
+      return this.defaultSqlTemplate();
+    case Template.TemplateType.SQL_FILE_LOADER:
+      return this.sqlFileLoaderTemplate();
+    case Template.TemplateType.DEFAULT_COFFEE:
+      return this.defaultCoffeeTemplate();
+    case Template.TemplateType.COFFEE_SQL_FILE_LOADER:
+      return this.coffeeSqlFileLoaderTemplate();
+    case Template.TemplateType.SQL_FILE_LOADER_IGNORE_ON_INIT:
+      return this.sqlFileLoaderIgnoreOnInitTemplate();
+    case Template.TemplateType.DEFAULT_JS:
+      return this.defaultJsTemplate();
+    case Template.TemplateType.V2_DEFAULT:
+      return require('./templates/v2.js')();
+    default:
+      if (this.plugins) {
+        plugin = this.plugins.overwrite(
+          `template:overwrite:provider:${this.templateType}`
+        );
+      }
+
+      if (plugin !== false) {
+        try {
+          return plugin[`template:overwrite:provider:${this.templateType}`]({
+            file: {
+              name: this.file.name
+            }
+          });
+        } catch (ex) {
+          log.error('Plugin failure "' + plugin.name + '", arborting!');
+
+          throw ex;
+        }
+      } else {
+        return this.defaultJsTemplate();
+      }
+  }
+};
+
+Template.prototype.write = function (callback) {
+  return this.file.write(this.getTemplate()).nodeify(callback);
+};
+
+module.exports = Template;

package/lib/templates/v2.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = () => `'use strict';
+
+exports.migrate = async (db, opt) => {
+  const type = opt.dbm.dataType;
+  return null;
+};
+
+exports._meta = {
+  version: 2
+};`;

package/lib/temputils.js

@@ -0,0 +1,62 @@
+'use strict';
+
+function isPromise (probe) {
+  return (
+    probe instanceof Promise ||
+    (probe &&
+      probe.then &&
+      probe.constructor &&
+      probe.constructor.name === 'Promise')
+  );
+}
+
+/**
+ * Backwards compatibility function.
+ *
+ * This ensures old migrations can still be executed by allowing them
+ * to still use callbacks or promises. This function ensures that every
+ * execution context may be returned only once (since callbacks can be called
+ * multiple times) and is basically FI(-only-)FO function.
+ */
+function maybePromised (context, action, params) {
+  let cbExecuted = false;
+
+  return new Promise((resolve, reject) => {
+    const r = err => {
+      if (cbExecuted === false) {
+        cbExecuted = true;
+
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      }
+    };
+
+    params[params.length++] = r;
+
+    if (typeof action === 'function') action = action.apply(context, params);
+    if (action === null) action = Promise.resolve();
+
+    if (isPromise(action)) {
+      action
+        .then(() => {
+          if (cbExecuted === false) {
+            cbExecuted = true;
+            resolve();
+          }
+        })
+        .catch(err => {
+          if (cbExecuted === false) {
+            cbExecuted = true;
+            reject(err);
+          }
+        });
+    }
+  });
+}
+
+module.exports = {
+  maybePromised: maybePromised
+};