@13w/miri 1.1.4

package/bin/miri

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --experimental-vm-modules --no-warnings
+
+import '../dist/cli.js'

package/dist/cli.js

@@ -0,0 +1,71 @@
+import { join } from 'node:path';
+/* eslint-disable no-console */
+import { Command } from 'commander';
+import { Table } from 'console-table-printer';
+import connection from './mongodb.js';
+import Miri, { PatchStatus } from './miri.js';
+const program = new Command();
+program.option('-m --migrations <folder>', 'Folder with migrations', join(process.cwd(), 'migrations'));
+program.option('-d --db <mongo-uri>', 'MongoDB Connection URI', 'mongodb://localhost:27017/test');
+const getMiri = async () => {
+    const opts = program.opts();
+    const client = await connection(opts.db);
+    return new Miri(client, {
+        localMigrations: program.opts().migrations,
+    });
+};
+const stats = async (remote = false) => {
+    const miri = await getMiri();
+    const patches = await miri.stat(remote);
+    await miri[Symbol.asyncDispose]();
+    if (!patches.length) {
+        return;
+    }
+    const table = new Table({});
+    for (const patch of patches) {
+        const printable = {
+            group: patch.group,
+            name: patch.name,
+            status: PatchStatus[patch.status],
+            degradation: patch.degradation,
+        };
+        table.addRow(printable, {
+            color: {
+                [PatchStatus.Ok]: 'white',
+                [PatchStatus.New]: 'cyan',
+                [PatchStatus.Updated]: 'white_bold',
+                [PatchStatus.Changed]: 'yellow',
+                [PatchStatus.Degraded]: 'blue',
+                [PatchStatus.Removed]: 'red',
+            }[patch.status],
+        });
+    }
+    table.printTable();
+};
+program.command('stats')
+    .description('Displays list of applied migrations')
+    .action(() => stats(true));
+const initProgram = program.command('init');
+initProgram.command('apply')
+    .action(async () => {
+    const miri = await getMiri();
+    await miri.init();
+    await miri[Symbol.asyncDispose]();
+});
+initProgram.command('status')
+    .action(() => {
+    console.log('There should be init status....');
+});
+program.command('diff')
+    .description('Displays difference between local and applied migrations')
+    .action(() => stats());
+program.command('sync')
+    .description('Applies migrations')
+    .action(async () => {
+    const miri = await getMiri();
+    await miri.sync();
+    await miri[Symbol.asyncDispose]();
+});
+program.parse();
+const opts = program.opts();
+//# sourceMappingURL=cli.js.map

package/dist/evaluator.js

@@ -0,0 +1,82 @@
+/* eslint-disable no-console */
+import { EventEmitter } from 'node:events';
+import { createContext, runInContext, SourceTextModule, SyntheticModule } from 'node:vm';
+import { inspect } from 'node:util';
+import { CliServiceProvider } from '@mongosh/service-provider-server';
+import { ShellInstanceState } from '@mongosh/shell-api';
+import { ShellEvaluator } from '@mongosh/shell-evaluator';
+import connect from './mongodb.js';
+const mongoClient = await connect();
+const print = (values, type) => {
+    const prepare = (object, type = 'print') => {
+        if (type === 'print') {
+            return String(object);
+        }
+        else {
+            return inspect(object, { colors: true, customInspect: true, depth: 22 });
+        }
+    };
+    for (const value of values) {
+        const printable = value.printable ?? value.rawValue;
+        if (printable === void 0) {
+            continue;
+        }
+        process.stdout.write(prepare(printable, value.type ?? type));
+        process.stdout.write('\n');
+    }
+};
+const bus = new EventEmitter();
+const cliServiceProvider = new CliServiceProvider(mongoClient, bus, {
+    productName: 'MIRI: Migration manager',
+    productDocsLink: 'https://example.com/',
+});
+const context = createContext({
+    __env: Object.fromEntries(Object.entries(process.env)
+        .filter(([key]) => key.startsWith('MIRI_'))
+        .map(([key, value]) => [key.substring(5), value])),
+});
+const originalEval = (code) => runInContext(code, context);
+const instanceState = new ShellInstanceState(cliServiceProvider);
+instanceState.setCtx(context);
+instanceState.setEvaluationListener({
+    onPrint(values, type) {
+        // console.dir(['onPrint', type, values])
+        return print(values, type);
+    },
+    onPrompt() {
+        throw new Error('Prompt isn\'t supported');
+    },
+    onLoad() {
+        throw new Error('Load isn\'t supported');
+    },
+    async onExit(exitCode) {
+        process.stdout.write(`onExit: ${exitCode}\n`);
+        await mongoClient.close();
+        process.exit(exitCode);
+    },
+});
+export async function evaluateMongo(code, filename = '[no file]') {
+    const output = await new ShellEvaluator(instanceState)
+        .customEval(originalEval, `${code};`, context, filename);
+    // print([output])
+    return output.rawValue;
+}
+async function linker(specifier, referencingModule) {
+    return import(specifier).then((module) => {
+        return new SyntheticModule(['default'], function () {
+            this.setExport('default', module.default);
+        }, { context: referencingModule.context });
+    });
+}
+export async function evaluateJs(code, identifier = '[no file]') {
+    const context = createContext({ console });
+    const module = new SourceTextModule(code, { context, identifier });
+    await module.link(linker);
+    await module.evaluate()
+        .catch((error) => {
+        error.message += ` # at file ${identifier}`;
+        throw error;
+    });
+    return module.namespace;
+}
+//# sourceMappingURL=evaluator.js.map

