@oliasoft-open-source/node-json-migrator 2.0.0

package/dist/git/git.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlanRevisionsFromGit = exports.getPlanFromGit = exports.getHistoricalPlansFromGit = exports.exec = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _child_process = require("child_process");
+
+var _hash = require("../hash/hash");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const exec = command => new Promise((resolve, reject) => {
+  const args = ['-c', command];
+  const thread = (0, _child_process.spawn)('bash', args, {
+    stdio: ['inherit', 'pipe', 'pipe']
+  });
+  const stdOut = [];
+  const stdErr = [];
+  thread.stdout.on('data', data => {
+    stdOut.push(data.toString());
+  });
+  thread.stderr.on('data', data => {
+    stdErr.push(data.toString());
+  });
+  thread.on('close', () => {
+    if (stdErr.length) {
+      reject(stdErr.join(''));
+      return;
+    }
+
+    resolve(stdOut.join(''));
+  });
+});
+
+exports.exec = exec;
+
+const getPlanRevisionsFromGit = async planFilePath => {
+  const stdOut = await exec(`git rev-list --pretty='format:%H|%ad' HEAD ${planFilePath}`);
+  const lines = stdOut.split(/\r\n|\r|\n/).filter(r => r === null || r === void 0 ? void 0 : r.includes('|'));
+  return lines.map(line => {
+    const [version, timeStamp] = line.split('|');
+    const utcTimeStamp = new Date(timeStamp).toISOString();
+    return {
+      version,
+      timeStamp: utcTimeStamp
+    };
+  });
+};
+
+exports.getPlanRevisionsFromGit = getPlanRevisionsFromGit;
+
+const getPlanFromGit = async (planFilePath, revision) => {
+  return exec(`git show ${revision}:${planFilePath}`);
+};
+
+exports.getPlanFromGit = getPlanFromGit;
+
+const getHistoricalPlansFromGit = async planFilePath => {
+  try {
+    const revisions = await getPlanRevisionsFromGit(planFilePath);
+    const historicalPlans = await Promise.all(revisions.map(async revision => {
+      const plan = await getPlanFromGit(planFilePath, revision.version);
+      const version = (0, _hash.hash)(plan);
+      return {
+        revision,
+        version,
+        plan
+      };
+    }));
+    return {
+      historicalPlans
+    };
+  } catch (error) {
+    console.error(_chalk.default.red(error));
+    throw new Error('Unable to fetch plan.json history from git');
+  }
+};
+
+exports.getHistoricalPlansFromGit = getHistoricalPlansFromGit;

package/dist/glob/glob.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortFilePathsByFilename = exports.getUniqueSkippedFileNames = exports.getSkippedFilePaths = exports.getMigrationFilePaths = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _globPromise = _interopRequireDefault(require("glob-promise"));
+
+var _lodash = require("lodash");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const matchSkip = /(.skip|.skip\d+).js$/g;
+/**
+ * Sorts migration file paths
+ *
+ * @param {Array<String>} filePaths
+ * @returns {Array<String>} sorted files
+ */
+
+const sortFilePathsByFilename = filePaths => (0, _lodash.sortBy)(filePaths, file => {
+  return _path.default.parse(file).base;
+});
+/**
+ * Gets paths to entity migrations in a directory
+ *
+ * @param {String} pathToMigrations
+ * @returns {Promise<Array<String>>} matching migration filePaths
+ */
+
+
+exports.sortFilePathsByFilename = sortFilePathsByFilename;
+
+const getMigrationFilePaths = async pathToMigrations => {
+  const filePath = pattern => `${pathToMigrations}${pattern}`;
+
+  const filePaths = await (0, _globPromise.default)(filePath('/**/*.js'), {
+    ignore: [filePath('/**/*.skip?([0-9]*).js'), filePath('/**/index.js'), filePath('/**/plan.json'), filePath('/**/*.bundle.js'), filePath('/**/*.test.js'), filePath('/**/*.spec.js'), filePath('/**/__tests__/*'), filePath('/**/__test__/*')]
+  });
+  return sortFilePathsByFilename(filePaths);
+};
+/**
+ * Gets paths to skipped migrations in a directory
+ *
+ * @param {String} pathToMigrations
+ * @returns {Promise<Array<String>>} skipped migration filePaths
+ */
+
+
+exports.getMigrationFilePaths = getMigrationFilePaths;
+
+const getSkippedFilePaths = async pathToMigrations => {
+  const filePath = pattern => `${pathToMigrations}${pattern}`;
+
+  const filePaths = await (0, _globPromise.default)(filePath('/**/*.skip?([0-9]*).js'), {
+    ignore: [filePath('/**/index.js'), filePath('/**/plan.json'), filePath('/**/*.bundle.js'), filePath('/**/*.test.js'), filePath('/**/*.spec.js'), filePath('/**/__tests__/*'), filePath('/**/__test__/*')]
+  });
+  return sortFilePathsByFilename(filePaths);
+};
+
+exports.getSkippedFilePaths = getSkippedFilePaths;
+
+const getUniqueSkippedFileNames = skippedPaths => {
+  const fileNames = skippedPaths.map(p => _path.default.parse(p).base.replace(matchSkip, '.js'));
+  return Array.from(new Set(fileNames));
+};
+
+exports.getUniqueSkippedFileNames = getUniqueSkippedFileNames;

