dsh-db-tool 1.7.2 → 1.8.1

package/dist/adapters/mysql/index.js

@@ -6,7 +6,7 @@
  * TRANSACTION READ ONLY）+ query 首词只读白名单双保险；服务层拦截 execute。
  */
 import mysql from 'mysql2/promise';
-import { assertIdent, clampLimit, clampOffset, humanize, normalizeCell, quoteIdent } from '../sql-shared/common.js';
+import { assertIdent, clampLimit, clampOffset, humanize, normalizeCell, quoteIdent, validPort } from '../sql-shared/common.js';
 /** ro 模式下 query 允许的读语句首词白名单 */
 const RO_READ_PREFIX = /^(select|show|desc|describe|explain|use|help|table)\b/i;
 /**
@@ -43,7 +43,8 @@ function connOptions(conn) {
     if (conn.url) {
         const u = new URL(conn.url);
         base.host = u.hostname;
-        base.port = Number(u.port) || 3306;
+        // 端口段校验：':0' 等非法值抛中文错误，不再被 Number()|| 静默改写 3306
+        base.port = u.port ? validPort(u.port, 3306, 'mysql') : 3306;
         try {
             if (u.username)
                 base.user = decodeURIComponent(u.username);
@@ -63,7 +64,8 @@ function connOptions(conn) {
     else if (conn.fields) {
         const f = conn.fields;
         base.host = String(f.host ?? '127.0.0.1');
-        base.port = Number(f.port ?? 3306);
+        // 前端原样发字符串端口：显式校验，NaN/0 等不再被驱动 `|| 3306` 静默改写后连错服务
+        base.port = validPort(f.port, 3306, 'mysql');
         base.user = String(f.user ?? f.username ?? 'root');
         if (f.password != null)
             base.password = String(f.password);
@@ -78,16 +80,46 @@ function connOptions(conn) {
     return base;
 }
 export async function createMysqlAdapter(conn, opts) {
-    const pool = mysql.createPool(connOptions(conn));
+    const baseOpts = connOptions(conn);
+    const pool = mysql.createPool(baseOpts);
     const readOnly = opts?.mode === 'ro';
-    if (readOnly) {
-        // 服务器级 ro 强制：每个新底层连接自动设为只读会话（应用层另有 query 白名单双保险）。
-        // 回调收到的是 callback 版 PoolConnection，query() 返回 Query 命令对象（EventEmitter）：
-        // 吞掉 SET 失败防 uncaughtException（见 swallowSetError）。
-        pool.on('connection', (c) => {
+    // 跨库（Navicat 式）：按库名缓存独立池。mysql2 官方多库方案即多池管理——池上
+    // changeUser/USE 只影响被调用的那条池内连接，池保持建池配置，切库不可靠。
+    const mainDb = typeof baseOpts.database === 'string' ? baseOpts.database : '';
+    const dbPools = new Map();
+    /**
+     * 关闭幂等标志（对齐 pg-like/sqlserver）：关闭后一切访问必须被拦下——
+     * 否则跨库访问会新建池（关不掉的连接泄漏），主池请求则报英文驱动错。
+     */
+    let closed = false;
+    const assertOpen = () => {
+        if (closed)
+            throw new Error('mysql 连接已关闭：请重新连接后重试');
+    };
+    /** ro 模式：每个新底层连接自动设为只读会话（应用层另有 query 白名单双保险）。
+     *  回调收到的是 callback 版 PoolConnection，query() 返回 Query 命令对象（EventEmitter）：
+     *  吞掉 SET 失败防 uncaughtException（见 swallowSetError）。主池与跨库池共用同一注册。 */
+    const attachReadOnly = (p) => {
+        if (!readOnly)
+            return;
+        p.on('connection', (c) => {
             swallowSetError(c.query('SET SESSION TRANSACTION READ ONLY'));
         });
-    }
+    };
+    attachReadOnly(pool);
+    const poolFor = (db) => {
+        assertOpen();
+        if (db === mainDb)
+            return pool;
+        let p = dbPools.get(db);
+        if (!p) {
+            // connOptions 已把 URL/fields 拆成纯字段，覆盖 database 即建出目标库的池
+            p = mysql.createPool({ ...baseOpts, database: db });
+            dbPools.set(db, p);
+            attachReadOnly(p);
+        }
+        return p;
+    };
     /** 事务激活期间路由到同一连接，保证 BEGIN/COMMIT 生效 */
     let txConn = null;
     // PoolConnection 与 Pool 的联合会让 mysql2 的 query/execute 重载解析失败，收窄为 Pool 视图
