@13w/miri 1.1.6 → 1.1.8

package/Readme.md

@@ -0,0 +1,53 @@
+#### Migration manager
+### Migrations folder structure
+
+* migrations/
+  * init/
+    * 01-create-collections.js
+      ```javascript
+      db.createCollection('users');
+      db.createCollection('goods');
+      ```
+    * 02-create-default-users.js
+    ```javascript
+    db.users.insertOne({firstName: 'foo', lastName: 'zoo'});
+    db.users.insertOne({firstName: 'baz', lastName: 'poo'});
+    ```
+    * 03-create-default-goods.js
+    ```javascript
+    db.goods.insertOne({name: 'lemon'});
+    db.goods.insertOne({name: 'orange'});
+    ```
+  * indexes/
+    * users.json
+    ```json
+    [
+      {name: 1}
+    ]
+    ```
+    * goods.json
+    ```json
+    [
+      [{name: 1}, { unique: true }]
+    ]
+    ```
+  * version-1/
+    * 01-02-2023-add-full-name.js
+    ```javascript
+    export const test = () => db.users.countDocuments({ fullName: { $exists: false } });
+    export const up = () => db.users.updateMany({ fullName: { $exists: false } }, [{ $set: { fullName: { $concat: ['$firstName', ' ', '$lastName'] } } }])
+    export const down = () => db.users.updateMany({}, {$unset: { fullName: 1 }})
+    ```
+    * 04-05-2023-add-user-age.js
+    ```javascript
+    export const test = () => db.users.countDocuments({ age: { $exists: false } });
+    export const up => () => db.users.updateMany({ age: { $exists: false } }, {$set: { age: 135 }})
+    export const down = () => db.users.updateMany({}, {$unset: { age: 1 }})
+    ```
+  * version-2/
+    * 05-08-2023-add-price-to-goods.js
+    ```javascript
+    export const test = () => db.goods.countDocuments({ price: { $exists: false } });
+    export const up => () => db.goods.updateMany({ price: { $exists: false } }, { $set: {price: 12.24} })
+    export const down = () => db.goods.updateMany({}, {$unset: { price: 1 }})
+    ```

package/dist/cli.js

@@ -1,9 +1,11 @@
+Error.stackTraceLimit = Infinity;
 import { join } from 'node:path';
 /* eslint-disable no-console */
 import { Command } from 'commander';
 import { Table } from 'console-table-printer';
+import colors from 'colors';
 import connection from './mongodb.js';
-import Miri, { PatchStatus } from './miri.js';
+import Miri, { IndexStatus, 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');
@@ -14,7 +16,7 @@ const getMiri = async () => {
         localMigrations: opts.migrations,
     });
 };
