@dbx-app/node-core 0.4.3 → 0.4.4

package/dist/connections.d.ts

@@ -17,6 +17,14 @@ export interface ConnectionConfig {
     proxy_username?: string;
     proxy_password?: string;
     ssl: boolean;
+    ca_cert_path?: string;
+    oracle_connection_type?: "service_name" | "sid";
+    redis_connection_mode?: "standalone" | "sentinel";
+    redis_sentinel_master?: string;
+    redis_sentinel_nodes?: string;
+    redis_sentinel_username?: string;
+    redis_sentinel_password?: string;
+    redis_sentinel_tls?: boolean;
 }
 export interface ConnectionStoreOptions {
     path?: string;

package/dist/connections.js

@@ -53,6 +53,9 @@ export async function loadConnections(options = {}) {
                 config.password = getSecret(db, row.id, "password");
             if (!config.proxy_password)
                 config.proxy_password = getSecret(db, row.id, "proxy_password");
+            if (!config.redis_sentinel_password) {
+                config.redis_sentinel_password = getSecret(db, row.id, "redis_sentinel_password");
+            }
             configs.push(config);
         }
         return configs;
@@ -148,7 +151,14 @@ export async function addConnection(config) {
         proxy_password: "",
         ssl: normalized.ssl ?? false,
         sysdba: false,
+        oracle_connection_type: normalized.oracle_connection_type ?? null,
         connection_string: null,
+        redis_connection_mode: normalized.redis_connection_mode ?? "standalone",
+        redis_sentinel_master: normalized.redis_sentinel_master ?? "",
+        redis_sentinel_nodes: normalized.redis_sentinel_nodes ?? "",
+        redis_sentinel_username: normalized.redis_sentinel_username ?? "",
+        redis_sentinel_password: "",
+        redis_sentinel_tls: normalized.redis_sentinel_tls ?? false,
     };
     const configJson = JSON.stringify(full);
     const insert = db.transaction(() => {
@@ -159,6 +169,9 @@ export async function addConnection(config) {
         if (normalized.proxy_password) {
             db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "proxy_password", normalized.proxy_password);
         }
+        if (normalized.redis_sentinel_password) {
+            db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "redis_sentinel_password", normalized.redis_sentinel_password);
+        }
     });
     insert();
     db.close();

package/dist/database.d.ts

@@ -23,3 +23,56 @@ export interface QueryOptions {
 export declare function executeQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): Promise<QueryResult>;
 export declare function listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]>;
 export declare function describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]>;
+export declare function mongoDocumentsToQueryResult(documents: unknown[], total: number): QueryResult;
+export declare function inferMongoColumns(documents: unknown[]): ColumnInfo[];
+interface MongoFindCommand {
+    collection: string;
+    filter: string;
+    skip: number;
+    limit: number;
+    sort?: string;
+}
+interface MongoCountDocumentsCommand {
+    collection: string;
+    filter: string;
+}
+interface MongoAggregateCommand {
+    collection: string;
+    pipeline: string;
+}
+export type MongoWriteCommand = {
+    kind: "insert";
+    collection: string;
+    docsJson: string;
+} | {
+    kind: "update";
+    collection: string;
+    filter: string;
+    update: string;
+    many: boolean;
+} | {
+    kind: "delete";
+    collection: string;
+    filter: string;
+    many: boolean;
+};
+export declare function parseMongoFindCommand(input: string): MongoFindCommand | null;
+export declare function parseMongoCountDocumentsCommand(input: string): MongoCountDocumentsCommand | null;
+export declare function parseMongoAggregateCommand(input: string): MongoAggregateCommand | null;
+export declare function mongoAggregateWriteStage(pipelineJson: string): "$out" | "$merge" | null;
+export declare function parseMongoWriteCommand(input: string): MongoWriteCommand | null;
+export declare function evaluateMongoWriteSafety(command: MongoWriteCommand, options: {
+    allowWrites?: boolean;
+    allowDangerous?: boolean;
+}): {
+    allowed: boolean;
+    reason?: string;
+};
+export declare function evaluateMongoAggregateSafety(command: MongoAggregateCommand, options: {
+    allowWrites?: boolean;
+    allowDangerous?: boolean;
+}): {
+    allowed: boolean;
+    reason?: string;
+};
+export {};