package/dist/miri.js

@@ -0,0 +1,244 @@
+/* eslint-disable no-console */
+import { createHash } from 'node:crypto';
+import { readdir, readFile, realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ObjectId } from 'mongodb';
+import { evaluateJs, evaluateMongo } from './evaluator.js';
+export var PatchStatus;
+(function (PatchStatus) {
+    PatchStatus[PatchStatus["Ok"] = 0] = "Ok";
+    PatchStatus[PatchStatus["New"] = 1] = "New";
+    PatchStatus[PatchStatus["Updated"] = 2] = "Updated";
+    PatchStatus[PatchStatus["Changed"] = 3] = "Changed";
+    PatchStatus[PatchStatus["Removed"] = 4] = "Removed";
+    PatchStatus[PatchStatus["Degraded"] = 5] = "Degraded";
+})(PatchStatus || (PatchStatus = {}));
+const sortPatches = (a, b) => {
+    if (a.group === b.group) {
+        return a.name < b.name ? -1 : 1;
+    }
+    return a.group < b.group ? 1 : -1;
+};
+export default class Migrator {
+    client;
+    options;
+    #client;
+    #collection;
+    #options;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+        this.#client = client;
+        this.#collection = client.db().collection('migrations');
+        this.#options = options;
+    }
+    async [Symbol.asyncDispose]() {
+        await this.#client.close();
+    }
+    async diff() {
+        const localPatches = await this.getLocalPatches();
+        const remotePatches = await this.getRemotePatches();
+        for (const localPatch of localPatches) {
+            const remotePatch = remotePatches.find(({ group, name }) => localPatch.group === group && localPatch.name === name);
+            if (remotePatch) {
+                localPatch._id = remotePatch._id;
+                localPatch.status = PatchStatus.Ok;
+                if (localPatch.content.up?.hash !== remotePatch.content.up?.hash) {
+                    localPatch.status = PatchStatus.Changed;
+                }
+                else if (localPatch.content.test?.hash !== remotePatch.content.test?.hash
+                    || localPatch.content.down?.hash !== remotePatch.content.down?.hash) {
+                    localPatch.status = PatchStatus.Updated;
+                }
+                if (localPatch.status !== PatchStatus.Ok) {
+                    Object.defineProperty(localPatch, 'remoteContent', {
+                        value: remotePatch.content,
+                        enumerable: false,
+                    });
+                }
+                remotePatches.splice(remotePatches.indexOf(remotePatch), 1);
+            }
+            else {
+                localPatch.status = PatchStatus.New;
+            }
+        }
+        localPatches.push(...remotePatches.map((remotePatch) => {
+            remotePatch.status = PatchStatus.Removed;
+            return remotePatch;
+        }));
+        localPatches.sort(sortPatches);
+        return localPatches;
+    }
+    async applyPatchContent(content, wrap = true) {
+        if (!content?.body) {
+            return -1;
+        }
+        const code = Buffer.from(content.body, 'base64').toString();
+        return evaluateMongo(wrap ? `(${code})();` : code)
+            .catch((error) => {
+            throw error;
+        }) ?? 0;
+    }
+    async sync() {
+        const patches = await this.diff();
+        for (const patch of patches) {
+            console.group(`Patch ${patch.group} / ${patch.name}...`);
+            if (patch.status === PatchStatus.Removed) {
+                console.group('Reverting changes');
+                const result = await this.applyPatchContent(patch.remoteContent?.down);
+                console.log(result === -1 ? 'Revert script not found' : 'done');
+                console.groupEnd();
+                await this.#collection.deleteOne({ _id: patch._id });
+                console.groupEnd();
+                continue;
+            }
+            if (patch.status === PatchStatus.Changed) {
+                console.group('Reverting changes');
+                const result = await this.applyPatchContent(patch.remoteContent?.down);
+                console.log(result === -1 ? 'Revert script not found' : 'done');
+                console.groupEnd();
+                patch.status = PatchStatus.New;
+            }
+            if (patch.status === PatchStatus.New) {
+                console.group('Testing migration');
+                const test = await this.applyPatchContent(patch.content.test);
+                console.log(`degradation level: ${test}`);
+                if (test !== 0) {
+                    console.group('Applying migration...');
+                    await this.applyPatchContent(patch.content.up);
+                    console.log('Done');
+                    console.groupEnd();
+                }
+                else {
+                    console.log('nothing to apply');
+                }
+                console.groupEnd();
+            }
+            console.groupEnd();
+            await this.#collection.updateOne({ _id: patch._id }, {
+                $set: {
+                    _id: patch._id,
+                    group: patch.group,
+                    name: patch.name,
+                    content: patch.content,
+                },
+            }, { upsert: true });
+        }
+    }
+    async getLocalPatches(raw = false, group = '', name = '') {
+        const migrationsDir = await realpath(join(process.cwd(), this.#options.localMigrations ?? 'migrations'));
+        console.debug(`Reading ${migrationsDir}...`);
+        const files = await readdir(migrationsDir, { recursive: true, withFileTypes: true });
+        const patches = [];
+        for (const file of files) {
+            if (!file.isFile()) {
+                continue;
+            }
+            const patchObject = {
+                _id: new ObjectId(),
+                group: file.path.substring(migrationsDir.length + 1),
+                name: file.name,
+                content: {},
+            };
+            if (group ? patchObject.group !== group : ['init', 'indexes'].includes(patchObject.group)) {
+                continue;
+            }
+            if (name && patchObject.name !== name) {
+                continue;
+            }
+            patches.push(patchObject);
+            const patchContent = await readFile(join(file.path, file.name));
+            if (raw) {
+                patchObject.raw = patchContent.toString('base64');
+                continue;
+            }
+            const patchExports = await evaluateJs(patchContent.toString());
+            for (const key of ['test', 'up', 'down']) {
+                const func = patchExports[key];
+                if (typeof func !== 'function') {
+                    continue;
+                }
+                const body = Buffer.from(func.toString()).toString('base64');
+                patchObject.content[key] = {
+                    body,
+                    hash: createHash('sha256').update(body).digest('hex'),
+                };
+            }
+        }
+        return patches;
+    }
+    async getRemotePatches(group = '', name = '') {
+        const filter = {
+            group: { $nin: ['init', 'index'] },
+        };
+        if (group) {
+            filter.group = group;
+        }
+        if (name) {
+            filter.name = name;
+        }
+        const patches = await this.#collection.find(filter, {
+            projection: {
+                _id: 1,
+                group: 1,
+                name: 1,
+                content: {
+                    test: {
+                        hash: 1,
+                        body: 1,
+                    },
+                    up: {
+                        hash: 1,
+                        body: 1,
+                    },
+                    down: {
+                        hash: 1,
+                        body: 1,
+                    },
+                },
+            },
+        }).toArray();
+        patches.sort(sortPatches);
+        return patches;
+    }
+    async init() {
+        const localInits = await this.getLocalPatches(true, 'init');
+        const remoteInits = await this.getRemotePatches('init');
+        if (!localInits.length) {
+            console.log('Nothing to apply');
+            return;
+        }
+        console.group('Applying initial patches...');
+        for (const patch of localInits) {
+            console.group(`Testing ${patch.name}...`);
+            const remoteInit = remoteInits.find(({ group, name }) => patch.group === group && patch.name === name);
+            if (remoteInit) {
+                console.log('skip');
+                console.groupEnd();
+                continue;
+            }
+            console.log('applying');
+            await this.applyPatchContent({ body: patch.raw, hash: '' }, false);
+            await this.#collection.insertOne({
+                group: patch.group,
+                name: patch.name,
+                content: {},
+            });
+            console.groupEnd();
+        }
+        console.groupEnd();
+    }
+    async stat(remote = false) {
+        const patches = await (remote ? this.getRemotePatches() : this.diff());
+        for (const patch of patches) {
+            patch.status = patch.status ?? PatchStatus.Ok;
+            const degradation = await this.applyPatchContent(patch.content.test);
+            patch.degradation = degradation === -1 ? '-' : degradation;
+            if (degradation > 0 && [PatchStatus.Ok, PatchStatus.Updated].includes(patch.status)) {
+                patch.status = PatchStatus.Degraded;
+            }
+        }
+        return patches;
+    }
+}
+//# sourceMappingURL=miri.js.map