package/dist/hash/hash.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hash = void 0;
+
+var crypto = _interopRequireWildcard(require("crypto"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Generate SHA256 hash from a string
+ *
+ * @param {String} string
+ * @returns {String} SHA256 hash
+ */
+const hash = string => crypto.createHash('sha256').update(string).digest('hex');
+
+exports.hash = hash;

package/dist/history/history.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.printVersionHistory = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _git = require("../git/git");
+
+var _database = require("../database/database");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Parse plan.json
+ *
+ * @param {string} plan
+ * @returns object|null parsed plan
+ */
+const parsePlan = plan => {
+  return (() => {
+    try {
+      return JSON.parse(plan);
+    } catch (e) {
+      console.error('Unable to parse plan.json');
+      return null;
+    }
+  })();
+};
+/**
+ * @typedef {Object} Configuration
+ * @property {string} directory (path to migrations directory)
+ * @property {string} entity (entity name for payload, e.g. dataset)
+ * @property {Object} database (connected pg-promise database)
+ */
+
+/**
+ * Prints the version history of plan.json (for debugging)
+ *
+ * @param {Object} args
+ * @param {Configuration} args.config
+ */
+
+
+const printVersionHistory = async ({
+  config
+}) => {
+  const {
+    database,
+    entity,
+    directory
+  } = config;
+
+  try {
+    const planFilePath = `${directory}/plan.json`; //read version history from database cache
+
+    const versionHistoryFromDatabase = await (0, _database.getVersions)(database, entity);
+    const fullDatabaseVersionHistory = versionHistoryFromDatabase.map(d => {
+      const plan = parsePlan(d === null || d === void 0 ? void 0 : d.plan);
+      const finalMigration = plan !== null && plan !== void 0 && plan.length ? plan[plan.length - 1] : null;
+      return {
+        planVersion: d === null || d === void 0 ? void 0 : d.version,
+        lastFileName: (finalMigration === null || finalMigration === void 0 ? void 0 : finalMigration.fileName) || null,
+        lastSequence: (finalMigration === null || finalMigration === void 0 ? void 0 : finalMigration.sequence) || null
+      };
+    }); //read full version history from git logs (back to beginning of time)
+
+    const {
+      historicalPlans: fullHistoricalPlans
+    } = await (0, _git.getHistoricalPlansFromGit)(planFilePath);
+    const fullGitVersionHistory = fullHistoricalPlans.map(p => {
+      var _p$revision, _p$revision2;
+
+      const plan = parsePlan(p === null || p === void 0 ? void 0 : p.plan);
+      const finalMigration = plan !== null && plan !== void 0 && plan.length ? plan[plan.length - 1] : null;
+      return {
+        gitCommitHash: p === null || p === void 0 ? void 0 : (_p$revision = p.revision) === null || _p$revision === void 0 ? void 0 : _p$revision.version,
+        planVersion: p === null || p === void 0 ? void 0 : p.version,
+        timeStamp: p === null || p === void 0 ? void 0 : (_p$revision2 = p.revision) === null || _p$revision2 === void 0 ? void 0 : _p$revision2.timeStamp,
+        lastFileName: (finalMigration === null || finalMigration === void 0 ? void 0 : finalMigration.fileName) || null,
+        lastSequence: (finalMigration === null || finalMigration === void 0 ? void 0 : finalMigration.sequence) || null
+      };
+    });
+    const output = {
+      fullDatabaseVersionHistory,
+      fullGitVersionHistory
+    };
+    console.log(JSON.stringify(output, null, 2));
+  } catch (error) {
+    console.error(_chalk.default.red(error));
+    throw new Error('Unable to print debug history');
+  }
+};
+
+exports.printVersionHistory = printVersionHistory;

package/dist/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createMigration", {
+  enumerable: true,
+  get: function () {
+    return _create.createMigration;
+  }
+});
+Object.defineProperty(exports, "getPlannedMigrations", {
+  enumerable: true,
+  get: function () {
+    return _plan.getPlannedMigrations;
+  }
+});
+Object.defineProperty(exports, "getPlannedVersion", {
+  enumerable: true,
+  get: function () {
+    return _plannedVersion.getPlannedVersion;
+  }
+});
+Object.defineProperty(exports, "getVersions", {
+  enumerable: true,
+  get: function () {
+    return _database.getVersions;
+  }
+});
+Object.defineProperty(exports, "migrate", {
+  enumerable: true,
+  get: function () {
+    return _migrate.migrate;
+  }
+});
+Object.defineProperty(exports, "pipe", {
+  enumerable: true,
+  get: function () {
+    return _pipe.pipe;
+  }
+});
+Object.defineProperty(exports, "printVersionHistory", {
+  enumerable: true,
+  get: function () {
+    return _history.printVersionHistory;
+  }
+});
+
+var _create = require("./create/create");
+
+var _plan = require("./plan/plan");
+
+var _plannedVersion = require("./plan/planned-version");
+
+var _migrate = require("./migrate/migrate");
+
+var _pipe = require("./pipe/pipe");
+
+var _database = require("./database/database");
+
+var _history = require("./history/history");

