@dbx-app/node-core 0.4.7 → 0.4.8

package/README.md

@@ -21,13 +21,7 @@ Other DBX connection types can be routed through DBX Desktop bridge integrations
 ## Public Modules
 
 ```ts
-import {
-  createBackend,
-  loadConnections,
-  getDbxDiagnostics,
-  evaluateSqlSafety,
-  buildSchemaContext,
-} from "@dbx-app/node-core";
+import { createBackend, loadConnections, getDbxDiagnostics, evaluateSqlSafety, buildSchemaContext } from "@dbx-app/node-core";
 ```
 
 The package is intended as a shared implementation layer for official DBX Node packages. Applications should prefer `@dbx-app/cli` for terminal workflows and `@dbx-app/mcp-server` for MCP clients.

package/dist/backend.js

@@ -1,5 +1,5 @@
-import { addConnection as desktopAddConnection, findConnection as desktopFindConnection, loadConnections as desktopLoadConnections, removeConnection as desktopRemoveConnection, } from "./connections.js";
-import { closeDatabaseResources as desktopCloseDatabaseResources, describeTable as desktopDescribeTable, executeQuery as desktopExecuteQuery, listTables as desktopListTables, } from "./database.js";
+import { addConnection as desktopAddConnection, findConnection as desktopFindConnection, loadConnections as desktopLoadConnections, removeConnection as desktopRemoveConnection } from "./connections.js";
+import { closeDatabaseResources as desktopCloseDatabaseResources, describeTable as desktopDescribeTable, executeQuery as desktopExecuteQuery, listTables as desktopListTables } from "./database.js";
 export async function createBackend(env = process.env) {
     if (env.DBX_WEB_URL) {
         return await import("./web-backend.js");

package/dist/connections.d.ts

@@ -19,6 +19,7 @@ export interface ConnectionConfig {
     redis_sentinel_username?: string;
     redis_sentinel_password?: string;
     redis_sentinel_tls?: boolean;
+    read_only?: boolean;
 }
 export type TransportLayerConfig = ({
     type: "ssh";

package/dist/connections.js

@@ -32,9 +32,7 @@ function openDb(readonly = false, path = defaultDbPath()) {
     return new Database(path, { readonly });
 }
 function getSecret(db, connectionId, key) {
-    const row = db
-        .prepare("SELECT secret FROM connection_secrets WHERE connection_id = ? AND key = ?")
-        .get(connectionId, key);
+    const row = db.prepare("SELECT secret FROM connection_secrets WHERE connection_id = ? AND key = ?").get(connectionId, key);
     return row?.secret ?? "";
 }
 function transportLayerSecretSegment(index, layer) {
@@ -89,19 +87,11 @@ function hydrateTransportLayerSecrets(db, config, connectionId) {
     config.transport_layers = normalizeTransportLayers(config);
     config.transport_layers.forEach((layer, index) => {
         if (layer.type === "ssh") {
-            layer.password ||=
-                getSecret(db, connectionId, transportLayerSshPasswordKey(index, layer)) ||
-                    (layer.id === "legacy" ? getSecret(db, connectionId, "ssh_password") : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.password`));
-            layer.key_passphrase ||=
-                getSecret(db, connectionId, transportLayerSshKeyPassphraseKey(index, layer)) ||
-                    (layer.id === "legacy"
-                        ? getSecret(db, connectionId, "ssh_key_passphrase")
-                        : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.key_passphrase`));
+            layer.password ||= getSecret(db, connectionId, transportLayerSshPasswordKey(index, layer)) || (layer.id === "legacy" ? getSecret(db, connectionId, "ssh_password") : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.password`));
+            layer.key_passphrase ||= getSecret(db, connectionId, transportLayerSshKeyPassphraseKey(index, layer)) || (layer.id === "legacy" ? getSecret(db, connectionId, "ssh_key_passphrase") : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.key_passphrase`));
         }
         else {
-            layer.password ||=
-                getSecret(db, connectionId, transportLayerProxyPasswordKey(index, layer)) ||
-                    (layer.id === "legacy-proxy" ? getSecret(db, connectionId, "proxy_password") : "");
+            layer.password ||= getSecret(db, connectionId, transportLayerProxyPasswordKey(index, layer)) || (layer.id === "legacy-proxy" ? getSecret(db, connectionId, "proxy_password") : "");
         }
     });
 }
@@ -176,9 +166,7 @@ export async function inspectConnectionStore(options = {}) {
     return diagnostics;
 }
 function tableExists(db, name) {
-    const row = db
-        .prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?")
-        .get(name);
+    const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name);
     return !!row;
 }
 export async function findConnection(name) {

package/dist/database.js

@@ -274,7 +274,9 @@ function resolveTimeoutMs(options) {
 function convertBridgeQueryResult(result, options) {
     const rows = result.rows.slice(0, resolveMaxRows(options)).map((row) => {
         const obj = {};
-        result.columns.forEach((col, i) => { obj[col] = row[i]; });
+        result.columns.forEach((col, i) => {
+            obj[col] = row[i];
+        });
         return obj;
     });
     return { columns: result.columns, rows, row_count: rows.length };

package/dist/diagnostics.d.ts

@@ -1,7 +1,7 @@
 export declare const DIRECT_QUERY_TYPES: readonly ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite", "rqlite", "gaussdb", "kwdb", "opengauss"];
 export type DirectQueryType = (typeof DIRECT_QUERY_TYPES)[number];
 export declare function isDirectQueryType(dbType: string): dbType is DirectQueryType;
-export declare const BRIDGE_REQUIRED_TYPES: readonly ["redis", "mongodb", "duckdb", "clickhouse", "sqlserver", "oracle", "elasticsearch", "dameng", "kingbase", "highgo", "vastbase", "goldendb", "databend", "yashandb", "databricks", "saphana", "teradata", "vertica", "firebird", "exasol", "oceanbase-oracle", "gbase", "tdengine", "iotdb", "h2", "snowflake", "trino", "hive", "db2", "informix", "iris", "neo4j", "cassandra", "bigquery", "kylin", "sundb", "xugu", "jdbc", "access"];
+export declare const BRIDGE_REQUIRED_TYPES: readonly ["redis", "mongodb", "duckdb", "clickhouse", "sqlserver", "oracle", "elasticsearch", "etcd", "dameng", "kingbase", "highgo", "vastbase", "goldendb", "databend", "yashandb", "databricks", "saphana", "teradata", "vertica", "firebird", "exasol", "oceanbase-oracle", "gbase", "tdengine", "iotdb", "h2", "snowflake", "trino", "hive", "db2", "informix", "iris", "neo4j", "cassandra", "bigquery", "kylin", "sundb", "xugu", "jdbc", "access"];
 export interface DbxDiagnostics {
     appDataDir: string;
     dbPath: string;

package/dist/diagnostics.js

@@ -1,18 +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",
-    "rqlite",
-    "gaussdb",
-    "kwdb",
-    "opengauss",
-];
+export const DIRECT_QUERY_TYPES = ["postgres", "redshift", "mysql", "doris", "starrocks", "sqlite", "rqlite", "gaussdb", "kwdb", "opengauss"];
 const DIRECT_QUERY_TYPE_SET = new Set(DIRECT_QUERY_TYPES);
 export function isDirectQueryType(dbType) {
     return DIRECT_QUERY_TYPE_SET.has(dbType);
@@ -25,6 +14,7 @@ export const BRIDGE_REQUIRED_TYPES = [
     "sqlserver",
     "oracle",
     "elasticsearch",
+    "etcd",
     "dameng",
     "kingbase",
     "highgo",
@@ -79,9 +69,7 @@ export async function getDbxDiagnostics() {
         loadConnectionsOk: connectionStore.loadConnectionsOk,
         loadedConnectionCount: connectionStore.loadedConnectionCount,
         loadConnectionsError: connectionStore.loadConnectionsError,
-        loadConnectionsHint: connectionStore.loadConnectionsError
-            ? connectionStoreHint(connectionStore.loadConnectionsError)
-            : undefined,
+        loadConnectionsHint: connectionStore.loadConnectionsError ? connectionStoreHint(connectionStore.loadConnectionsError) : undefined,
         bridgePortFile: portFile,
         bridgePortFileExists,
         bridgeUrl,

package/dist/schema-context.js

@@ -3,9 +3,7 @@ export async function buildSchemaContext(backend, config, options = {}) {
     const maxTables = Math.max(1, Math.min(options.maxTables ?? DEFAULT_MAX_TABLES, 20));
     const availableTables = await backend.listTables(config, options.schema);
     const requested = new Set((options.tables ?? []).map((table) => table.toLowerCase()));
-    const selected = requested.size
-        ? availableTables.filter((table) => requested.has(table.name.toLowerCase()))
-        : availableTables.slice(0, maxTables);
+    const selected = requested.size ? availableTables.filter((table) => requested.has(table.name.toLowerCase())) : availableTables.slice(0, maxTables);
     const limited = selected.slice(0, maxTables);
     const tables = await Promise.all(limited.map(async (table) => ({
         name: table.name,
@@ -21,19 +19,10 @@ export async function buildSchemaContext(backend, config, options = {}) {
     };
 }
 export function formatSchemaContext(context) {
-    const header = [
-        `Connection: ${context.connection}`,
-        context.database ? `Database: ${context.database}` : "",
-        context.schema ? `Schema: ${context.schema}` : "",
-    ].filter(Boolean);
+    const header = [`Connection: ${context.connection}`, context.database ? `Database: ${context.database}` : "", context.schema ? `Schema: ${context.schema}` : ""].filter(Boolean);
     const sections = context.tables.map((table) => {
         const lines = table.columns.map((column) => {
-            const parts = [
-                column.name,
-                column.data_type,
-                column.is_nullable ? "NULL" : "NOT NULL",
-                column.is_primary_key ? "PK" : "",
-            ].filter(Boolean);
+            const parts = [column.name, column.data_type, column.is_nullable ? "NULL" : "NOT NULL", column.is_primary_key ? "PK" : ""].filter(Boolean);
             return `- ${parts.join(" ")}${column.comment ? ` -- ${column.comment}` : ""}`;
         });
         return [`## ${table.name}`, `Type: ${table.type}`, ...lines].join("\n");

package/dist/web-backend.js

@@ -1,4 +1,4 @@
-import { evaluateMongoAggregateSafety, evaluateMongoWriteSafety, inferMongoColumns, mongoDocumentsToQueryResult, parseMongoAggregateCommand, parseMongoCountDocumentsCommand, parseMongoFindCommand, parseMongoGetIndexesCommand, parseMongoWriteCommand, } from "./database.js";
+import { evaluateMongoAggregateSafety, evaluateMongoWriteSafety, inferMongoColumns, mongoDocumentsToQueryResult, parseMongoAggregateCommand, parseMongoCountDocumentsCommand, parseMongoFindCommand, parseMongoGetIndexesCommand, 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 || "";

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@dbx-app/node-core",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "description": "Shared Node.js database and DBX connection utilities for DBX CLI and MCP server",
-  "type": "module",
-  "engines": {
-    "node": ">=22.13.0"
-  },
+  "license": "Apache-2.0",
   "files": [
     "dist"
   ],
+  "type": "module",
   "exports": {
     ".": "./dist/index.js",
     "./backend": "./dist/backend.js",
@@ -22,7 +20,6 @@
     "./schema-context": "./dist/schema-context.js",
     "./sql-safety": "./dist/sql-safety.js"
   },
-  "license": "Apache-2.0",
   "dependencies": {
     "better-sqlite3": "^12.9.0",
     "keytar": "^7.9.0",
@@ -36,6 +33,9 @@
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   },
+  "engines": {
+    "node": ">=22.13.0"
+  },
   "scripts": {
     "test": "vitest run --config vitest.config.ts",
     "build": "tsc"