dsh-db-tool 0.1.3 → 0.1.5

package/client/client.js

@@ -66,6 +66,7 @@ window.__ModuleLoader__.load({
 			modeRw: "读写",
 			// 浏览
 			noDatabases: "无可用数据库",
+			noSchemas: "无模式",
 			noTables: "无表",
 			loadFailed: "加载失败",
 			structure: "结构",
@@ -150,6 +151,7 @@ window.__ModuleLoader__.load({
 			modeRo: "read-only ro",
 			modeRw: "read-write rw",
 			noDatabases: "No databases available",
+			noSchemas: "No schemas",
 			noTables: "No tables",
 			loadFailed: "Failed to load",
 			structure: "Structure",
@@ -708,7 +710,8 @@ window.__ModuleLoader__.load({
 			const [loading, setLoading] = React.useState({});
 			const [error, setError] = React.useState({}); // 树节点加载失败信息（就地显示，可点重试）
 			const [dbs, setDbs] = React.useState({}); // connId -> string[]
-			const [tablesMap, setTablesMap] = React.useState({}); // "<connId>/<db>" -> TableInfo[]
+			const [schemasMap, setSchemasMap] = React.useState({}); // "<connId>/<db>" -> string[]（PG/GaussDB 库内 schema 层）
+			const [tablesMap, setTablesMap] = React.useState({}); // "<connId>/<db|schema>" -> TableInfo[]
 			const [sel, setSel] = React.useState(null); // {connId, db, table: TableInfo}
 			const [schema, setSchema] = React.useState([]);
 			const [preview, setPreview] = React.useState(null); // QueryResult
@@ -718,7 +721,7 @@ window.__ModuleLoader__.load({
 
 			// 会话项目切换 / 连接列表变化时清空树缓存，避免陈旧授权下的旧数据
 			React.useEffect(() => {
-				setOpen({}); setLoading({}); setError({}); setDbs({}); setTablesMap({}); setSel(null); setSchema([]); setPreview(null);
+				setOpen({}); setLoading({}); setError({}); setDbs({}); setSchemasMap({}); setTablesMap({}); setSel(null); setSchema([]); setPreview(null);
 			}, [projectPath]);
 
 			function toggle(key, load) {
@@ -744,22 +747,37 @@ window.__ModuleLoader__.load({
 						setDbs((m) => Object.assign({}, m, { [c.id]: list || [] }));
 					}));
 			}
+			// PG/GaussDB 官方层级为 数据库 → 模式(schema) → 表：库节点下先列 schema 再列表
+			const HAS_SCHEMAS = { postgresql: true, gaussdb: true };
 			function toggleDb(c, d) {
 				if (!projectPath) return;
+				const useSchemas = !!HAS_SCHEMAS[c.kind];
+				const what = useSchemas ? "schemas" : "tables";
 				toggle("d:" + c.id + "/" + d, () =>
-					api("tables" + qs({ project: projectPath, connId: c.id, database: d })).then((list) => {
-						setTablesMap((m) => Object.assign({}, m, { [c.id + "/" + d]: list || [] }));
+					api(what + qs({ project: projectPath, connId: c.id, database: d })).then((list) => {
+						const setter = useSchemas ? setSchemasMap : setTablesMap;
+						setter((m) => Object.assign({}, m, { [c.id + "/" + d]: list || [] }));
+					}));
+			}
+			function toggleSchema(c, d, s) {
+				if (!projectPath) return;
+				// PG 系跨库浏览：tables 的 database 传 "库名.schema"（Navicat 官方行为，服务端按库开连接）
+				toggle("s:" + c.id + "/" + d + "/" + s, () =>
+					api("tables" + qs({ project: projectPath, connId: c.id, database: d + "." + s })).then((list) => {
+						setTablesMap((m) => Object.assign({}, m, { [c.id + "/" + d + "/" + s]: list || [] }));
 					}));
 			}
 			// 请求序号守卫：快速切换选中表/翻页时，丢弃晚到的旧响应，防止旧数据覆盖新选中项
 			const openSeq = React.useRef(0);
 			const openTable = React.useCallback((s, pg) => {
 				if (!s || !projectPath) return;
+				// PG 系跨库：database 传 "库名.schema"；其它库传库名
+				const dbRef = s.schemaName ? s.db + "." + s.schemaName : s.db;
 				const seq = ++openSeq.current;
 				setBusy("open");
 				Promise.all([
-					api("schema" + qs({ project: projectPath, connId: s.connId, database: s.db, table: s.table.name })),
-					api("preview" + qs({ project: projectPath, connId: s.connId, database: s.db, table: s.table.name, limit: PAGE_SIZE, offset: ((pg || 1) - 1) * PAGE_SIZE })),
+					api("schema" + qs({ project: projectPath, connId: s.connId, database: dbRef, table: s.table.name })),
+					api("preview" + qs({ project: projectPath, connId: s.connId, database: dbRef, table: s.table.name, limit: PAGE_SIZE, offset: ((pg || 1) - 1) * PAGE_SIZE })),
 				])
 					.then(([sch, prev]) => {
 						if (seq !== openSeq.current) return; // 旧请求晚到，丢弃
@@ -795,19 +813,43 @@ window.__ModuleLoader__.load({
 				if (!list) continue;
 				if (list.length === 0) { treeRows.push(treerow(ck + ":e", 1, false, true, t("noDatabases"))); continue; }
 				for (const d of list) {
+					const useSchemas = !!HAS_SCHEMAS[c.kind];
 					const dk = "d:" + c.id + "/" + d;
 					const dOpen = !!open[dk];
 					treeRows.push(treerow(dk, 1, dOpen, false, d, () => toggleDb(c, d)));
 					if (!dOpen) continue;
-					const tkey = c.id + "/" + d;
-					const tlist = tablesMap[tkey];
 					if (loading[dk]) { treeRows.push(treerow(dk + ":l", 2, false, true, "…")); continue; }
 					if (error[dk]) { treeRows.push(treerow(dk + ":x", 2, false, true, t("loadFailed") + "：" + error[dk], () => retry(dk, () => toggleDb(c, d)))); continue; }
+					// PG/GaussDB：库 → 模式 → 表（三层，Navicat 官方层级）；schema 节点复用 open/loading/error 状态
+					if (useSchemas) {
+						const slist = schemasMap[c.id + "/" + d];
+						if (!slist) continue;
+						if (slist.length === 0) { treeRows.push(treerow(dk + ":e", 2, false, true, t("noSchemas"))); continue; }
+						for (const s of slist) {
+							const sk = "s:" + c.id + "/" + d + "/" + s;
+							const sOpen = !!open[sk];
+							treeRows.push(treerow(sk, 2, sOpen, false, s, () => toggleSchema(c, d, s)));
+							if (!sOpen) continue;
+							const tlist = tablesMap[c.id + "/" + d + "/" + s];
+							if (loading[sk]) { treeRows.push(treerow(sk + ":l", 3, false, true, "…")); continue; }
+							if (error[sk]) { treeRows.push(treerow(sk + ":x", 3, false, true, t("loadFailed") + "：" + error[sk], () => retry(sk, () => toggleSchema(c, d, s)))); continue; }
+							if (!tlist) continue;
+							if (tlist.length === 0) { treeRows.push(treerow(sk + ":e", 3, false, true, t("noTables"))); continue; }
+							for (const tb of tlist) {
+								const active = !!sel && sel.connId === c.id && sel.db === d && sel.schemaName === s && sel.table.name === tb.name;
+								treeRows.push(treerow("t:" + sk + "/" + tb.name, 3, false, true,
+									tb.name + (tb.type && tb.type !== "table" ? " · " + tb.type : ""),
+									() => setSel({ connId: c.id, db: d, schemaName: s, table: tb }), active));
+							}
+						}
+						continue;
+					}
+					const tlist = tablesMap[c.id + "/" + d];
 					if (!tlist) continue;
 					if (tlist.length === 0) { treeRows.push(treerow(dk + ":e", 2, false, true, t("noTables"))); continue; }
 					for (const tb of tlist) {
 						const active = !!sel && sel.connId === c.id && sel.db === d && sel.table.name === tb.name;
-						treeRows.push(treerow("t:" + tkey + "/" + tb.name, 2, false, true,
+						treeRows.push(treerow("t:" + c.id + "/" + d + "/" + tb.name, 2, false, true,
 							tb.name + (tb.type && tb.type !== "table" ? " · " + tb.type : ""),
 							() => setSel({ connId: c.id, db: d, table: tb }), active));
 					}
@@ -832,7 +874,7 @@ window.__ModuleLoader__.load({
 							["structure", "preview"].map((v) =>
 								React.createElement("button", { key: v, className: view === v ? "active" : "", onClick: () => setView(v) }, v === "structure" ? t("structure") : t("preview"))),
 						),
-						React.createElement("strong", null, (view === "structure" ? t("structure") : t("preview")) + " · " + sel.db + " / " + sel.table.name),
+						React.createElement("strong", null, (view === "structure" ? t("structure") : t("preview")) + " · " + sel.db + (sel.schemaName ? "." + sel.schemaName : "") + " / " + sel.table.name),
 						view === "structure"
 							? resultTable(
 								[t("column"), t("dataType"), t("nullable"), t("keyCol"), t("defaultVal"), t("comment")],

package/dist/adapters/sql-shared/pg-like.js

@@ -28,25 +28,64 @@ function poolConfig(conn) {
 export async function createPgLikeAdapter(kind, Driver, conn, opts) {
     const pool = new Driver.Pool(poolConfig(conn));
     const readOnly = opts?.mode === 'ro';
-    if (readOnly) {
-        // 服务器级 ro 强制（官方手段）：每个新连接会话设为只读事务。
-        // fail-closed：SET 失败时 release(err) 让驱动销毁该连接、等待的 acquire 收到错误——
-        // 会话级只读是 ro 的最后防线，不允许静默降级成可写连接。
-        pool.on('connect', (c) => {
+    // 服务器级 ro 强制（官方手段）：每个新连接会话设为只读事务。
+    // fail-closed：SET 失败时 release(err) 让驱动销毁该连接、等待的 acquire 收到错误——
+    // 会话级只读是 ro 的最后防线，不允许静默降级成可写连接。
+    const setupReadOnly = (p) => {
+        p.on('connect', (c) => {
             void c.query('SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY').catch((err) => {
                 c.release(err instanceof Error ? err : new Error(String(err)));
             });
         });
         // pg 约定：release(err) 若无等待者会 emit pool 'error'，不监听会崩进程
-        pool.on('error', () => { });
-    }
+        p.on('error', () => { });
+    };
+    if (readOnly)
+        setupReadOnly(pool);
     // 事务激活期间所有 query/execute 路由到同一 client
     let txClient = null;
     const run = (sql, params) => txClient ? txClient.query(sql, params) : pool.query(sql, params);
+    // 跨库浏览（Navicat 行为）：树列出服务器上所有库，展开非连接库时用同一凭据开指向该库的池。
+    // 池按库缓存复用；ro 模式下新池同样套会话只读。连接自身的库（fields.database 或 url 库名）直接复用主池。
+    const dbPools = new Map();
+    const mainDb = () => {
+        if (conn.fields)
+            return conn.fields.database ? String(conn.fields.database) : null;
+        if (!conn.url)
+            return null;
+        try {
+            return decodeURIComponent(new URL(conn.url).pathname.replace(/^\//, '')) || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    const poolFor = (db) => {
+        if (!db || db === mainDb())
+            return pool;
+        const cached = dbPools.get(db);
+        if (cached)
+            return cached;
+        const created = new Driver.Pool({ ...poolConfig(conn), database: db });
+        if (readOnly)
+            setupReadOnly(created);
+        dbPools.set(db, created);
+        return created;
+    };
     const defaultSchema = () => {
         const f = conn.fields;
         return f && typeof f.schema === 'string' && f.schema ? f.schema : 'public';
     };
+    /** 浏览目标解析："db.schema"（跨库）| "schema"（当前库）| 空（当前库默认 schema）。
+     *  PG 标识符不允许裸点，按第一个点切分安全；多余点由 assertIdent 拒绝。 */
+    const parseBrowseTarget = (ref, what) => {
+        if (!ref)
+            return { db: null, schema: defaultSchema() };
+        const i = ref.indexOf('.');
+        if (i < 0)
+            return { db: null, schema: assertIdent(ref, what) };
+        return { db: assertIdent(ref.slice(0, i), '数据库'), schema: assertIdent(ref.slice(i + 1), what) };
+    };
     function toQueryResult(res) {
         let columns = (res.fields ?? []).map((f) => f.name);
         if (columns.length === 0 && res.rows.length > 0) {
@@ -116,30 +155,41 @@ export async function createPgLikeAdapter(kind, Driver, conn, opts) {
             const res = await pool.query('SELECT datname FROM pg_database WHERE datistemplate = false AND datallowconn = true ORDER BY datname');
             return res.rows.map((r) => String(r.datname));
         }),
+        // 库内 schema 清单（Navicat 官方层级：数据库 → 模式 → 表）。
+        // database 参数 = 库名（UI 树第一层）；pg_* 前缀覆盖 pg_catalog/pg_toast/pg_temp 系。
+        listSchemas: (database) => humanize(`${kind} 列出模式`, async () => {
+            const p = poolFor(database ? assertIdent(database, '数据库') : null);
+            const res = await p.query(`SELECT nspname FROM pg_catalog.pg_namespace
+           WHERE nspname NOT LIKE 'pg\\_%' AND nspname <> 'information_schema'
+           ORDER BY nspname`);
+            return res.rows.map((r) => String(r.nspname));
+        }),
+        // database 参数 = "库名.schema"（跨库浏览）或 "schema"（当前库）
         listTables: (database) => humanize(`${kind} 列出表`, async () => {
-            const schema = database ? assertIdent(database, 'schema') : defaultSchema();
-            const res = await pool.query(`SELECT table_name, table_type FROM information_schema.tables
+            const { db, schema } = parseBrowseTarget(database, 'schema');
+            const res = await poolFor(db).query(`SELECT table_name, table_type FROM information_schema.tables
            WHERE table_schema = $1 ORDER BY table_name`, [schema]);
             return res.rows.map((r) => {
                 const rawType = String(r.table_type);
                 return {
                     name: String(r.table_name),
                     type: rawType === 'BASE TABLE' ? 'TABLE' : rawType,
-                    database: schema,
+                    database: db ? `${db}.${schema}` : schema,
                 };
             });
         }),
         describeTable: (table, database) => humanize(`${kind} 查看表结构`, async () => {
-            const schema = database ? assertIdent(database, 'schema') : defaultSchema();
+            const { db, schema } = parseBrowseTarget(database, 'schema');
             const tbl = assertIdent(table, '表名');
-            const res = await pool.query(`SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, c.character_maximum_length,
+            const p = poolFor(db);
+            const res = await p.query(`SELECT c.column_name, c.data_type, c.is_nullable, c.column_default, c.character_maximum_length,
                   col_description((quote_ident($1) || '.' || quote_ident($2))::regclass, c.ordinal_position) AS col_comment
            FROM information_schema.columns c
            WHERE c.table_schema = $1 AND c.table_name = $2
            ORDER BY c.ordinal_position`, [schema, tbl]);
             if (res.rows.length === 0)
-                throw new Error(`表不存在: ${schema}.${tbl}`);
-            const pks = await pool.query(`SELECT kcu.column_name FROM information_schema.table_constraints tc
+                throw new Error(`表不存在: ${db ? db + '.' : ''}${schema}.${tbl}`);
+            const pks = await p.query(`SELECT kcu.column_name FROM information_schema.table_constraints tc
            JOIN information_schema.key_column_usage kcu
              ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
            WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = $1 AND tc.table_name = $2`, [schema, tbl]);
@@ -158,13 +208,17 @@ export async function createPgLikeAdapter(kind, Driver, conn, opts) {
             });
         }),
         previewRows: (table, limit, database, offset) => humanize(`${kind} 预览行`, async () => {
-            const schema = database ? assertIdent(database, 'schema') : defaultSchema();
+            const { db, schema } = parseBrowseTarget(database, 'schema');
             const tbl = assertIdent(table, '表名');
             const lim = clampLimit(limit);
             const off = clampOffset(offset);
-            const res = await run(`SELECT * FROM ${quoteIdent(schema)}.${quoteIdent(tbl)} LIMIT $1 OFFSET $2`, [lim, off]);
+            const sql = `SELECT * FROM ${quoteIdent(schema)}.${quoteIdent(tbl)} LIMIT $1 OFFSET $2`;
+            // 当前库保持事务路由（run）；跨库必须用该库自己的池
+            const res = db ? await poolFor(db).query(sql, [lim, off]) : await run(sql, [lim, off]);
             return toQueryResult(res);
         }),
-        close: () => humanize(`${kind} 关闭连接`, () => pool.end()),
+        close: () => humanize(`${kind} 关闭连接`, async () => {
+            await Promise.all([pool.end(), ...[...dbPools.values()].map((p) => p.end())]);
+        }),
     };
 }

package/dist/http/index.js

@@ -210,6 +210,9 @@ async function route(req, res, service, path, q, opts) {
     if (path === '/api/tables' && req.method === 'GET') {
         return sendOk(res, await service.tables(projectOf(q), required(q, 'connId'), q.get('database') ?? undefined));
     }
+    if (path === '/api/schemas' && req.method === 'GET') {
+        return sendOk(res, await service.schemas(projectOf(q), required(q, 'connId'), q.get('database') ?? undefined));
+    }
     if (path === '/api/schema' && req.method === 'GET') {
         return sendOk(res, await service.schema(projectOf(q), required(q, 'connId'), required(q, 'table'), q.get('database') ?? undefined));
     }

package/dist/manager.js

@@ -146,6 +146,21 @@ export class DbToolService {
             throw this.toDriverError(e);
         }
     }
+    /** 库内 schema 清单（仅 PG/GaussDB 等三层语义适配器实现；ro 即可）。 */
+    async schemas(projectPath, connId, database) {
+        const { key, adapter } = await this.authorize(projectPath, connId, false);
+        if (!adapter.listSchemas)
+            return [];
+        try {
+            const result = await adapter.listSchemas(database);
+            this.audit(key, connId, 'schemas', database ?? 'default', 'none', false, true);
+            return result;
+        }
+        catch (e) {
+            this.audit(key, connId, 'schemas', database ?? 'default', 'none', false, false, this.errText(e));
+            throw this.toDriverError(e);
+        }
+    }
     async schema(projectPath, connId, table, database) {
         const t = assertNonEmpty(table, 'table');
         const { key, adapter } = await this.authorize(projectPath, connId, false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-db-tool",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "DSH community plugin: chat-operated multi-database admin tool with sidebar management, project-scoped grants, ro/rw modes and dangerous-operation confirmation",
   "type": "module",
   "license": "MIT",

package/skills/db-admin/SKILL.md

@@ -57,6 +57,7 @@ DatabaseManager({ action: "schema", conn_id: "c1", database: "shop", table: "use
 ```
 
 - 表列表返回 `TableInfo[]`：`{name, type?, comment?, database?}`（Redis 的 type 为 hash|list|set|zset|string|stream）。
+- PostgreSQL/GaussDB 为「数据库 → 模式(schema) → 表」三层语义，支持跨库浏览（Navicat 行为）：`database` 参数传 `"库名.schema"` 即可浏览连接库之外的库（如 `gycwd.public`，服务端自动用同一凭据开指向该库的连接）；只传 schema 名（如 `public`）则查连接自身库。`listSchemas(database)` 的参数是**纯库名**。不确定 schema 时先执行 `SELECT nspname FROM pg_catalog.pg_namespace WHERE nspname NOT LIKE 'pg\_%' AND nspname <> 'information_schema'`。
 - 列结构返回 `ColumnInfo[]`：`{name, dataType, nullable, key?, default?, comment?}`。
 
 ### 5. preview — 预览表数据