package/dist/database.js

@@ -337,6 +337,35 @@ function sqliteQuery(config, sql, options) {
     }
 }
 export async function executeQuery(config, sql, options) {
+    if (config.db_type === "mongodb") {
+        const find = parseMongoFindCommand(sql);
+        if (find) {
+            const result = await withTimeout(mongoFindDocuments(config, find.collection, find.skip, find.limit, find.filter, find.sort), resolveTimeoutMs(options));
+            return mongoDocumentsToQueryResult(result.documents.slice(0, resolveMaxRows(options)), result.total);
+        }
+        const count = parseMongoCountDocumentsCommand(sql);
+        if (count) {
+            const result = await withTimeout(mongoFindDocuments(config, count.collection, 0, 1, count.filter), resolveTimeoutMs(options));
+            return { columns: ["count"], rows: [{ count: result.total }], row_count: 1 };
+        }
+        const aggregate = parseMongoAggregateCommand(sql);
+        if (aggregate) {
+            const safety = evaluateMongoAggregateSafety(aggregate, sqlSafetyFromEnv());
+            if (!safety.allowed)
+                throw new Error(safety.reason);
+            const result = await withTimeout(mongoAggregateDocuments(config, aggregate.collection, aggregate.pipeline, resolveMaxRows(options)), resolveTimeoutMs(options));
+            return mongoDocumentsToQueryResult(result.documents.slice(0, resolveMaxRows(options)), result.total);
+        }
+        const write = parseMongoWriteCommand(sql);
+        if (write) {
+            const safety = evaluateMongoWriteSafety(write, sqlSafetyFromEnv());
+            if (!safety.allowed)
+                throw new Error(safety.reason);
+            const affected = await withTimeout(executeMongoWrite(config, write), resolveTimeoutMs(options));
+            return { columns: [], rows: [], row_count: affected };
+        }
+        throw new Error("Use MongoDB shell-style commands, for example: db.projects.find({}).limit(100), db.projects.countDocuments({}), db.projects.insertOne({...}), db.projects.updateOne({...}, {$set: {...}}), or db.projects.deleteOne({...})");
+    }
     if (isDirectType(config.db_type)) {
         return query(config, sql, undefined, options);
     }
@@ -348,6 +377,14 @@ export async function executeQuery(config, sql, options) {
     return convertBridgeQueryResult(result, options);
 }
 export async function listTables(config, schema) {
+    if (config.db_type === "mongodb") {
+        const collections = await bridgeDataRequest("/data/mongo/list-collections", {
+            connection_name: config.name,
+            database: config.database || "",
+            schema: schema || "",
+        });
+        return collections.map((name) => ({ name, type: "COLLECTION" }));
+    }
     if (config.db_type === "sqlite") {
         const result = await query(config, `SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name`);
         return result.rows.map((r) => ({ name: String(r.name || ""), type: String(r.type || "table") }));
@@ -370,6 +407,10 @@ export async function listTables(config, schema) {
     return result.rows.map((r) => ({ name: String(r.name || r.NAME), type: String(r.type || r.TYPE || "TABLE") }));
 }
 export async function describeTable(config, table, schema) {
+    if (config.db_type === "mongodb") {
+        const result = await mongoFindDocuments(config, table, 0, 20, "{}");
+        return inferMongoColumns(result.documents);
+    }
     if (config.db_type === "sqlite") {
         const result = await query(config, `PRAGMA table_info(${quoteSqliteIdentifier(table)})`);
         return result.rows.map((r) => ({
@@ -413,3 +454,379 @@ export async function describeTable(config, table, schema) {
         comment: r.comment != null ? String(r.comment) : null,
     }));
 }
+async function mongoFindDocuments(config, collection, skip, limit, filter, sort) {
+    return bridgeDataRequest("/data/mongo/find-documents", {
+        connection_name: config.name,
+        database: config.database || "",
+        collection,
+        skip,
+        limit,
+        filter,
+        sort,
+    });
+}
+async function executeMongoWrite(config, command) {
+    if (command.kind === "insert") {
+        const result = await bridgeDataRequest("/data/mongo/insert-documents", {
+            connection_name: config.name,
+            database: config.database || "",
+            collection: command.collection,
+            docs_json: command.docsJson,
+        });
+        return result.affected_rows;
+    }
+    if (command.kind === "update") {
+        const result = await bridgeDataRequest("/data/mongo/update-documents", {
+            connection_name: config.name,
+            database: config.database || "",
+            collection: command.collection,
+            filter_json: command.filter,
+            update_json: command.update,
+            many: command.many,
+        });
+        return result.affected_rows;
+    }
+    const result = await bridgeDataRequest("/data/mongo/delete-documents", {
+        connection_name: config.name,
+        database: config.database || "",
+        collection: command.collection,
+        filter_json: command.filter,
+        many: command.many,
+    });
+    return result.affected_rows;
+}
+async function mongoAggregateDocuments(config, collection, pipelineJson, maxRows) {
+    return bridgeDataRequest("/data/mongo/aggregate-documents", {
+        connection_name: config.name,
+        database: config.database || "",
+        collection,
+        pipeline_json: pipelineJson,
+        max_rows: maxRows,
+    });
+}
+export function mongoDocumentsToQueryResult(documents, total) {
+    const columns = [];
+    for (const doc of documents) {
+        if (isRecord(doc)) {
+            for (const key of Object.keys(doc)) {
+                if (!columns.includes(key))
+                    columns.push(key);
+            }
+        }
+        else if (!columns.includes("value")) {
+            columns.push("value");
+        }
+    }
+    const rows = documents.map((doc) => {
+        const row = {};
+        for (const column of columns) {
+            row[column] = isRecord(doc) ? toCellValue(doc[column]) : column === "value" ? toCellValue(doc) : null;
+        }
+        return row;
+    });
+    return { columns, rows, row_count: rows.length };
+}
+export function inferMongoColumns(documents) {
+    const columns = new Map();
+    for (const doc of documents) {
+        if (!isRecord(doc)) {
+            const entry = columns.get("value") ?? { types: new Set(), nullable: false };
+            entry.types.add(mongoTypeName(doc));
+            columns.set("value", entry);
+            continue;
+        }
+        for (const [name, value] of Object.entries(doc)) {
+            const entry = columns.get(name) ?? { types: new Set(), nullable: false };
+            entry.types.add(mongoTypeName(value));
+            if (value === null || value === undefined)
+                entry.nullable = true;
+            columns.set(name, entry);
+        }
+    }
+    return Array.from(columns.entries()).map(([name, entry]) => ({
+        name,
+        data_type: Array.from(entry.types).sort().join(" | ") || "unknown",
+        is_nullable: entry.nullable,
+        column_default: null,
+        is_primary_key: name === "_id",
+        comment: null,
+    }));
+}
+export function parseMongoFindCommand(input) {
+    const source = input.trim().replace(/;$/, "").trim();
+    const target = parseCollectionMethodTarget(source, "find");
+    if (!target)
+        return null;
+    const findOpenIndex = source.indexOf("(", target.methodCallIndex);
+    const findCloseIndex = findMatchingParen(source, findOpenIndex);
+    if (findCloseIndex < 0)
+        return null;
+    const findArgs = splitTopLevel(source.slice(findOpenIndex + 1, findCloseIndex));
+    const filter = normalizeJsonArgument(findArgs[0] || "{}");
+    if (!filter)
+        return null;
+    const chain = source.slice(findCloseIndex + 1).trim();
+    if (chain && !chain.startsWith("."))
+        return null;
+    const sortArg = readChainedCallArgument(chain, "sort");
+    let sort;
+    if (sortArg !== undefined) {
+        const parsedSort = normalizeJsonArgument(sortArg);
+        if (!parsedSort)
+            return null;
+        sort = parsedSort;
+    }
+    const skip = readChainedIntegerArgument(chain, "skip", 0);
+    const limit = readChainedIntegerArgument(chain, "limit", MAX_ROWS);
+    if (skip === null || limit === null)
+        return null;
+    return { collection: target.collection, filter, skip, limit, sort };
+}
+export function parseMongoCountDocumentsCommand(input) {
+    const source = input.trim().replace(/;$/, "").trim();
+    const target = parseCollectionMethodTarget(source, "countDocuments");
+    if (!target)
+        return null;
+    const openIndex = source.indexOf("(", target.methodCallIndex);
+    const closeIndex = findMatchingParen(source, openIndex);
+    if (closeIndex < 0 || source.slice(closeIndex + 1).trim())
+        return null;
+    const args = splitTopLevel(source.slice(openIndex + 1, closeIndex));
+    if (args.length > 1 && args.slice(1).some((arg) => arg.trim()))
+        return null;
+    const filter = normalizeJsonArgument(args[0] || "{}");
+    return filter ? { collection: target.collection, filter } : null;
+}
+export function parseMongoAggregateCommand(input) {
+    const source = input.trim().replace(/;$/, "").trim();
+    const target = parseCollectionMethodTarget(source, "aggregate");
+    if (!target)
+        return null;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args || args.length !== 1)
+        return null;
+    const pipeline = normalizeJsonArgument(args[0]);
+    if (!pipeline)
+        return null;
+    return Array.isArray(JSON.parse(pipeline)) ? { collection: target.collection, pipeline } : null;
+}
+export function mongoAggregateWriteStage(pipelineJson) {
+    try {
+        const pipeline = JSON.parse(pipelineJson);
+        if (!Array.isArray(pipeline))
+            return null;
+        for (const stage of pipeline) {
+            if (!isRecord(stage))
+                continue;
+            if (Object.prototype.hasOwnProperty.call(stage, "$out"))
+                return "$out";
+            if (Object.prototype.hasOwnProperty.call(stage, "$merge"))
+                return "$merge";
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseMongoWriteCommand(input) {
+    const source = input.trim().replace(/;$/, "").trim();
+    const insertOne = parseCollectionMethodTarget(source, "insertOne");
+    if (insertOne) {
+        const args = parseMethodArgs(source, insertOne.methodCallIndex);
+        if (!args || args.length !== 1)
+            return null;
+        const doc = normalizeJsonArgument(args[0]);
+        return doc ? { kind: "insert", collection: insertOne.collection, docsJson: doc } : null;
+    }
+    const insertMany = parseCollectionMethodTarget(source, "insertMany");
+    if (insertMany) {
+        const args = parseMethodArgs(source, insertMany.methodCallIndex);
+        if (!args || args.length !== 1)
+            return null;
+        const docs = normalizeJsonArgument(args[0]);
+        if (!docs)
+            return null;
+        return Array.isArray(JSON.parse(docs)) ? { kind: "insert", collection: insertMany.collection, docsJson: docs } : null;
+    }
+    for (const method of ["updateOne", "updateMany"]) {
+        const target = parseCollectionMethodTarget(source, method);
+        if (!target)
+            continue;
+        const args = parseMethodArgs(source, target.methodCallIndex);
+        if (!args || args.length !== 2)
+            return null;
+        const filter = normalizeJsonArgument(args[0]);
+        const update = normalizeJsonArgument(args[1]);
+        if (!filter || !update)
+            return null;
+        return { kind: "update", collection: target.collection, filter, update, many: method === "updateMany" };
+    }
+    for (const method of ["deleteOne", "deleteMany"]) {
+        const target = parseCollectionMethodTarget(source, method);
+        if (!target)
+            continue;
+        const args = parseMethodArgs(source, target.methodCallIndex);
+        if (!args || args.length !== 1)
+            return null;
+        const filter = normalizeJsonArgument(args[0]);
+        if (!filter)
+            return null;
+        return { kind: "delete", collection: target.collection, filter, many: method === "deleteMany" };
+    }
+    return null;
+}
+export function evaluateMongoWriteSafety(command, options) {
+    if (!options.allowWrites) {
+        return {
+            allowed: false,
+            reason: "MCP MongoDB execution is read-only by default. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.",
+        };
+    }
+    if (!options.allowDangerous && (command.kind === "update" || command.kind === "delete") && isEmptyJsonObject(command.filter)) {
+        return {
+            allowed: false,
+            reason: "MongoDB update/delete commands must include a non-empty filter unless DBX_MCP_ALLOW_DANGEROUS_SQL=1 is set.",
+        };
+    }
+    return { allowed: true };
+}
+export function evaluateMongoAggregateSafety(command, options) {
+    const writeStage = mongoAggregateWriteStage(command.pipeline);
+    if (!writeStage)
+        return { allowed: true };
+    if (!options.allowWrites) {
+        return {
+            allowed: false,
+            reason: `MongoDB aggregate stage "${writeStage}" writes data. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.`,
+        };
+    }
+    if (!options.allowDangerous) {
+        return {
+            allowed: false,
+            reason: `MongoDB aggregate stage "${writeStage}" is dangerous. Set DBX_MCP_ALLOW_DANGEROUS_SQL=1 to allow it.`,
+        };
+    }
+    return { allowed: true };
+}
+function parseCollectionMethodTarget(source, method) {
+    const direct = new RegExp(`^db\\.([A-Za-z_$][\\w$]*)\\.${method}\\s*\\(`).exec(source);
+    if (direct)
+        return { collection: direct[1], methodCallIndex: source.indexOf(`.${method}`) };
+    const quoted = new RegExp(`^db\\.getCollection\\(\\s*(['"])([^'"]+)\\1\\s*\\)\\.${method}\\s*\\(`).exec(source);
+    if (quoted)
+        return { collection: quoted[2], methodCallIndex: source.indexOf(`.${method}`) };
+    return null;
+}
+function parseMethodArgs(source, methodCallIndex) {
+    const openIndex = source.indexOf("(", methodCallIndex);
+    const closeIndex = findMatchingParen(source, openIndex);
+    if (closeIndex < 0 || source.slice(closeIndex + 1).trim())
+        return null;
+    return splitTopLevel(source.slice(openIndex + 1, closeIndex));
+}
+function readChainedCallArgument(chain, method) {
+    const pattern = new RegExp(`\\.${method}\\s*\\(`, "g");
+    const match = pattern.exec(chain);
+    if (!match)
+        return undefined;
+    const openIndex = match.index + match[0].lastIndexOf("(");
+    const closeIndex = findMatchingParen(chain, openIndex);
+    return closeIndex < 0 ? undefined : chain.slice(openIndex + 1, closeIndex);
+}
+function readChainedIntegerArgument(chain, method, fallback) {
+    const arg = readChainedCallArgument(chain, method);
+    if (arg === undefined)
+        return fallback;
+    if (!/^\d+$/.test(arg.trim()))
+        return null;
+    return Number(arg.trim());
+}
+function normalizeJsonArgument(arg) {
+    const value = (arg.trim() || "{}").replace(/ObjectId\s*\(\s*["']([^"']+)["']\s*\)/g, '{"$oid":"$1"}');
+    try {
+        JSON.parse(value);
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function isEmptyJsonObject(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return isRecord(parsed) && Object.keys(parsed).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+function splitTopLevel(source) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    let quote = null;
+    for (let i = 0; i < source.length; i += 1) {
+        const ch = source[i];
+        if (quote) {
+            if (ch === "\\" && i + 1 < source.length)
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"')
+            quote = ch;
+        else if (ch === "{" || ch === "[" || ch === "(")
+            depth += 1;
+        else if (ch === "}" || ch === "]" || ch === ")")
+            depth -= 1;
+        else if (ch === "," && depth === 0) {
+            parts.push(source.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(source.slice(start));
+    return parts;
+}
+function findMatchingParen(source, openIndex) {
+    if (openIndex < 0 || source[openIndex] !== "(")
+        return -1;
+    let depth = 0;
+    let quote = null;
+    for (let i = openIndex; i < source.length; i += 1) {
+        const ch = source[i];
+        if (quote) {
+            if (ch === "\\" && i + 1 < source.length)
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === "'" || ch === '"')
+            quote = ch;
+        else if (ch === "(")
+            depth += 1;
+        else if (ch === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mongoTypeName(value) {
+    if (value === null || value === undefined)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    if (isRecord(value))
+        return "object";
+    return typeof value;
+}
+function toCellValue(value) {
+    return typeof value === "object" && value !== null ? JSON.stringify(value) : value;
+}

package/dist/diagnostics.d.ts

@@ -1,5 +1,5 @@
-export declare const DIRECT_QUERY_TYPES: readonly ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite"];
-export declare const BRIDGE_REQUIRED_TYPES: readonly ["redis", "mongodb", "duckdb", "clickhouse", "sqlserver", "oracle", "elasticsearch", "dameng", "kingbase", "highgo", "vastbase", "goldendb", "gaussdb", "tdengine", "h2", "snowflake", "trino", "hive", "db2", "informix", "neo4j", "cassandra", "bigquery", "kylin", "sundb", "jdbc", "access"];
+export declare const DIRECT_QUERY_TYPES: readonly ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite", "gaussdb", "opengauss"];
+export declare const BRIDGE_REQUIRED_TYPES: readonly ["redis", "mongodb", "duckdb", "clickhouse", "sqlserver", "oracle", "elasticsearch", "dameng", "kingbase", "highgo", "vastbase", "goldendb", "yashandb", "databricks", "saphana", "teradata", "vertica", "firebird", "exasol", "oceanbase-oracle", "gbase", "tdengine", "h2", "snowflake", "trino", "hive", "db2", "informix", "neo4j", "cassandra", "bigquery", "kylin", "sundb", "xugu", "jdbc", "access"];
 export interface DbxDiagnostics {
     appDataDir: string;
     dbPath: string;

package/dist/diagnostics.js

@@ -1,7 +1,7 @@
 import { access, readFile } from "node:fs/promises";
 import { bridgePortFilePath, dbPath, appDataDir } from "./paths.js";
 import { inspectConnectionStore } from "./connections.js";
-export const DIRECT_QUERY_TYPES = ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite"];
+export const DIRECT_QUERY_TYPES = ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite", "gaussdb", "opengauss"];
 export const BRIDGE_REQUIRED_TYPES = [
     "redis",
     "mongodb",
@@ -15,7 +15,15 @@ export const BRIDGE_REQUIRED_TYPES = [
     "highgo",
     "vastbase",
     "goldendb",
-    "gaussdb",
+    "yashandb",
+    "databricks",
+    "saphana",
+    "teradata",
+    "vertica",
+    "firebird",
+    "exasol",
+    "oceanbase-oracle",
+    "gbase",
     "tdengine",
     "h2",
     "snowflake",
@@ -28,6 +36,7 @@ export const BRIDGE_REQUIRED_TYPES = [
     "bigquery",
     "kylin",
     "sundb",
+    "xugu",
     "jdbc",
     "access",
 ];

package/dist/format.d.ts

@@ -0,0 +1,2 @@
+export declare function mdTable(headers: string[], rows: string[][]): string;
+export declare function formatCell(value: unknown): string;

package/dist/format.js

@@ -0,0 +1,14 @@
+export function mdTable(headers, rows) {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length), 3));
+    const header = `| ${headers.map((h, i) => h.padEnd(widths[i])).join(" | ")} |`;
+    const sep = `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`;
+    const body = rows.map((r) => `| ${r.map((c, i) => (c || "").padEnd(widths[i])).join(" | ")} |`).join("\n");
+    return body ? `${header}\n${sep}\n${body}` : `${header}\n${sep}`;
+}
+export function formatCell(value) {
+    if (value === null || value === undefined)
+        return "NULL";
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./bridge.js";
 export * from "./connections.js";
 export * from "./database.js";
 export * from "./diagnostics.js";
+export * from "./format.js";
 export * from "./paths.js";
 export * from "./schema-context.js";
 export * from "./sql-safety.js";

package/dist/index.js

@@ -3,6 +3,7 @@ export * from "./bridge.js";
 export * from "./connections.js";
 export * from "./database.js";
 export * from "./diagnostics.js";
+export * from "./format.js";
 export * from "./paths.js";
 export * from "./schema-context.js";
 export * from "./sql-safety.js";

package/dist/web-backend.js

@@ -1,3 +1,5 @@
+import { evaluateMongoAggregateSafety, evaluateMongoWriteSafety, inferMongoColumns, mongoDocumentsToQueryResult, parseMongoAggregateCommand, parseMongoCountDocumentsCommand, parseMongoFindCommand, parseMongoWriteCommand, } from "./database.js";
+import { sqlSafetyFromEnv } from "./sql-safety.js";
 const baseUrl = process.env.DBX_WEB_URL.replace(/\/+$/, "");
 const password = process.env.DBX_WEB_PASSWORD || "";
 let sessionCookie = null;
@@ -73,6 +75,14 @@ async function ensureConnected(config) {
 }
 export async function listTables(config, schema) {
     await ensureConnected(config);
+    if (config.db_type === "mongodb") {
+        const res = await apiFetch("/api/mongo/list-collections", {
+            method: "POST",
+            body: JSON.stringify({ connectionId: config.id, database: config.database || "" }),
+        });
+        const collections = (await res.json());
+        return collections.map((name) => ({ name, type: "COLLECTION" }));
+    }
     const params = new URLSearchParams({
         connection_id: config.id,
         database: config.database || "",
@@ -83,6 +93,14 @@ export async function listTables(config, schema) {
 }
 export async function describeTable(config, table, schema) {
     await ensureConnected(config);
+    if (config.db_type === "mongodb") {
+        const res = await apiFetch("/api/mongo/find-documents", {
+            method: "POST",
+            body: JSON.stringify({ connectionId: config.id, database: config.database || "", collection: table, skip: 0, limit: 20, filter: "{}" }),
+        });
+        const result = (await res.json());
+        return inferMongoColumns(result.documents);
+    }
     const params = new URLSearchParams({
         connection_id: config.id,
         database: config.database || "",
@@ -94,6 +112,68 @@ export async function describeTable(config, table, schema) {
 }
 export async function executeQuery(config, sql, options) {
     await ensureConnected(config);
+    if (config.db_type === "mongodb") {
+        const find = parseMongoFindCommand(sql);
+        if (find) {
+            const res = await apiFetch("/api/mongo/find-documents", {
+                method: "POST",
+                body: JSON.stringify({
+                    connectionId: config.id,
+                    database: config.database || "",
+                    collection: find.collection,
+                    skip: find.skip,
+                    limit: find.limit,
+                    filter: find.filter,
+                    sort: find.sort,
+                }),
+            });
+            const result = (await res.json());
+            return mongoDocumentsToQueryResult(result.documents.slice(0, options?.maxRows ?? result.documents.length), result.total);
+        }
+        const count = parseMongoCountDocumentsCommand(sql);
+        if (count) {
+            const res = await apiFetch("/api/mongo/find-documents", {
+                method: "POST",
+                body: JSON.stringify({
+                    connectionId: config.id,
+                    database: config.database || "",
+                    collection: count.collection,
+                    skip: 0,
+                    limit: 1,
+                    filter: count.filter,
+                }),
+            });
+            const result = (await res.json());
+            return { columns: ["count"], rows: [{ count: result.total }], row_count: 1 };
+        }
+        const aggregate = parseMongoAggregateCommand(sql);
+        if (aggregate) {
+            const safety = evaluateMongoAggregateSafety(aggregate, sqlSafetyFromEnv());
+            if (!safety.allowed)
+                throw new Error(safety.reason);
+            const res = await apiFetch("/api/mongo/aggregate-documents", {
+                method: "POST",
+                body: JSON.stringify({
+                    connectionId: config.id,
+                    database: config.database || "",
+                    collection: aggregate.collection,
+                    pipelineJson: aggregate.pipeline,
+                    maxRows: options?.maxRows ?? 100,
+                }),
+            });
+            const result = (await res.json());
+            return mongoDocumentsToQueryResult(result.documents.slice(0, options?.maxRows ?? result.documents.length), result.total);
+        }
+        const write = parseMongoWriteCommand(sql);
+        if (write) {
+            const safety = evaluateMongoWriteSafety(write, sqlSafetyFromEnv());
+            if (!safety.allowed)
+                throw new Error(safety.reason);
+            const affected = await executeMongoWrite(config, write);
+            return { columns: [], rows: [], row_count: affected };
+        }
+        throw new Error("Use MongoDB shell-style commands, for example: db.projects.find({}).limit(100), db.projects.countDocuments({}), db.projects.insertOne({...}), db.projects.updateOne({...}, {$set: {...}}), or db.projects.deleteOne({...})");
+    }
     const res = await apiFetch("/api/query/execute", {
         method: "POST",
         body: JSON.stringify({
@@ -113,3 +193,45 @@ export async function executeQuery(config, sql, options) {
     const limitedRows = rows.slice(0, options?.maxRows ?? rows.length);
     return { columns: data.columns, rows: limitedRows, row_count: limitedRows.length };
 }
+async function executeMongoWrite(config, command) {
+    if (command.kind === "insert") {
+        const res = await apiFetch("/api/mongo/insert-documents", {
+            method: "POST",
+            body: JSON.stringify({
+                connectionId: config.id,
+                database: config.database || "",
+                collection: command.collection,
+                docsJson: command.docsJson,
+            }),
+        });
+        const result = (await res.json());
+        return result.affected_rows;
+    }
+    if (command.kind === "update") {
+        const res = await apiFetch("/api/mongo/update-documents", {
+            method: "POST",
+            body: JSON.stringify({
+                connectionId: config.id,
+                database: config.database || "",
+                collection: command.collection,
+                filterJson: command.filter,
+                updateJson: command.update,
+                many: command.many,
+            }),
+        });
+        const result = (await res.json());
+        return result.affected_rows;
+    }
+    const res = await apiFetch("/api/mongo/delete-documents", {
+        method: "POST",
+        body: JSON.stringify({
+            connectionId: config.id,
+            database: config.database || "",
+            collection: command.collection,
+            filterJson: command.filter,
+            many: command.many,
+        }),
+    });
+    const result = (await res.json());
+    return result.affected_rows;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dbx-app/node-core",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Shared Node.js database and DBX connection utilities for DBX CLI and MCP server",
   "type": "module",
   "engines": {
@@ -16,6 +16,7 @@
     "./connections": "./dist/connections.js",
     "./database": "./dist/database.js",
     "./diagnostics": "./dist/diagnostics.js",
+    "./format": "./dist/format.js",
     "./paths": "./dist/paths.js",
     "./schema-context": "./dist/schema-context.js",
     "./sql-safety": "./dist/sql-safety.js"