package/dist/migrate/migrate.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.migrate = void 0;
+
+var _pipe = require("../pipe/pipe");
+
+var _pending = require("../pending/pending");
+
+/**
+ * @typedef {Array|Object} Payload
+ */
+
+/**
+ * @typedef {Object} PlannedMigrations
+ * @property {Array<function>} plannedMigrations (planned migrations)
+ * @property {string} nextVersion (next payload version)
+ */
+
+/**
+ * @typedef {Object} Configuration
+ * @property {string} directory (path to migrations directory)
+ * @property {string} entity (entity name for payload, e.g. dataset)
+ * @property {string} [version] (current payload version)
+ * @property {boolean} [force] (override validation)
+ * @property {boolean} [dry] (don't alter database or files)
+ * @property {Object} [database] (connected pg-promise database)
+ * @property {Object} [pgpHelpers] (pg-promise helpers)
+ * @property {PlannedMigrations} [plan]
+ */
+
+/**
+ * Migrates a payload
+ *
+ * There are two ways to use this function:
+ * i) function looks up the pending migrations for you (default)
+ * ii) pass in pre-fetched pending migrators via config.pending
+ *
+ * @param {Object} args
+ * @param {Payload} args.payload
+ * @param {Configuration} args.config
+ * @returns Promise<{nextPayload: Payload, nextVersion: string}>
+ */
+const migrate = async ({
+  payload,
+  config
+}) => {
+  const {
+    pendingMigrators,
+    nextVersion
+  } = await (0, _pending.getPendingMigrators)({
+    config
+  });
+  const nextPayload = (0, _pipe.pipe)(pendingMigrators, payload);
+  return {
+    nextPayload,
+    nextVersion
+  };
+};
+
+exports.migrate = migrate;