@@ -160,18 +192,23 @@ export async function createMysqlAdapter(conn, opts) {
             const [rows] = await pool.query('SELECT VERSION() AS v');
             return { ok: true, serverInfo: `MySQL ${String(rows[0]?.v ?? '')}` };
         }),
-        query: (sql, params) => humanize('mysql 查询失败', async () => {
+        query: (sql, params, database) => humanize('mysql 查询失败', async () => {
             if (readOnly && !RO_READ_PREFIX.test(sql.trimStart())) {
                 throw new Error('DRIVER_ERROR: 只读(ro)模式下 query 仅允许读语句（select/show/desc/describe/explain/use/help/table），写操作请使用可写连接');
             }
-            const [rows, fields] = await runner().query(sql, params ?? []);
+            // 跨库请求路由到该库自己的池（白名单校验在前，拒绝发生在建池之前；
+            // 缺省判断用 != null：空串等非法值必须进 assertIdent 被拒，不能落回主池）；
+            // 无 database 时维持事务粘主池语义（服务层已拒绝事务携带 database）
+            const target = database != null ? poolFor(assertIdent(database, '库名')) : runner();
+            const [rows, fields] = await target.query(sql, params ?? []);
             if (!Array.isArray(rows))
                 return { columns: [], rows: [], rowCount: 0 };
             return toQueryResult(rows, fields);
         }),
-        execute: (statement, params) => humanize('mysql 执行失败', async () => {
+        execute: (statement, params, database) => humanize('mysql 执行失败', async () => {
             // mysql2 的 ExecuteValues 不接受 unknown[]，此处值均为绑定参数（string|number|null）
-            const [result] = await runner().execute(statement, (params ?? []));
+            const target = database != null ? poolFor(assertIdent(database, '库名')) : runner();
+            const [result] = await target.execute(statement, (params ?? []));
             const header = (Array.isArray(result) ? result[0] : result);
             const n = header?.affectedRows;
             return {
@@ -231,7 +268,12 @@ export async function createMysqlAdapter(conn, opts) {
                 return { columns: [], rows: [], rowCount: 0 };
             return toQueryResult(rows, fields);
         }),
-        close: () => humanize('mysql 关闭连接', () => pool.end()),
+        close: () => humanize('mysql 关闭连接', async () => {
+            if (closed)
+                return; // 幂等：重复 close 为 no-op（pg-pool 二次 end() 会抛的教训）
+            closed = true;
+            await Promise.all([pool.end(), ...[...dbPools.values()].map((p) => p.end())]);
+        }),
     };
 }
 export const factory = (conn) => createMysqlAdapter(conn);

package/dist/adapters/oracle/index.js

@@ -18,6 +18,7 @@
  */
 import oracledb from 'oracledb';
 import { sqlHead, SQL_READ_HEADS } from '../../guard/index.js';
+import { validPort } from '../sql-shared/common.js';
 // CLOB 统一按字符串返回；BLOB 统一按 Buffer 返回。均为官方全局按类型转换
 // （fetchInfo 的键是列名而非类型名，`{ BLOB: … }` 只会匹配恰好名为 "BLOB" 的列，
 // 按类型统一转换须用全局 fetchAsString/fetchAsBuffer——官方 connection.rst
@@ -111,12 +112,15 @@ export function resolveOracleConn(conn) {
         return {
             user,
             password: decodeURIComponent(u.password),
-            connectString: `${u.hostname}:${u.port || 1521}/${service}`,
+            // 端口段校验：':0' 等非法值抛中文错误，不再 host:0 直传驱动
+            connectString: `${u.hostname}:${u.port ? validPort(u.port, 1521, 'oracle') : 1521}/${service}`,
         };
     }
     const f = conn.fields ?? {};
     const host = typeof f.host === 'string' ? f.host : '';
-    const port = typeof f.port === 'number' ? f.port : 1521;
+    // 前端原样发字符串端口：显式校验；历史 typeof==='number' 门把一切字符串（含合法 '14330'）
+    // 静默丢弃回退 1521
+    const port = validPort(f.port, 1521, 'oracle');
     const service = typeof f.service === 'string' ? f.service : typeof f.database === 'string' ? f.database : '';
     if (host === '' || service === '') {
         throw new Error('Oracle 连接需要 url（oracle://user:pass@host:1521/SERVICE）或 fields（host/port/service）');

package/dist/adapters/redis/index.js

@@ -10,6 +10,7 @@
  *  - 只读账号建议由用户在服务端配置 ACL 只读用户（见 README/文档）。
  */
 import { createClient } from 'redis';
+import { validPort } from '../sql-shared/common.js';
 /** 危险命令：服务层拦截器在用户确认前拒绝执行（KEYS 同时被 query 白名单禁用）。对齐官方 ACL dangerous 类。 */
 export const DANGEROUS_COMMANDS = new Set([
     'FLUSHALL', 'FLUSHDB', 'SWAPDB', 'CONFIG', 'DEBUG', 'SAVE', 'SHUTDOWN',
@@ -111,9 +112,11 @@ function parseInfo(raw) {
     return rows;
 }
 /** 从 fields 拼接连接 URL（url 缺省时） */
-function buildUrl(fields, ssl) {
+export function buildUrl(fields, ssl) {
     const host = typeof fields?.host === 'string' && fields.host !== '' ? fields.host : '127.0.0.1';
-    const port = typeof fields?.port === 'number' ? fields.port : 6379;
+    // 前端原样发字符串端口：显式校验；历史 typeof==='number' 门把一切字符串（含合法 '14330'）
+    // 静默丢弃回退 6379，属静默错连
+    const port = validPort(fields?.port, 6379, 'redis');
     const user = typeof fields?.user === 'string' && fields.user !== '' ? encodeURIComponent(fields.user) : '';
     const pass = typeof fields?.password === 'string' ? `:${encodeURIComponent(fields.password)}@` : '';
     const db = typeof fields?.database === 'number' && fields.database !== 0 ? `/${fields.database}` : '';

package/dist/adapters/sql-shared/common.js

@@ -27,6 +27,21 @@ export function clampOffset(offset) {
     const n = Math.floor(Number(offset ?? 0));
     return Number.isFinite(n) && n > 0 ? n : 0;
 }
+/**
+ * 端口校验（fail-closed，sqlserver validPort 同口径，各适配器 fields/URL 两路径共用）：
+ * 仅「未提供」（undefined/null/''，表单留空的官方语义）回退该库默认端口；提供了但
+ * Number() 后不是 1-65535 的整数则抛中文错误——绝不静默改写用户配置（各驱动普遍对
+ * falsy 端口 `|| 默认` 静默回退、对非整数静默截断，连错服务/端口后排障会被误导）。
+ */
+export function validPort(v, dflt, label) {
+    if (v === undefined || v === null || v === '')
+        return dflt;
+    const n = Number(v);
+    if (!Number.isInteger(n) || n <= 0 || n > 65535) {
+        throw new Error(`${label} 连接的端口取值非法：${JSON.stringify(v)}（须为 1-65535 的整数；留空才使用默认端口 ${dflt}）`);
+    }
+    return n;
+}
 /** 任意单元格 → NormalizedCell（string | number | null） */
 export function normalizeCell(v) {
     if (v === null || v === undefined)
@@ -44,8 +59,9 @@ export function normalizeCell(v) {
             ? Number(b)
             : b.toString();
     }
+    // Invalid Date（如驱动返回无法解析的日期）不能抛 RangeError：单格异常会放大成整查询失败
     if (v instanceof Date)
-        return v.toISOString();
+        return Number.isNaN(v.getTime()) ? String(v) : v.toISOString();
     if (v instanceof Uint8Array)
         return `[BLOB ${v.byteLength} bytes]`;
     let s;

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

@@ -1,4 +1,4 @@
-import { assertIdent, clampLimit, clampOffset, humanize, normalizeCell, quoteIdent } from './common.js';
+import { assertIdent, clampLimit, clampOffset, humanize, normalizeCell, quoteIdent, validPort } from './common.js';
 /** 多主机 authority 逐台重组段（host[:port]） */
 function joinHostSeg(h) {
     return `${h.host}${h.port != null ? ':' + h.port : ''}`;
@@ -20,7 +20,9 @@ function poolConfig(conn, overrideUrl, max = 10) {
         // devg-dist/gaussdb-12-0319）、默认管理用户 gaussdb；postgresql 维持社区默认 5432/postgres 不变。
         const gb = conn.meta.kind === 'gaussdb';
         base.host = String(f.host ?? '127.0.0.1');
-        base.port = Number(f.port ?? (gb ? 8000 : 5432));
+        // 前端原样发字符串端口：显式校验，NaN/'' 经 Number() 变 0 后会被驱动 truthy 检查
+        // 静默回退 defaults 5432（连 gaussdb 想兜底的 8000 都落不到）、小数被 parseInt 截断
+        base.port = validPort(f.port, gb ? 8000 : 5432, conn.meta.kind);
         base.user = String(f.user ?? f.username ?? (gb ? 'gaussdb' : 'postgres'));
         if (f.password != null)
             base.password = String(f.password);
@@ -42,7 +44,7 @@ function poolConfig(conn, overrideUrl, max = 10) {
  * authority（host:port,host:port）端口段含逗号非数字 → new URL 直接抛 Invalid URL。
  * 故自行按文本解析 authority，不经 WHATWG 解析。
  */
-export function normalizeUrl(url) {
+export function normalizeUrl(url, label = 'postgres') {
     const stripped = url.replace(/^jdbc:/i, '');
     const schemeEnd = stripped.indexOf('://');
     // 无 authority（非 URL 形态）：整串原样保留，交由驱动按既有逻辑处理
@@ -60,8 +62,14 @@ export function normalizeUrl(url) {
         const ci = seg.lastIndexOf(':');
         if (ci < 0)
             return { host: seg };
-        const port = Number.parseInt(seg.slice(ci + 1), 10);
-        return Number.isFinite(port) ? { host: seg.slice(0, ci), port } : { host: seg };
+        const host = seg.slice(0, ci);
+        const rawPort = seg.slice(ci + 1);
+        // 空端口段视同未提供（驱动按默认端口探测）；非空则必须为 1-65535 整数——历史 parseInt
+        // 会静默截断 '1433.5'→1433、NaN 时把整段当主机名，均属静默改写端口。dflt 传 0 仅占位：
+        // rawPort 非空不会走到回退分支。
+        if (rawPort === '')
+            return { host };
+        return { host, port: validPort(rawPort, 0, label) };
     });
     const prefix = `${stripped.slice(0, schemeEnd)}://${userinfo}`;
     // 单台不设 hosts（调用方只在多台时探测）
@@ -118,7 +126,7 @@ export async function pickHost(driver, base, hosts, masterOnly) {
  * 返回最终驱动池配置与最终连接 URL。
  */
 export async function pgLikePoolCfg(kind, driver, conn, max) {
-    const norm = conn.url ? normalizeUrl(conn.url) : null;
+    const norm = conn.url ? normalizeUrl(conn.url, kind) : null;
     const cleanUrl = norm ? norm.prefix + (norm.hosts ?? []).map(joinHostSeg).join(',') + norm.suffix : undefined;
     let finalUrl = cleanUrl;
     if (norm?.hosts && norm.hosts.length > 1) {