@semics-tech/mongolite 1.2.0 → 1.3.0

package/dist/cjs/bin/mongolite.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+/**
+ * `mongolite` — the guided explorer for MongoLite databases.
+ *
+ * Running it with no arguments is the intended path: it finds your database
+ * files, lists the collections it finds inside, and walks you through a query.
+ * Flags are shortcuts for people who already know where they are going, and
+ * `--repl` drops into the older command-driven debugger.
+ */
+const explorer_js_1 = require("../cli/explorer.js");
+const query_debugger_js_1 = require("../debugger/query-debugger.js");
+const ui_js_1 = require("../cli/ui.js");
+function parseArgs(argv) {
+    const options = { verbose: false, help: false, version: false, repl: false };
+    const positional = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        switch (arg) {
+            case '--database':
+            case '-d':
+                options.database = argv[++index];
+                break;
+            case '--collection':
+            case '-c':
+                options.collection = argv[++index];
+                break;
+            case '--verbose':
+            case '-v':
+                options.verbose = true;
+                break;
+            case '--repl':
+            case '--expert':
+                options.repl = true;
+                break;
+            case '--sample':
+                options.sampleSize = Number(argv[++index]);
+                break;
+            case '--page-size':
+                options.pageSize = Number(argv[++index]);
+                break;
+            case '--help':
+            case '-h':
+                options.help = true;
+                break;
+            case '--version':
+            case '-V':
+                options.version = true;
+                break;
+            default:
+                if (arg.startsWith('-')) {
+                    throw new Error(`Unknown option: ${arg}`);
+                }
+                positional.push(arg);
+                break;
+        }
+    }
+    // `mongolite ./app.db users` is the shape people try first, so support it.
+    if (!options.database && positional[0])
+        options.database = positional[0];
+    if (!options.collection && positional[1])
+        options.collection = positional[1];
+    return options;
+}
+function showHelp() {
+    const lines = [
+        `${ui_js_1.style.bold('mongolite')} — explore a MongoLite (SQLite-backed) database`,
+        '',
+        ui_js_1.style.bold('Usage'),
+        '  npx mongolite                      Start the guided explorer',
+        '  npx mongolite ./app.db             Open a specific database',
+        '  npx mongolite ./app.db users       Open a specific collection',
+        '',
+        ui_js_1.style.bold('Options'),
+        '  -d, --database <path>   Database file to open (otherwise you get a list to pick from)',
+        '  -c, --collection <name> Collection to start in',
+        '      --sample <n>        Documents to sample when inferring fields (default 200)',
+        '      --page-size <n>     Results shown per page (default 20)',
+        '      --repl              Use the older command-driven debugger instead',
+        '  -v, --verbose           Log the SQL being built',
+        '  -h, --help              Show this help',
+        '  -V, --version           Show the version',
+        '',
+        ui_js_1.style.bold('In the explorer'),
+        '  ↑/↓ move · type to filter the list · enter to choose · esc to go back · Ctrl+C to quit',
+        '',
+        'No MongoDB knowledge is needed: pick a field, pick a condition in plain English,',
+        'and the filter it builds is printed so you can learn the syntax as you go.',
+        'If you already know it, "Write a MongoDB filter yourself" and "Run raw SQL" are',
+        'under Advanced.',
+        '',
+    ];
+    process.stdout.write(`${lines.join('\n')}\n`);
+}
+/**
+ * Find the package version by walking up from the running script.
+ * Deliberately avoids `import.meta` and `__dirname` so the same source compiles
+ * for both the ESM and CommonJS builds.
+ */
+async function showVersion() {
+    const { readFileSync, existsSync } = await Promise.resolve().then(() => __importStar(require('node:fs')));
+    const { dirname, join, parse } = await Promise.resolve().then(() => __importStar(require('node:path')));
+    let dir = dirname(process.argv[1] ?? process.cwd());
+    const { root } = parse(dir);
+    while (dir && dir !== root) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const pkg = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (pkg.version) {
+                    process.stdout.write(`${pkg.version}\n`);
+                    return;
+                }
+            }
+            catch {
+                // Unreadable package.json - keep walking up.
+            }
+        }
+        dir = dirname(dir);
+    }
+    process.stdout.write('unknown\n');
+}
+async function main() {
+    let options;
+    try {
+        options = parseArgs(process.argv.slice(2));
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.stderr.write('Run with --help to see the available options.\n');
+        process.exit(1);
+        return;
+    }
+    if (options.help) {
+        showHelp();
+        return;
+    }
+    if (options.version) {
+        await showVersion();
+        return;
+    }
+    if (options.repl) {
+        const queryDebugger = new query_debugger_js_1.QueryDebugger({
+            database: options.database,
+            collection: options.collection,
+            verbose: options.verbose,
+        });
+        await queryDebugger.start();
+        return;
+    }
+    const explorer = new explorer_js_1.Explorer({
+        database: options.database,
+        collection: options.collection,
+        verbose: options.verbose,
+        sampleSize: Number.isFinite(options.sampleSize) ? options.sampleSize : undefined,
+        pageSize: Number.isFinite(options.pageSize) ? options.pageSize : undefined,
+    });
+    await explorer.run();
+}
+main()
+    .then(() => {
+    (0, ui_js_1.closePrompts)();
+    process.exit(0);
+})
+    .catch((error) => {
+    const text = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`\n✖ ${text}\n`);
+    if (text.includes('SQLITE_CANTOPEN') || text.includes('unable to open')) {
+        process.stderr.write('  The file may not exist, or may not be readable.\n');
+    }
+    process.exit(1);
+});