package/dist/pending/pending.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPendingMigrators = exports.getPendingMigrations = void 0;
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _plan = require("../plan/plan");
+
+var _executed = require("../executed/executed");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const getPendingMigrations = ({
+  plannedMigrations,
+  executedMigrations,
+  printPendingFileNames = false
+}) => {
+  const executedMigrationFileNames = executedMigrations.map(e => e.fileName);
+  const pendingMigrations = plannedMigrations.filter(m => !executedMigrationFileNames.includes(m.fileName));
+
+  if (printPendingFileNames) {
+    pendingMigrations.forEach(m => {
+      console.log(_chalk.default.gray(`  ${m.fileName}`));
+    });
+  }
+
+  return pendingMigrations.map(m => ({
+    fileName: m.fileName,
+    migrator: m.migrator
+  }));
+};
+
+exports.getPendingMigrations = getPendingMigrations;
+
+const getPendingMigrators = async ({
+  config
+}) => {
+  const {
+    directory,
+    database,
+    pgpHelpers,
+    entity,
+    version,
+    plan,
+    printPendingFileNames
+  } = config;
+  const {
+    plannedMigrations,
+    nextVersion
+  } = plan || (await (0, _plan.getPlannedMigrations)({
+    config
+  }));
+  const executedMigrations = database ? await (0, _executed.getExecutedMigrationsFromVersion)(database, pgpHelpers, entity, directory, version, nextVersion, plannedMigrations) : [];
+  const pendingMigrators = getPendingMigrations({
+    plannedMigrations,
+    executedMigrations,
+    printPendingFileNames
+  });
+  return {
+    pendingMigrators,
+    nextVersion
+  };
+};
+
+exports.getPendingMigrators = getPendingMigrators;

package/dist/pipe/pipe.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pipe = void 0;
+
+const errorMessage = (fileName, message, stack) => `Unhandled exception in file ${fileName}: ${message}
+
+  ${stack}
+`;
+/**
+ * Executes the pending migrators on a payload, returns modified payload
+ *
+ * Loosely based on:
+ *  - Eric Elliott's pipe implementation https://medium.com/javascript-scene/reduce-composing-software-fe22f0c39a1d
+ *  - lodash flow https://lodash.com/docs/4.17.15#flow
+ *
+ * Implementation includes exception handling to extend errors with the filename
+ * until module-with-string fixes its stack trace handling (see OW-8879 and
+ * https://github.com/exuanbo/module-from-string/issues/18)
+ *
+ * @param {Array<Object>} migrations
+ * @param {Object} payload
+ * @returns {Object} migratedPayload
+ */
+
+
+const pipe = (migrations, payload) => migrations.reduce((v, m) => {
+  if (typeof (m === null || m === void 0 ? void 0 : m.migrator) !== 'function') {
+    throw new TypeError('Expected a function');
+  }
+
+  try {
+    return m.migrator(v);
+  } catch (error) {
+    throw new Error(errorMessage(m === null || m === void 0 ? void 0 : m.fileName, error.message, error.stack));
+  }
+}, payload);
+
+exports.pipe = pipe;

package/dist/plan/cached-planned-version.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setCachedPlannedVersion = exports.getCachedPlannedVersion = void 0;
+let cachedPlannedVersion = null;
+
+const getCachedPlannedVersion = () => cachedPlannedVersion;
+
+exports.getCachedPlannedVersion = getCachedPlannedVersion;
+
+const setCachedPlannedVersion = version => {
+  cachedPlannedVersion = version;
+};
+
+exports.setCachedPlannedVersion = setCachedPlannedVersion;