feat: 新增 DB checker — 支持 PostgreSQL/MySQL/SQLite 连接测试与 SQL 查询断言

- 实现 db 类型 checker，使用 Bun 内置 SQL 类
- 支持 db.url 连接字符串和可选 db.query 查询语句
- expect 支持 maxDurationMs、rowCount、rows 逐列校验
- 凭据屏蔽序列化输出
- SQLite 内存数据库测试覆盖

tests/server/checker/runner/db/validate.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from "bun:test";
+
+import { validateDbConfig } from "../../../../../src/server/checker/runner/db/validate";
+
+describe("validateDbConfig", () => {
+  test("空配置无问题", () => {
+    const result = validateDbConfig({ defaults: {}, targets: [] });
+    expect(result).toHaveLength(0);
+  });
+
+  test("缺少 db.url 返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ name: "test", type: "db" }],
+    });
+    expect(result.length).toBeGreaterThan(0);
+    const dbError = result.find((e) => e.path.includes("db"));
+    expect(dbError).toBeDefined();
+    expect(dbError!.code).toBe("required");
+  });
+
+  test("db.url 为空字符串返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "" }, name: "test", type: "db" }],
+    });
+    const urlError = result.find((e) => e.path.includes("db.url"));
+    expect(urlError).toBeDefined();
+    expect(urlError!.code).toBe("required");
+  });
+
+  test("db.query 为空字符串返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { query: "", url: "sqlite://:memory:" }, name: "test", type: "db" }],
+    });
+    const queryError = result.find((e) => e.path.includes("db.query"));
+    expect(queryError).toBeDefined();
+    expect(queryError!.code).toBe("invalid-value");
+  });
+
+  test("db 分组未知字段返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { timeout: 5, url: "sqlite://:memory:" }, name: "test", type: "db" }],
+    });
+    const unknownError = result.find((e) => e.path.includes("db.timeout"));
+    expect(unknownError).toBeDefined();
+    expect(unknownError!.code).toBe("unknown-field");
+  });
+
+  test("expect.maxDurationMs 非数字返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "sqlite://:memory:" }, expect: { maxDurationMs: "invalid" }, name: "test", type: "db" }],
+    });
+    const durationError = result.find((e) => e.path.includes("expect.maxDurationMs"));
+    expect(durationError).toBeDefined();
+    expect(durationError!.code).toBe("invalid-type");
+  });
+
+  test("expect.rowCount 非法 operator 返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "sqlite://:memory:" }, expect: { rowCount: { foo: 1 } }, name: "test", type: "db" }],
+    });
+    const rowCountError = result.find((e) => e.path.includes("expect.rowCount"));
+    expect(rowCountError).toBeDefined();
+    expect(rowCountError!.code).toBe("unknown-operator");
+  });
+
+  test("expect.rows 不是数组返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "sqlite://:memory:" }, expect: { rows: "not-array" }, name: "test", type: "db" }],
+    });
+    const rowsError = result.find((e) => e.path.includes("expect.rows"));
+    expect(rowsError).toBeDefined();
+    expect(rowsError!.code).toBe("invalid-type");
+  });
+
+  test("expect.rows 元素不是对象返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "sqlite://:memory:" }, expect: { rows: ["not-object"] }, name: "test", type: "db" }],
+    });
+    const rowError = result.find((e) => e.path.includes("expect.rows[0]"));
+    expect(rowError).toBeDefined();
+    expect(rowError!.code).toBe("invalid-type");
+  });
+
+  test("expect.rows 中 match 正则非法返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [
+        {
+          db: { url: "sqlite://:memory:" },
+          expect: { rows: [{ name: { match: "[invalid" } }] },
+          name: "test",
+          type: "db",
+        },
+      ],
+    });
+    const matchError = result.find((e) => e.path.includes("expect.rows[0].name"));
+    expect(matchError).toBeDefined();
+    expect(matchError!.code).toBe("invalid-regex");
+  });
+
+  test("expect 未知字段返回错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ db: { url: "sqlite://:memory:" }, expect: { status: [200] }, name: "test", type: "db" }],
+    });
+    const unknownError = result.find((e) => e.path.includes("expect.status"));
+    expect(unknownError).toBeDefined();
+    expect(unknownError!.code).toBe("unknown-field");
+  });
+
+  test("有效配置无错误", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [
+        {
+          db: { query: "SELECT 1", url: "sqlite://:memory:" },
+          expect: { maxDurationMs: 5000, rowCount: { gte: 1 }, rows: [{ cnt: { gte: 1 } }] },
+          name: "test",
+          type: "db",
+        },
+      ],
+    });
+    expect(result).toHaveLength(0);
+  });
+
+  test("忽略非 db 类型 target", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [{ name: "test", type: "http" }],
+    });
+    expect(result).toHaveLength(0);
+  });
+
+  test("多个 db target 分别校验", () => {
+    const result = validateDbConfig({
+      defaults: {},
+      targets: [
+        { db: { url: "sqlite://:memory:" }, name: "db1", type: "db" },
+        { db: { url: "" }, name: "db2", type: "db" },
+      ],
+    });
+    expect(result.length).toBeGreaterThan(0);
+    const db2Error = result.find((e) => e.targetName === "db2");
+    expect(db2Error).toBeDefined();
+  });
+});