root commit

Author: GochoMugo

.eslintrc.yml

@@ -0,0 +1,17 @@
+env:
+  es6: true
+  node: true
+extends: 'eslint:recommended'
+rules:
+  indent:
+    - error
+    - 4
+  linebreak-style:
+    - error
+    - unix
+  quotes:
+    - error
+    - double
+  semi:
+    - error
+    - always

.gitignore

@@ -0,0 +1,3 @@
+# dependencies
+node_modules
+package-lock.json

.npmignore

@@ -0,0 +1,12 @@
+###
+### FROM .gitignore
+###
+
+# dependencies
+node_modules
+package-lock.json
+
+###
+.eslintrc.yml
+.gitignore
+test

CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+
+## Unreleased
+
+
+
+
+## 0.0.0 - 2017-12-02
+
+**Out in the Wild**

LICENSE.txt

@@ -0,0 +1 @@
+Copyright (c) 2017 Forfuture, LLC <[email protected]>

README.md

@@ -0,0 +1,61 @@
+# migrate
+
+> Database-agnostic migration framework
+
+* [Usage](#usage)
+* [Installation](#installation)
+* [License](#license)
+
+
+<a name="usage"></a>
+## usage
+
+```bash
+# Intro: We have entered into a project that does NOT
+# manage database migrations, using this tool.
+
+# Run migrations.
+# Assume we are in version 1.0.0 already (using the --current option).
+$ npx migrate --current 1.0.0
+
+# ... new migrations added ...
+
+# Run migrations.
+# No need to specify which version we are in! The tool
+# keeps history.
+$ npx migrate
+
+# Migrate to a specific version (e.g. 1.4.0).
+$ npx migrate 1.4.0
+
+# Undo last migration.
+$ npx migrate --undo
+
+# List available migrations/versions.
+$ npx migrate --list
+
+# Show current data version.
+$ npx migrate --which
+
+# Show a brief history of migrations.
+$ npx migrate --history
+
+# Show help information.
+$ npx migrate --help
+```
+
+
+<a name="installation"></a>
+## installation
+
+```bash
+$ npm install gitlab:forfuture/migrate#semver:0.0.0
+```
+
+
+<a name="license"></a>
+## license
+
+**The MIT License (MIT)**
+
+Copyright (c) 2017 Forfuture LLC <[email protected]>

bin/migrate

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("../lib/cli").runAndExit();

integrations/sequelize.js

@@ -0,0 +1,107 @@
+/**
+ * The MIT License (MIT)
+ * Copyright (c) 2017 Forfuture, LLC <[email protected]>
+ */
+
+
+// installed modules
+const async = require("asyncawait/async");
+const await = require("asyncawait/await");
+const Sequelize = require("sequelize");
+
+
+const MigrationModel = {
+    id: {
+        field: "id",
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+    },
+    version: {
+        field: "version",
+        type: Sequelize.TEXT,
+    },
+    migratedAt: {
+        field: "migrated_at",
+        type: Sequelize.DATE,
+    },
+};
+
+
+function toMigration(migration) {
+    return {
+        version: migration.version,
+        migratedAt: migration.migratedAt,
+    };
+}
+
+
+class SequelizeIntegration {
+    constructor(sequelize, options={}) {
+        this.sequelize = sequelize;
+        this.options = Object.assign({
+            tableName: "db_migrations",
+        }, options);
+
+        this._Migration = this.sequelize.define("DatabaseMigration", MigrationModel, {
+            tableName: this.options.tableName,
+        });
+        this._transaction = null;
+        this._empty = false;
+
+        this.integrate = async (this.integrate);
+        this.close = async (this.close);
+    }
+
+    integrate() {
+        // TODO: Document that all models should & will be synced!
+        await (this.sequelize.sync());
+        this._transaction = await (this.sequelize.transaction());
+
+        const migrations = await (this._Migration.findAll({
+            order: [[MigrationModel.migratedAt.field, "DESC"]],
+            limit: 2,
+        }, {
+            transaction: this._transaction,
+        }));
+        this._empty = !migrations.length;
+
+        const versions = {
+            current: toMigration(migrations[0]),
+            previous: toMigration(migrations[1]),
+        };
+        const context = {
+            sequelize: this.sequelize,
+            transaction: this._transaction,
+        };
+
+        return [versions, context, this.close.bind(this)];
+    }
+
+    close(error, output) {
+        if (error || !output) {
+            await (this._transaction.rollback());
+            return;
+        }
+
+        const migrations = [];
+        if (this._empty) {
+            migrations.push({
+                version: output.previousVersion,
+                migratedAt: new Date(0),
+            });
+        }
+        migrations.push({
+            version: output.currentVersion,
+            migratedAt: new Date(),
+        });
+
+        await (this._Migration.bulkCreate(migrations, {
+            transaction: this._transaction,
+        }));
+        await (this._transaction.commit());
+    }
+}
+
+
+exports = module.exports = SequelizeIntegration;

lib/cli.js

@@ -0,0 +1,174 @@
+/**
+ * The MIT License (MIT)
+ * Copyright (c) 2017 Forfuture, LLC <[email protected]>
+ */
+/* eslint-disable no-console */
+
+
+// built-in modules
+const async = require("asyncawait/async");
+const await = require("asyncawait/await");
+const path = require("path");
+
+
+// installed modules
+const Debug = require("debug");
+const program = require("commander");
+
+
+// own modules
+const migrations = require("./migrations");
+const pkg = require("../package");
+const utils = require("./utils");
+
+
+// module variables
+const debug = Debug("migrate:cli");
+
+
+program
+    .version(pkg.version)
+    .usage("[options] [version]")
+    .option("-i, --init-path <path>", "path to initialization file", "script/migrate")
+    .option("-m, --migrations-path <path>", "path to migrations directory", "script/migrations")
+    .option("-c, --current <version>", "use as current version")
+    .option("-u, --undo", "undo last migration")
+    .option("-l, --list", "list available data versions")
+    .option("-w, --which", "show current data version")
+    .option("-t, --history", "show migration history")
+    ; // eslint-disable-line indent
+
+
+const run = async (function run() {
+    let projectHandle;
+    let output;
+    let error;
+
+    try { await (async (function() {
+        program.parse(process.argv);
+
+        const paths = {};
+        ["initPath", "migrationsPath"].forEach(function(key) {
+            paths[key] = path.resolve(program[key]);
+        });
+
+        const versions = await (utils.getVersions(paths.migrationsPath));
+        if (program.list) {
+            console.log(versions);
+            return;
+        }
+
+        projectHandle = await (utils.openProject(paths.initPath));
+
+        const { dbVersions, context } = projectHandle;
+        const currentVersion = (dbVersions.current && dbVersions.current.version) || program.current;
+        if (!currentVersion) {
+            console.error("error: current version not found");
+            return;
+        }
+        if (program.which) {
+            console.log(currentVersion);
+            return;
+        }
+        debug("current version: %s", currentVersion);
+        if (program.history) {
+            console.log(dbVersions);
+            return;
+        }
+        debug("versions in db: %j", dbVersions);
+
+        let targetVersion = program.args.shift();
+        if (targetVersion && versions.indexOf(targetVersion) === -1) {
+            throw "target version not found";
+        }
+        if (!targetVersion && program.undo) {
+            if (!dbVersions.previous) {
+                return;
+            }
+            targetVersion = dbVersions.previous.version;
+        }
+        targetVersion = targetVersion || migrations.getLatestVersion(versions);
+        if (!targetVersion) {
+            throw "target version not found";
+        }
+        debug("target version: %s", targetVersion);
+
+        if (currentVersion === targetVersion) {
+            debug("currentVersion(%s) -eq targetVersion(%s)", currentVersion, targetVersion);
+            return;
+        }
+
+        const targetMigrations = migrations.findVersions(versions, currentVersion, targetVersion).map(function(version) {
+            return {
+                version,
+                module: require(path.join(paths.migrationsPath, version)),
+            };
+        });
+
+        if (!targetMigrations.length) {
+            debug("no migrations to run");
+            return;
+        }
+
+        const up = migrations.goingUp(currentVersion, targetVersion);
+        await (migrations.migrate(up, targetMigrations, context));
+
+        output = {
+            currentVersion: targetVersion,
+            previousVersion: currentVersion,
+        };
+        debug("migration output: %j", output);
+    })()); } catch (ex) {
+        error = ex;
+    }
+
+    // Clean up.
+    if (projectHandle) {
+        await (utils.closeProject(projectHandle, error, output));
+    }
+
+    // Error handling.
+    // TODO:
+    // Improve error logging!
+    if (error) {
+        console.error("error:", error.message || error);
+        if (error.stack) {
+            const padding = "       ";
+            console.error(padding + error.stack.split("\n").slice(1).map((l) => l.trim()).join(`\n${padding}`));
+        }
+        throw error;
+    }
+
+    return output;
+});
+
+
+const runAndExit = async (function runAndExit() {
+    try {
+        await (run());
+    } catch (ex) {
+        process.exit(1);
+    }
+    process.exit();
+});
+
+
+if (require.main === module) {
+    runAndExit();
+}
+
+
+exports = module.exports = {
+    /**
+     * Run the CLI.
+     * @kind function
+     * @return {Promise}
+     */
+    run,
+    /**
+     * Run the CLI and exit immediately.
+     * *Automatically invoked if this file is run as script.*
+     * @kind function
+     */
+    runAndExit,
+};