@13w/miri 1.1.10 → 1.1.12

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { readFile } from 'node:fs/promises';
 Error.stackTraceLimit = Infinity;
 import { join } from 'node:path';
 /* eslint-disable no-console */
@@ -5,27 +6,55 @@ import { Command } from 'commander';
 import { Table } from 'console-table-printer';
 import colors from 'colors';
 import { createTunnel } from 'tunnel-ssh';
+import SSHConfig from 'ssh-config';
 import connection from './mongodb.js';
 import Miri, { IndexStatus, PatchStatus } from './miri.js';
 import { readFileSync } from 'fs';
 import { realpathSync } from 'node:fs';
-const { MIRI_MONGO_URI = 'mongodb://localhost:27017/test', SSH_AUTH_SOCK } = process.env;
+const pkg = await readFile(join(import.meta.dirname, '../package.json'), 'utf-8').then((content) => JSON.parse(content));
+const mirirc = await readFile(join(process.cwd(), '.mirirc'), 'utf-8').then((content) => JSON.parse(content), () => ({}));
+const { SSH_AUTH_SOCK, HOME } = process.env;
 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', MIRI_MONGO_URI);
+program.version(pkg.version);
+program.option('-e --env <environment>', 'Environment name from .mirirc', 'default');
+program.option('-m --migrations <folder>', `Folder with migrations (default: "${process.cwd(), join(process.cwd(), 'migrations')}")`);
+program.option('-d --db <mongo-uri>', 'MongoDB Connection URI (default: "mongodb://localhost:27017/test")');
+program.option('--ssh-profile <profile>', 'Connect via SSH using profile');
 program.option('--ssh-host <host>', 'Connect via SSH proxy Host');
 program.option('--ssh-port <port>', 'Connect via SSH proxy Port');
 program.option('--ssh-user <user>', 'Connect via SSH proxy User');
 program.option('--ssh-key <path/to/key>', 'Connect via SSH proxy IdentityKey');