package/dist/mongodb.js

@@ -0,0 +1,6 @@
+import { MongoClient } from 'mongodb';
+let client;
+export default async function connect(uri = 'mongodb://localhost:27017/test') {
+    return client ?? (client = await new MongoClient(uri).connect());
+}
+//# sourceMappingURL=mongodb.js.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@13w/miri",
+  "description": "MongoDB patch manager",
+  "version": "1.1.4",
+  "type": "module",
+  "engines": {
+    "node": "v20"
+  },
+  "packageManager": "^pnpm@8.15.4",
+  "bin": {
+    "miri": "bin/miri"
+  },
+  "files": [
+    "bin/miri",
+    "dist/cli.js",
+    "dist/evaluator.js",
+    "dist/miri.js",
+    "dist/mongodb.js"
+  ],
+  "main": "bin/miri",
+  "types": "types/miri.d.ts",
+  "dependencies": {
+    "@mongosh/service-provider-server": "^2.1.5",
+    "@mongosh/shell-api": "^2.1.5",
+    "@mongosh/shell-evaluator": "^2.1.5",
+    "commander": "^12.0.0",
+    "console-table-printer": "^2.12.0",
+    "mongodb": "^6.3.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.21",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-deprecation": "^2.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "eslint src/ --ext .ts --quiet",
+    "postinstall": "pnpm run build"
+  }
+}