package/dist/cjs/cli/discover.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findDatabaseFiles = findDatabaseFiles;
+exports.formatBytes = formatBytes;
+exports.formatRelativeTime = formatRelativeTime;
+exports.listCollectionInfo = listCollectionInfo;
+exports.resolveDatabasePath = resolveDatabasePath;
+exports.databaseExists = databaseExists;
+/**
+ * Finding things for the user so they do not have to type paths or remember
+ * collection names: SQLite files on disk, and MongoLite-shaped tables inside
+ * a database.
+ */
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const DB_EXTENSIONS = ['.db', '.sqlite', '.sqlite3', '.db3'];
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.next',
+    '.cache',
+    'vendor',
+    '.venv',
+    'venv',
+    '__pycache__',
+]);
+/**
+ * Walk `root` looking for SQLite-looking files, skipping the usual noisy
+ * directories. Results are newest-first, since the file you just wrote is
+ * almost always the one you want.
+ */
+function findDatabaseFiles(root = process.cwd(), options = {}) {
+    const maxDepth = options.depth ?? 2;
+    const limit = options.limit ?? 50;
+    const found = [];
+    const walk = (dir, depth) => {
+        if (found.length >= limit || depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // Unreadable directory - nothing useful to say about it.
+        }
+        for (const entry of entries) {
+            if (found.length >= limit)
+                return;
+            const full = node_path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name.startsWith('.'))
+                    continue;
+                walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!DB_EXTENSIONS.includes(node_path_1.default.extname(entry.name).toLowerCase()))
+                continue;
+            // WAL/SHM siblings are not databases you can open directly.
+            if (/-(wal|shm)$/.test(entry.name))
+                continue;
+            try {
+                const stats = (0, node_fs_1.statSync)(full);
+                found.push({
+                    path: full,
+                    relativePath: node_path_1.default.relative(root, full) || entry.name,
+                    sizeBytes: stats.size,
+                    modified: stats.mtime,
+                });
+            }
+            catch {
+                // File vanished between readdir and stat - ignore.
+            }
+        }
+    };
+    walk(root, 0);
+    found.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    return found;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${value >= 10 ? Math.round(value) : value.toFixed(1)} ${units[unit]}`;
+}
+function formatRelativeTime(date, now = new Date()) {
+    const seconds = Math.max(0, Math.round((now.getTime() - date.getTime()) / 1000));
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    if (days < 30)
+        return `${days}d ago`;
+    return date.toISOString().slice(0, 10);
+}
+/**
+ * List the tables in the database, flagging which ones look like MongoLite
+ * collections (an `_id` column plus a `data` column). Foreign tables are still
+ * reported so a user pointed at the wrong file gets a useful message rather
+ * than an empty list.
+ */
+async function listCollectionInfo(db) {
+    const tables = await db.all(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+    const infos = [];
+    for (const { name } of tables) {
+        let isMongoLite = false;
+        try {
+            const columns = await db.all(`PRAGMA table_info("${name}")`);
+            const columnNames = new Set(columns.map((column) => column.name));
+            isMongoLite = columnNames.has('_id') && columnNames.has('data');
+        }
+        catch {
+            isMongoLite = false;
+        }
+        let count = 0;
+        try {
+            const row = await db.get(`SELECT COUNT(*) as count FROM "${name}"`);
+            count = row?.count ?? 0;
+        }
+        catch {
+            count = 0;
+        }
+        infos.push({ name, count, isMongoLite });
+    }
+    return infos;
+}
+/** Resolve a user-supplied database path, allowing `:memory:` and `~` shorthand. */
+function resolveDatabasePath(input) {
+    if (input === ':memory:')
+        return input;
+    const expanded = input.startsWith('~')
+        ? node_path_1.default.join(process.env.HOME ?? '', input.slice(1))
+        : input;
+    return node_path_1.default.resolve(expanded);
+}
+function databaseExists(dbPath) {
+    return dbPath === ':memory:' || (0, node_fs_1.existsSync)(dbPath);
+}