+let configCache;
+const getConfig = (programOpts) => {
+    if (configCache) {
+        return configCache;
+    }
+    const envs = mirirc.environments ?? { default: mirirc };
+    const env = envs[programOpts.env ?? 'default'] ?? {};
+    const config = Object.assign({}, mirirc, env, programOpts);
+    if (config.sshProfile) {
+        const sshConfigPath = join(HOME ?? '', '.ssh/config');
+        const sshConfigContent = readFileSync(sshConfigPath, 'utf-8');
+        console.log(`Reading profile ${config.sshProfile} from SSH config ${sshConfigPath}`);
+        const parsed = SSHConfig.parse(sshConfigContent).compute(config.sshProfile);
+        config.sshHost = programOpts.sshHost ?? parsed.Hostname;
+        config.sshPort = programOpts.sshPort ?? parsed.Port;
+        config.sshKey = programOpts.sshKey ?? parsed.IdentityFile?.[0];
+        config.sshUser = programOpts.sshUser ?? parsed.User;
+    }
+    // console.dir(config)
+    return configCache = config;
+};
 const createSSHTunnel = async (opts) => {
+    const config = getConfig(opts);
     const sshOptions = {
-        host: opts.sshHost,
-        port: Number(opts.sshPort ?? 22),
-        username: opts.sshUser,
+        host: config.sshHost,
+        port: Number(config.sshPort ?? 22),
+        username: config.sshUser,
         agent: SSH_AUTH_SOCK,
-        privateKey: opts.sshKey ? readFileSync(realpathSync(opts.sshKey)) : void 0,
+        privateKey: config.sshKey ? readFileSync(realpathSync(config.sshKey)) : void 0,
     };
-    const dst = new URL(opts.db);
+    const dst = new URL(config.db);
     const forwardOptions = {
         dstPort: Number(dst.port ?? 27017),
         dstAddr: dst.hostname,
@@ -37,19 +66,23 @@ const createSSHTunnel = async (opts) => {
     return dst.toString();
 };
 const getMiri = async () => {
-    const opts = program.opts();
-    const db = opts.sshHost ? await createSSHTunnel(opts) : opts.db;
+    const config = getConfig(program.opts());
+    const db = config.sshHost ? await createSSHTunnel(config) : config.db;
     const dbUri = new URL(db);
     dbUri.searchParams.append('directConnection', 'true');
-    dbUri.searchParams.append('appName', 'miri+v1');
+    dbUri.searchParams.append('appName', `miri+v${pkg.version}`);
     const client = await connection(dbUri.toString());
     return new Miri(client, {
-        localMigrations: opts.migrations,
+        localMigrations: config.migrations,
     });
 };
-const status = async (remote = false, group) => {
+const status = async (remote = false, group, all = false) => {
     const miri = await getMiri();
     const patches = await miri.stat(remote, group);
+    if (!group && all) {
+        const initPatches = await miri.stat(remote, 'init');
+        patches.unshift(...initPatches);
+    }
     await miri[Symbol.asyncDispose]();
     if (!patches.length) {
         return;
@@ -75,15 +108,53 @@ const status = async (remote = false, group) => {
     }
     table.printTable();
 };
+const syncIndexes = async (miri, coll) => {
+    let group = '';
+    console.group('Starting synchronisation...');
+    for await (const { collection, status, name, error } of miri.indexesSync(coll)) {
+        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();
+};
 program.command('status')
+    .option('--all', 'show all applied patches')
     .description('Displays list of applied migrations')
-    .action(() => status(true));
+    .action(({ all }) => status(true, void 0, all));
+program.command('sync')
+    .description('Applies all available patches from migrations folder')
+    .option('--degraded', 'Re-apply patches on degraded migrations')
+    .option('--all', 'Re-apply all patches')
+    .action(async (opts) => {
+    const miri = await getMiri();
+    await miri.init({ force: opts.all });
+    await syncIndexes(miri);
+    await miri.sync(opts);
+    await miri[Symbol.asyncDispose]();
+});
 const initProgram = program.command('init')
     .description('Manage initial scripts');
 initProgram.command('apply')
-    .action(async () => {
+    .argument('[patch]', 'patch name')
+    .option('--no-exec', 'Don\' execute patch, just set as done')
+    .option('--force', 'Force apply patch')
+    .action(async (opts, patch) => {
     const miri = await getMiri();
-    await miri.init();
+    await miri.init(opts, patch);
     await miri[Symbol.asyncDispose]();
 });
 initProgram.command('status')
@@ -124,29 +195,9 @@ indexesProgram.command('status')
 });
 const indexSyncProgram = indexesProgram.command('sync');
 indexSyncProgram.argument('[collection]', 'MongoDB Collection name', '')
-    .action(async (coll) => {
+    .action(async (collection) => {
     const miri = await getMiri();
-    let group = '';
-    console.group('Starting synchronisation...');
-    for await (const { collection, status, name, error } of miri.indexesSync(coll)) {
-        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 syncIndexes(miri, collection);
     await miri[Symbol.asyncDispose]();
 });
 const patchProgram = program.command('patch')

package/dist/miri.js

@@ -276,9 +276,9 @@ export default class Migrator {
             }
         }
     }
-    async init() {
-        const localInits = await this.getLocalPatches(true, 'init');
-        const remoteInits = await this.getRemotePatches('init');
+    async init({ noExec = false, force = false } = {}, patch) {
+        const localInits = await this.getLocalPatches(true, 'init', patch);
+        const remoteInits = await this.getRemotePatches('init', patch);
         if (!localInits.length) {
             console.log('Nothing to apply');
             return;
@@ -287,18 +287,25 @@ export default class Migrator {
         for (const patch of localInits) {
             console.group(`Testing ${patch.name}...`);
             const remoteInit = remoteInits.find(({ group, name }) => patch.group === group && patch.name === name);
-            if (remoteInit) {
+            if (!force && remoteInit) {
                 console.log('skip');
                 console.groupEnd();
                 continue;
             }
-            console.log('applying');
-            await this.applyPatchContent({ body: patch.raw, hash: '' }, `${patch.group}/${patch.name}`, false);
-            await this.#collection.insertOne({
-                group: patch.group,
-                name: patch.name,
-                content: {},
-            });
+            if (force || !noExec) {
+                console.log('applying');
+                await this.applyPatchContent({ body: patch.raw, hash: '' }, `${patch.group}/${patch.name}`, false);
+            }
+            else {
+                console.log('set as done');
+            }
+            if (!remoteInit) {
+                await this.#collection.insertOne({
+                    group: patch.group,
+                    name: patch.name,
+                    content: {},
+                });
+            }
             console.groupEnd();
         }
         console.groupEnd();

package/dist/mongodb.js

@@ -1,7 +1,9 @@
+/* eslint-disable no-console */
 import { MongoClient } from 'mongodb';
 let client;
 export default async function connect(uri = 'mongodb://localhost:27017/test') {
     if (!client) {
+        console.log(`Connecting MongoDB to ${uri}`);
         client = await MongoClient.connect(uri);
         client?.topology?.socket?.unref();
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@13w/miri",
   "description": "MongoDB patch manager",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "type": "module",
   "engines": {
     "node": "v20"
@@ -27,6 +27,7 @@
     "commander": "^12.0.0",
     "console-table-printer": "^2.12.0",
     "mongodb": "^6.5.0",
+    "ssh-config": "^4.4.2",
     "tunnel-ssh": "^5.1.2"
   },
   "devDependencies": {