@zz1996/dbhub-dameng 0.1.7 → 1.2.5-dameng.621

package/README.md

@@ -1,183 +1,172 @@
-> [!NOTE]  
-> Brought to you by [Bytebase](https://www.bytebase.com/), open-source database DevSecOps platform.
-
-> [!NOTE]
-> This package is a local Dameng/DM8 connector fork of Bytebase DBHub. Use
-> `npx -y @zz1996/dbhub-dameng --transport stdio --config ./dbhub.dameng.toml`
-> for Dameng MCP usage.
->
-> Dameng DSN format: `dameng://user:password@host:5236/schema`. Prefer a
-> least-privilege read-only Dameng account for production or shared databases,
-> even when the `execute_sql` tool is configured with `readonly = true`.
-
-<p align="center">
-<a href="https://dbhub.ai/" target="_blank">
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-dark.svg" width="75%">
-  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-light.svg" width="75%">
-  <img src="https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/logo/full-light.svg" width="75%" alt="DBHub Logo">
-</picture>
-</a>
-</p>
-
-```bash
-            +------------------+    +--------------+    +------------------+
-            |                  |    |              |    |                  |
-            |                  |    |              |    |                  |
-            |  Claude Desktop  +--->+              +--->+    PostgreSQL    |
-            |                  |    |              |    |                  |
-            |  Claude Code     +--->+              +--->+    SQL Server    |
-            |                  |    |              |    |                  |
-            |  Cursor          +--->+    DBHub     +--->+    SQLite        |
-            |                  |    |              |    |                  |
-            |  VS Code         +--->+              +--->+    MySQL         |
-            |                  |    |              |    |                  |
-            |  Copilot CLI     +--->+              +--->+    MariaDB       |
-            |                  |    |              |    |                  |
-            |                  +--->+              +--->+    Dameng / DM8  |
-            |                  |    |              |    |                  |
-            +------------------+    +--------------+    +------------------+
-                 MCP Clients           MCP Server             Databases
+# DBHub Dameng
+
+让 AI 直接连接达梦 DM8，查询数据、查看表结构和字段说明。
+基于 [Bytebase DBHub](https://github.com/bytebase/dbhub)，增加最小达梦适配。
+使用已发布的 npm 包即可，无需克隆仓库或编译源码。
+
+默认只有两个 MCP 工具：
+
+| 工具 | 用途 |
+| --- | --- |
+| `search_objects` | 查找 schema、表、视图、字段、索引和存储过程 |
+| `execute_sql` | 执行 SQL；按下方配置只允许读取，最多返回 100 行 |
+
+## 最简单：把这份 README 和连接串交给 AI
+
+在能够读写本机项目文件的 AI 编程客户端中，发送下面这段话。
+将最后一行替换为自己的连接串；也可以提供已有本地连接配置文件的路径。
+
+```text
+请根据以下 README，直接帮我在当前项目配置 DBHub 达梦 MCP，并验证连接：
+https://github.com/zuozh11/dbhub-dameng/blob/main/README.md
+
+要求：
+1. 检查 Node.js >= 22.5，以及 npm/npx 是否可用。
+2. 使用 @zz1996/dbhub-dameng@latest，以 stdio 启动。
+3. 创建本机专用的 .agents/dbhub.dameng.toml，开启 readonly = true、max_rows = 100，
+   只启用 execute_sql 和 search_objects。不要执行初始化脚本。
+4. 将含真实连接串的文件排除出 Git；如果同名文件已被跟踪，改用仓库外的本地文件。
+   不要把密码写进 README、提交记录或最终回复。
+5. 检查当前客户端已有的 MCP 配置，只新增或更新 DBHub 条目，保留其他配置。
+   --config 使用配置文件的绝对路径。能识别客户端就直接配置，无法识别时再问我。
+6. 重连 MCP，确认两个工具可用，执行 SELECT 1 AS OK FROM DUAL，
+   再用 search_objects 查询当前 schema 下的一个表名；不要读取业务数据或执行写操作。
+   如果无法控制客户端重连，请明确告诉我需要在哪一步重连，不要把文件写好当成连接成功。
+7. 完成后说明配置文件位置、验证结果，以及是否还需要我重启客户端。
+
+我的数据库连接串：dameng://user:password@host:5236/APP
 ```
 
-DBHub is a zero-dependency, token efficient MCP server implementing the Model Context Protocol (MCP) server interface. This lightweight gateway allows MCP-compatible clients to connect to and explore different databases:
+如果只使用普通聊天网页，AI 可以生成配置，但需要你自己保存到本机并在 MCP 客户端中启用。
+真实连接信息仅提供给你信任的客户端；共享或生产库请使用最小权限只读账号。
 
-- **Local Development First**: Zero dependency, token efficient with just two MCP tools to maximize context window
-- **Multi-Database**: PostgreSQL, MySQL, MariaDB, SQL Server, SQLite, and Dameng/DM8 through a single interface
-- **Multi-Connection**: Connect to multiple databases simultaneously with TOML configuration
-- **Guardrails**: Read-only mode, row limiting, and query timeout to prevent runaway operations
-- **Secure Access**: SSH tunneling and SSL/TLS encryption
+## 连接串怎么写
 
-## Supported Databases
-
-PostgreSQL, MySQL, SQL Server, MariaDB, SQLite, and Dameng/DM8.
-
-## MCP Tools
-
-DBHub implements MCP tools for database operations:
-
-- **[execute_sql](https://dbhub.ai/tools/execute-sql)**: Execute SQL queries with transaction support and safety controls
-- **[search_objects](https://dbhub.ai/tools/search-objects)**: Search and explore database schemas, tables, columns, indexes, and procedures with progressive disclosure
-- **[Custom Tools](https://dbhub.ai/tools/custom-tools)**: Define reusable, parameterized SQL operations in your `dbhub.toml` configuration file
-
-## Workbench
-
-DBHub includes a [built-in web interface](https://dbhub.ai/workbench/overview) for interacting with your database tools. It provides a visual way to execute queries, run custom tools, and view request traces without requiring an MCP client.
-
-![workbench](https://raw.githubusercontent.com/bytebase/dbhub/main/docs/images/workbench/workbench.webp)
+```text
+dameng://用户名:密码@主机:5236/Schema名称
+```
 
-## Installation
+例如下面是虚构的配置：
 
-See the full [Installation Guide](https://dbhub.ai/installation) for detailed instructions.
+```text
+dameng://reader:example_password@127.0.0.1:5236/APP
+```
 
-### Quick Start
+- 默认端口为 `5236`。
+- 路径中的 `APP` 是 schema，不是数据库实例名；按数据库中的实际大小写填写。
+- 用户名、密码中的特殊字符要进行 URL 编码，例如 `@` → `%40`、`#` → `%23`、`/` → `%2F`。
+  已编码的连接串不要重复编码。
+- 启动 MCP 的电脑必须能够访问该地址；内网数据库可能需要先连接 VPN。
 
-**Docker:**
+## 手动配置
 
-```bash
-docker run --rm --init \
-   --name dbhub \
-   --publish 8080:8080 \
-   bytebase/dbhub \
-   --transport http \
-   --port 8080 \
-   --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
-```
+### 1. 准备 Node.js
 
-**NPM:** (requires Node.js >= 22.5.0)
+需要 Node.js **>= 22.5**，并能访问 npm registry：
 
-```bash
-npx @bytebase/dbhub@latest --transport http --port 8080 --dsn "postgres://user:password@localhost:5432/dbname?sslmode=disable"
+```sh
+node --version
+npm --version
+npx --version
 ```
 
-**Dameng / DM8 fork:**
-
-```bash
-npx -y @zz1996/dbhub-dameng --transport stdio --config ./dbhub.dameng.toml
-```
+### 2. 创建本机数据库配置
 
-Minimal Dameng TOML configuration:
+创建 `.agents/dbhub.dameng.toml`，替换下面的示例连接串：
 
 ```toml
 [[sources]]
-id = "dm8_readonly"
-description = "Dameng DM8 database for schema discovery and read-only SQL queries"
-dsn = "dameng://${DM8_USER}:${DM8_PASSWORD}@${DM8_HOST}:5236/${DM8_SCHEMA}"
-query_timeout = 30
-lazy = true
-
-[[tools]]
-name = "search_objects"
-source = "dm8_readonly"
+id = "default"
+dsn = "dameng://reader:example_password@127.0.0.1:5236/APP"
 
 [[tools]]
 name = "execute_sql"
-source = "dm8_readonly"
+source = "default"
 readonly = true
 max_rows = 100
+
+[[tools]]
+name = "search_objects"
+source = "default"
 ```
 
-To verify the local Dameng connector against a real DM8 instance without
-committing credentials, set `DAMENG_DSN` or point to a local TOML file:
+将 `/.agents/dbhub.dameng.toml` 加入项目的 `.gitignore`，确保该文件未被 Git 跟踪。
+已被跟踪的文件不会因加入 `.gitignore` 自动停止跟踪，此时请改用仓库外的本地配置文件。
 
-```bash
-DAMENG_DSN="dameng://user:password@host:5236/schema" pnpm verify:dameng
-pnpm verify:dameng -- --config ./dbhub.dameng.toml --source dm8_readonly
-```
+也可以使用 `dsn = "${DAMENG_DSN}"`，由客户端向 MCP 进程传入环境变量。
+不要假设从桌面打开的客户端会继承终端里临时 `export` 的变量。
 
-**Demo Mode:**
+### 3. 添加到 MCP 客户端
 
-```bash
-npx @bytebase/dbhub@latest --transport http --port 8080 --demo
-```
+以下示例中的 `/absolute/path/to/project/.agents/dbhub.dameng.toml`
+必须替换为上一步文件的**绝对路径**。已有配置请合并，不要覆盖整个文件。
+
+**使用 `mcpServers` JSON 格式的客户端：**
 
-**Restrict to loopback (recommended for production):**
+将下面条目合并到客户端的 MCP 配置中；不同客户端的配置文件位置由客户端决定。
 
-```bash
-npx @bytebase/dbhub@latest --transport http --host 127.0.0.1 --port 8080 --demo
+```json
+{
+  "mcpServers": {
+    "dbhub": {
+      "command": "npx",
+      "args": [
+        "--yes",
+        "@zz1996/dbhub-dameng@latest",
+        "--transport", "stdio",
+        "--config", "/absolute/path/to/project/.agents/dbhub.dameng.toml"
+      ]
+    }
+  }
+}
 ```
 
-> The HTTP transport defaults to `--host 0.0.0.0`, exposing DBHub on every network interface. For production, bind to `127.0.0.1` and front DBHub with a reverse proxy (nginx/Caddy) or firewall — DBHub does not authenticate HTTP clients.
->
-> The HTTP transport also has built-in DNS-rebinding protection: it only accepts requests whose `Host` is loopback, this machine's own hostname/IPs, or a name you allow via [`--allowed-hosts`](https://dbhub.ai/config/command-line#allowed-hosts). If a client behind a reverse proxy or custom DNS name gets a `403`, add that hostname with `--allowed-hosts`.
+**Codex：**
 
-See [Command-Line Options](https://dbhub.ai/config/command-line) for all available parameters.
+将下面内容合并到项目的 `.codex/config.toml`（项目需受信任），
+或用户级的 `~/.codex/config.toml`：
 
-### Multi-Database Setup
+```toml
+[mcp_servers.dbhub]
+command = "npx"
+args = ["--yes", "@zz1996/dbhub-dameng@latest", "--transport", "stdio", "--config", "/absolute/path/to/project/.agents/dbhub.dameng.toml"]
+```
 
-Connect to multiple databases simultaneously using TOML configuration files. Perfect for managing production, staging, and development databases from a single DBHub instance.
+配置位置和字段可参考 [Codex 官方 MCP 文档](https://developers.openai.com/zh-Hans/docs/extend/mcp)。
+Windows 上若客户端无法直接启动 `npx`，可将 `command` 改为 `npx.cmd`；
+TOML/JSON 中的 Windows 路径可以使用正斜杠，例如 `C:/projects/app/.agents/dbhub.dameng.toml`。
 
-See [Multi-Database Configuration](https://dbhub.ai/config/toml) for complete setup instructions.
+### 4. 重连并验证
 
-## Development
+在客户端重新连接 MCP，必要时重启客户端。第一次启动需要下载 npm 包。
+让 AI 执行：
 
-Requires Node.js >= 22.5.0 (DBHub uses the built-in `node:sqlite` module).
+```text
+请用 execute_sql 执行 SELECT 1 AS OK FROM DUAL，
+再用 search_objects 查看当前 schema 的一个表名（object_type=table、detail_level=names、limit=1）。
+```
 
-```bash
-# Install dependencies
-pnpm install
+看到 SQL 返回 `OK = 1`，且对象查询没有连接错误，即完成基本连通性验证。
+schema 中没有可见表时可以返回空列表。检索字段或索引时，应同时提供 `schema` 和 `table`。
 
-# Run in development mode
-pnpm dev
+终端排查启动问题时，也可以直接运行：
 
-# Build and run for production
-pnpm build && pnpm start --transport stdio --dsn "postgres://user:password@localhost:5432/dbname"
+```sh
+npx --yes @zz1996/dbhub-dameng@latest --transport stdio --config /absolute/path/to/project/.agents/dbhub.dameng.toml
 ```
 
-See [Testing](.claude/skills/testing/SKILL.md) and [Debug](https://dbhub.ai/config/debug).
+stdio 模式启动后等待 MCP 客户端请求是正常行为，这不是 SQL 交互终端；单纯启动不代表数据库查询已验证。
 
-## Contributors
+## 更新与边界
 
-<a href="https://github.com/bytebase/dbhub/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=bytebase/dbhub" />
-</a>
+- 使用 `@latest` 的配置在重新启动 MCP 时获取当前版本；已经运行的进程不会热更新。
+- 需要固定版本时，将 `@latest` 换成明确的 npm 版本号。
+- 只读模式不能替代数据库权限，尤其不能隔离数据库函数内部的副作用。
+- 达梦版覆盖普通 SQL 与元数据浏览；不支持包含内部分号的匿名 PL/SQL 块，
+  暂不提供达梦的 `explain_sql`、`health_check`。
 
-## Star History
+[npm 包](https://www.npmjs.com/package/@zz1996/dbhub-dameng) ·
+[开发与自动发布说明](https://github.com/zuozh11/dbhub-dameng/blob/main/DAMENG.md) ·
+[上游 DBHub](https://github.com/bytebase/dbhub)
 
-<a href="https://www.star-history.com/?repos=bytebase%2Fdbhub&type=date&legend=top-left">
- <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=bytebase/dbhub&type=date&legend=top-left" />
- </picture>
-</a>
+本项目沿用上游 MIT 许可证，详见 [LICENSE](https://github.com/zuozh11/dbhub-dameng/blob/main/LICENSE)。

package/dbhub.dameng.toml.example

@@ -1,20 +1,13 @@
-# Example DBHub configuration for the local Dameng/DM8 fork.
-# Do not commit real credentials. Prefer environment variables.
-
 [[sources]]
-id = "dm8_dev"
-description = "Dameng DM8 development database. Read-only access for agent schema discovery and SQL queries."
-dsn = "dameng://${DM8_USER}:${DM8_PASSWORD}@${DM8_HOST}:5236/${DM8_SCHEMA}"
-connection_timeout = 5
-query_timeout = 30
-lazy = true
+id = "default"
+dsn = "${DAMENG_DSN}"
 
 [[tools]]
 name = "execute_sql"
-source = "dm8_dev"
+source = "default"
 readonly = true
 max_rows = 100
 
 [[tools]]
 name = "search_objects"
-source = "dm8_dev"
+source = "default"

package/dist/{chunk-SQA2ISDE.js → chunk-2JL4KCP5.js}

@@ -91,7 +91,9 @@ var SafeURL = class {
           }
         });
       }
-      const atIndex = urlString.indexOf("@");
+      const pathStart = urlString.indexOf("/");
+      const authorityEnd = pathStart === -1 ? urlString.length : pathStart;
+      const atIndex = urlString.lastIndexOf("@", authorityEnd - 1);
       if (atIndex !== -1) {
         const auth = urlString.substring(0, atIndex);
         urlString = urlString.substring(atIndex + 1);
@@ -143,118 +145,6 @@ var SafeURL = class {
   }
 };
 
-// src/utils/dsn-obfuscate.ts
-function parseConnectionInfoFromDSN(dsn) {
-  if (!dsn) {
-    return null;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (typeof type === "undefined") {
-      return null;
-    }
-    if (type === "sqlite") {
-      const prefix = "sqlite:///";
-      if (dsn.length > prefix.length) {
-        const rawPath = dsn.substring(prefix.length);
-        const firstChar = rawPath[0];
-        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
-        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
-        return {
-          type,
-          database: isSpecialPath ? rawPath : "/" + rawPath
-        };
-      }
-      return { type };
-    }
-    const url = new SafeURL(dsn);
-    const info = { type };
-    if (url.hostname) {
-      info.host = url.hostname;
-    }
-    if (url.port) {
-      info.port = parseInt(url.port, 10);
-    }
-    if (url.pathname && url.pathname.length > 1) {
-      info.database = url.pathname.substring(1);
-    }
-    if (url.username) {
-      info.user = url.username;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function obfuscateDSNPassword(dsn) {
-  if (!dsn) {
-    return dsn;
-  }
-  try {
-    const type = getDatabaseTypeFromDSN(dsn);
-    if (type === "sqlite") {
-      return dsn;
-    }
-    const url = new SafeURL(dsn);
-    if (!url.password) {
-      return dsn;
-    }
-    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
-    const protocol = dsn.split(":")[0];
-    let result;
-    if (url.username) {
-      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
-    } else {
-      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
-    }
-    if (url.port) {
-      result += `:${url.port}`;
-    }
-    result += url.pathname;
-    if (url.searchParams.size > 0) {
-      const params = [];
-      url.forEachSearchParam((value, key) => {
-        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-      });
-      result += `?${params.join("&")}`;
-    }
-    return result;
-  } catch {
-    return dsn;
-  }
-}
-function getDatabaseTypeFromDSN(dsn) {
-  if (!dsn) {
-    return void 0;
-  }
-  const protocol = dsn.split(":")[0];
-  return protocolToConnectorType(protocol);
-}
-function protocolToConnectorType(protocol) {
-  const mapping = {
-    "postgres": "postgres",
-    "postgresql": "postgres",
-    "mysql": "mysql",
-    "mariadb": "mariadb",
-    "sqlserver": "sqlserver",
-    "sqlite": "sqlite",
-    "dameng": "dameng",
-    "dm": "dameng"
-  };
-  return mapping[protocol];
-}
-function getDefaultPortForType(type) {
-  const ports = {
-    "postgres": 5432,
-    "mysql": 3306,
-    "mariadb": 3306,
-    "sqlserver": 1433,
-    "sqlite": void 0,
-    "dameng": 5236
-  };
-  return ports[type];
-}
-
 // src/utils/sql-parser.ts
 var TokenType = { Plain: 0, Comment: 1, QuotedBlock: 2 };
 function plainToken(i) {
@@ -431,12 +321,12 @@ function scanTokenSQLServer(sql, i) {
   return scanSingleLineComment(sql, i) ?? scanMultiLineComment(sql, i) ?? scanSingleQuotedString(sql, i) ?? scanDoubleQuotedString(sql, i) ?? scanBracketQuotedIdentifier(sql, i) ?? plainToken(i);
 }
 var dialectScanners = {
+  dameng: scanTokenAnsi,
   postgres: scanTokenPostgres,
   mysql: scanTokenMySQL,
   mariadb: scanTokenMySQL,
   sqlite: scanTokenSQLite,
-  sqlserver: scanTokenSQLServer,
-  dameng: scanTokenAnsi
+  sqlserver: scanTokenSQLServer
 };
 function getScanner(dialect) {
   return dialect ? dialectScanners[dialect] ?? scanTokenAnsi : scanTokenAnsi;
@@ -466,6 +356,21 @@ function stripCommentsAndStrings(sql, dialect) {
   }
   return parts.join("");
 }
+function blankCommentsAndStrings(sql, dialect) {
+  const scanToken = getScanner(dialect);
+  let result = "";
+  let i = 0;
+  while (i < sql.length) {
+    const token = scanToken(sql, i);
+    if (token.type === TokenType.Plain) {
+      result += sql[i];
+    } else {
+      result += " ".repeat(token.end - i);
+    }
+    i = token.end;
+  }
+  return result;
+}
 function splitSQLStatements(sql, dialect) {
   const scanToken = getScanner(dialect);
   const statements = [];
@@ -494,10 +399,7 @@ function splitSQLStatements(sql, dialect) {
 export {
   ConnectorRegistry,
   SafeURL,
-  parseConnectionInfoFromDSN,
-  obfuscateDSNPassword,
-  getDatabaseTypeFromDSN,
-  getDefaultPortForType,
   stripCommentsAndStrings,
+  blankCommentsAndStrings,
   splitSQLStatements
 };

package/dist/chunk-3RJRH3CN.js

@@ -0,0 +1,121 @@
+import {
+  SafeURL
+} from "./chunk-2JL4KCP5.js";
+
+// src/utils/dsn-obfuscate.ts
+function parseConnectionInfoFromDSN(dsn) {
+  if (!dsn) {
+    return null;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (typeof type === "undefined") {
+      return null;
+    }
+    if (type === "sqlite") {
+      const prefix = "sqlite:///";
+      if (dsn.length > prefix.length) {
+        const rawPath = dsn.substring(prefix.length);
+        const firstChar = rawPath[0];
+        const isWindowsDrive = rawPath.length > 1 && rawPath[1] === ":";
+        const isSpecialPath = firstChar === ":" || firstChar === "." || firstChar === "~" || isWindowsDrive;
+        return {
+          type,
+          database: isSpecialPath ? rawPath : "/" + rawPath
+        };
+      }
+      return { type };
+    }
+    const url = new SafeURL(dsn);
+    const info = { type };
+    if (url.hostname) {
+      info.host = url.hostname;
+    }
+    if (url.port) {
+      info.port = parseInt(url.port, 10);
+    }
+    if (url.pathname && url.pathname.length > 1) {
+      info.database = url.pathname.substring(1);
+    }
+    if (url.username) {
+      info.user = url.username;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function obfuscateDSNPassword(dsn) {
+  if (!dsn) {
+    return dsn;
+  }
+  try {
+    const type = getDatabaseTypeFromDSN(dsn);
+    if (type === "sqlite") {
+      return dsn;
+    }
+    const url = new SafeURL(dsn);
+    if (!url.password) {
+      return dsn;
+    }
+    const obfuscatedPassword = "*".repeat(Math.min(url.password.length, 8));
+    const protocol = dsn.split(":")[0];
+    let result;
+    if (url.username) {
+      result = `${protocol}://${url.username}:${obfuscatedPassword}@${url.hostname}`;
+    } else {
+      result = `${protocol}://${obfuscatedPassword}@${url.hostname}`;
+    }
+    if (url.port) {
+      result += `:${url.port}`;
+    }
+    result += url.pathname;
+    if (url.searchParams.size > 0) {
+      const params = [];
+      url.forEachSearchParam((value, key) => {
+        params.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+      });
+      result += `?${params.join("&")}`;
+    }
+    return result;
+  } catch {
+    return dsn;
+  }
+}
+function getDatabaseTypeFromDSN(dsn) {
+  if (!dsn) {
+    return void 0;
+  }
+  const protocol = dsn.split(":")[0];
+  return protocolToConnectorType(protocol);
+}
+function protocolToConnectorType(protocol) {
+  const mapping = {
+    "dameng": "dameng",
+    "postgres": "postgres",
+    "postgresql": "postgres",
+    "mysql": "mysql",
+    "mariadb": "mariadb",
+    "sqlserver": "sqlserver",
+    "sqlite": "sqlite"
+  };
+  return mapping[protocol];
+}
+function getDefaultPortForType(type) {
+  const ports = {
+    "dameng": 5236,
+    "postgres": 5432,
+    "mysql": 3306,
+    "mariadb": 3306,
+    "sqlserver": 1433,
+    "sqlite": void 0
+  };
+  return ports[type];
+}
+
+export {
+  parseConnectionInfoFromDSN,
+  obfuscateDSNPassword,
+  getDatabaseTypeFromDSN,
+  getDefaultPortForType
+};