-const stats = async (remote = false) => {
+const status = async (remote = false) => {
     const miri = await getMiri();
     const patches = await miri.stat(remote);
     await miri[Symbol.asyncDispose]();
@@ -42,9 +44,9 @@ const stats = async (remote = false) => {
     }
     table.printTable();
 };
-program.command('stats')
+program.command('status')
     .description('Displays list of applied migrations')
-    .action(() => stats(true));
+    .action(() => status(true));
 const initProgram = program.command('init');
 initProgram.command('apply')
     .action(async () => {
@@ -56,16 +58,80 @@ initProgram.command('status')
     .action(() => {
     console.log('There should be init status....');
 });
+const indexesProgram = program.command('indexes');
+const indexStatusProgram = indexesProgram.command('status')
+    .argument('[collection]', 'MongoDB Collection name')
+    .option('-q --quiet', 'Show only changes', false)
+    .action(async () => {
+    const collection = indexStatusProgram.args[0];
+    const { quiet } = indexStatusProgram.opts();
+    const miri = await getMiri();
+    const structure = await miri.indexesDiff(collection);
+    await miri[Symbol.asyncDispose]();
+    for (const [collection, indexes] of Object.entries(structure)) {
+        let changes = false;
+        for (const [name, detail] of Object.entries(indexes)) {
+            if (quiet && detail.status === IndexStatus.Applied) {
+                continue;
+            }
+            const color = {
+                [IndexStatus.New]: colors.green,
+                [IndexStatus.Applied]: colors.white,
+                [IndexStatus.Removed]: colors.red,
+            }[detail.status];
+            const point = {
+                [IndexStatus.New]: colors.green.bold('+ '),
+                [IndexStatus.Applied]: colors.cyan('\u00b7 '),
+                [IndexStatus.Removed]: colors.red.bold('- '),
+            }[detail.status];
+            if (!changes) {
+                console.group(colors.bold(`Collection ${collection}:`));
+                changes = true;
+            }
+            console.log(color(`${point}${name}`));
+        }
+        console.groupEnd();
+    }
+});
+const indexSyncProgram = indexesProgram.command('sync');
+indexSyncProgram.option('<collection>', 'MongoDB Collection name', '')
+    .action(async () => {
+    const miri = await getMiri();
+    let group = '';
+    console.group('Starting synchronisation...', indexSyncProgram.opts());
+    for await (const { collection, status, name, error } of miri.indexesSync()) {
+        if (group !== collection) {
+            if (group) {
+                console.log('Done');
+                console.groupEnd();
+            }
+            group = collection;
+            console.group(`Collection: ${collection}...`);
+        }
+        if (status === IndexStatus.Applied) {
+            continue;
+        }
+        console[error ? 'group' : 'log'](`${status === IndexStatus.New ? 'Creating' : 'Removing'} index ${name}... ${error ? 'failed' : 'done'}`);
+        if (error) {
+            console.log(colors.red(error.message));
+            console.groupEnd();
+        }
+    }
+    console.groupEnd();
+    await miri[Symbol.asyncDispose]();
+});
 program.command('diff')
     .description('Displays difference between local and applied migrations')
-    .action(() => stats());
-program.command('sync')
+    .action(() => status());
+const programSync = program.command('sync')
+    .option('--remote', 'Remote only')
+    .option('--degraded', 'Re-apply patches on degraded migrations')
+    .option('--all', 'Re-apply all patches')
     .description('Applies migrations')
     .action(async () => {
     const miri = await getMiri();
-    await miri.sync();
+    await miri.sync(programSync.opts());
     await miri[Symbol.asyncDispose]();
 });
 program.parse();
-const opts = program.opts();
 //# sourceMappingURL=cli.js.map

package/dist/evaluator.js

@@ -5,6 +5,7 @@ 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 colors from 'colors';
 const print = (values, type) => {
     const prepare = (object, type = 'print') => {
         if (type === 'print') {
@@ -19,8 +20,7 @@ const print = (values, type) => {
         if (printable === void 0) {
             continue;
         }
-        process.stdout.write(prepare(printable, value.type ?? type));
-        process.stdout.write('\n');
+        console.log(colors.blue(prepare(printable, value.type ?? type)));
     }
 };
 const __env = Object.fromEntries(Object.entries(process.env)
@@ -29,6 +29,7 @@ const __env = Object.fromEntries(Object.entries(process.env)
 export async function evaluateMongo(client, code, filename = '[no file]') {
     const context = createContext({ __env });
     const bus = new EventEmitter();
+    // console.log(`Client status! ${(<{ topology: { isConnected: () => boolean } } & MongoClient>client)?.topology?.isConnected() ? '' : 'not'} connected`)
     const cliServiceProvider = new CliServiceProvider(client, bus, {
         productName: 'MIRI: Migration manager',
         productDocsLink: 'https://example.com/',

package/dist/miri.js

@@ -1,9 +1,10 @@
 /* eslint-disable no-console */
 import { createHash } from 'node:crypto';
 import { readdir, readFile, realpath } from 'node:fs/promises';
-import { resolve } from 'node:path';
+import { resolve, extname, basename } from 'node:path';
 import { ObjectId } from 'mongodb';
 import { evaluateJs, evaluateMongo } from './evaluator.js';
+import colors from 'colors';
 export var PatchStatus;
 (function (PatchStatus) {
     PatchStatus[PatchStatus["Ok"] = 0] = "Ok";
@@ -13,6 +14,12 @@ export var PatchStatus;
     PatchStatus[PatchStatus["Removed"] = 4] = "Removed";
     PatchStatus[PatchStatus["Degraded"] = 5] = "Degraded";
 })(PatchStatus || (PatchStatus = {}));
+export var IndexStatus;
+(function (IndexStatus) {
+    IndexStatus[IndexStatus["New"] = 0] = "New";
+    IndexStatus[IndexStatus["Applied"] = 1] = "Applied";
+    IndexStatus[IndexStatus["Removed"] = 2] = "Removed";
+})(IndexStatus || (IndexStatus = {}));
 const sortPatches = (a, b) => {
     if (a.group === b.group) {
         return a.name < b.name ? -1 : 1;
@@ -74,13 +81,14 @@ export default class Migrator {
             return -1;
         }
         const code = Buffer.from(content.body, 'base64').toString();
-        return evaluateMongo(this.client, wrap ? `(${code})();` : code, filename)
+        return evaluateMongo(this.client, wrap ? `(async ${code})();` : code, filename)
             .catch((error) => {
             throw error;
         }) ?? 0;
     }
-    async sync() {
-        const patches = await this.diff();
+    async sync({ remote = false, all = false, degraded = false } = {}) {
+        const patches = remote ? await this.getRemotePatches() : await this.diff();
+        // console.log(`Sync: remote: ${remote ? 'on' : 'off'} | all: ${all ? 'on' : 'off'} | degraded: ${degraded ? 'on' : 'off'}`)
         for (const patch of patches) {
             const filename = `${patch.group}/${patch.name}`;
             console.group(`Patch ${patch.group} / ${patch.name}...`);
@@ -100,18 +108,18 @@ export default class Migrator {
                 console.groupEnd();
                 patch.status = PatchStatus.New;
             }
-            if (patch.status === PatchStatus.New) {
-                console.group('Testing migration');
+            if (all || degraded || patch.status === PatchStatus.New) {
+                console.group(colors.white('Testing migration'));
                 const test = await this.applyPatchContent(patch.content.test, filename);
-                console.log(`degradation level: ${test}`);
-                if (test !== 0) {
-                    console.group('Applying migration...');
+                console.log(colors.white(`degradation level: ${test}`));
+                if (all || test !== 0) {
+                    console.group(colors.cyan('Applying migration...'));
                     await this.applyPatchContent(patch.content.up, filename);
-                    console.log('Done');
+                    console.log(colors.green('Done'));
                     console.groupEnd();
                 }
                 else {
-                    console.log('nothing to apply');
+                    console.log(colors.green('nothing to apply'));
                 }
                 console.groupEnd();
             }
@@ -135,10 +143,15 @@ export default class Migrator {
             if (!file.isFile()) {
                 continue;
             }
+            const extension = extname(file.name);
+            if (!['.js', '.json'].includes(extension)) {
+                continue;
+            }
             const patchObject = {
                 _id: new ObjectId(),
                 group: file.path.substring(migrationsDir.length + 1),
                 name: file.name,
+                title: basename(file.name, extension),
                 content: {},
             };
             if (group ? patchObject.group !== group : ['init', 'indexes'].includes(patchObject.group)) {
@@ -202,6 +215,66 @@ export default class Migrator {
         patches.sort(sortPatches);
         return patches;
     }
+    async indexesDiff(collection) {
+        const localIndexes = await this.getLocalPatches(true, 'indexes', collection && `${collection}.json`);
+        const structure = {};
+        const db = this.#client.db();
+        for (const patch of localIndexes) {
+            const indexes = JSON.parse(Buffer.from(patch.raw, 'base64').toString());
+            structure[patch.title] = {};
+            const collection = structure[patch.title];
+            // console.log(`Reading indexes from ${patch.title}...`)
+            const remoteIndexes = await db.collection(patch.title).indexes({ full: true })
+                .catch(() => []);
+            // console.dir([patch.title, remoteIndexes], { colors: true, customInspect: true, depth: 22 })
+            for (const index of indexes) {
+                // noinspection SuspiciousTypeOfGuard
+                if (typeof index === 'string') {
+                    continue;
+                }
+                const [key, options] = (Array.isArray(index) ? index : [index, {}]);
+                const name = Object.entries(key).reduce((result, [key, value]) => `${result ? `${result}_` : ''}${key}_${value}`, '');
+                const remoteIndex = remoteIndexes.find(({ name: indexName }) => indexName === name);
+                collection[name] = { key, options, status: remoteIndex ? IndexStatus.Applied : IndexStatus.New };
+                if (remoteIndex) {
+                    remoteIndexes.splice(remoteIndexes.indexOf(remoteIndex), 1);
+                }
+            }
+            if (remoteIndexes.length) {
+                for (const index of remoteIndexes) {
+                    if (index.name === '_id_') {
+                        continue;
+                    }
+                    collection[index.name] = { key: index.key, options: index, status: IndexStatus.Removed };
+                }
+            }
+        }
+        return structure;
+    }
+    async *indexesSync(collection) {
+        const structure = await this.indexesDiff(collection);
+        const db = this.#client.db();
+        for (const [collection, indexes] of Object.entries(structure)) {
+            const coll = db.collection(collection);
+            for (const [name, { key, status, options }] of Object.entries(indexes)) {
+                if (status === IndexStatus.Removed) {
+                    const error = await coll.dropIndex(name)
+                        .then(() => { })
+                        .catch((error) => error);
+                    yield { collection, name, error, status };
+                    continue;
+                }
+                if (status === IndexStatus.New) {
+                    const error = await coll.createIndex(key, options)
+                        .then(() => { })
+                        .catch((error) => error);
+                    yield { collection, name, error, status };
+                    continue;
+                }
+                yield { collection, name, status };
+            }
+        }
+    }
     async init() {
         const localInits = await this.getLocalPatches(true, 'init');
         const remoteInits = await this.getRemotePatches('init');

package/dist/mongodb.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@13w/miri",
   "description": "MongoDB patch manager",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "type": "module",
   "engines": {
     "node": "v20"
@@ -23,6 +23,7 @@
     "@mongosh/service-provider-server": "^2.1.5",
     "@mongosh/shell-api": "^2.1.5",
     "@mongosh/shell-evaluator": "^2.1.5",
+    "colors": "^1.4.0",
     "commander": "^12.0.0",
     "console-table-printer": "^2.12.0",
     "mongodb": "^6.3.0"