chore: 强化代码质量与风格检查体系

ESLint 升级到 recommended-type-checked + stylistic-type-checked，引入 perfectionist 导入排序和 import 插件导入验证。 Prettier 显式声明全部格式化参数，消除跨环境差异。 TypeScript 启用 noUnusedLocals 和 noPropertyAccessFromIndexSignature。完善 ignore 列表，排除 .agents/、bun.lock、data/ 等。引入 husky + lint-staged（pre-commit）+ commitlint（commit-msg）。更新 DEVELOPMENT.md 代码质量章节。修复所有新增规则检测到的类型和风格违规。
2026-05-12 18:44:59 +08:00
parent ce8baae3d1
commit a5cf6065c2
83 changed files with 2654 additions and 1824 deletions
--- a/src/server/checker/runner/http/expect.ts
+++ b/src/server/checker/runner/http/expect.ts
@@ -1,31 +1,16 @@
 import type { HeaderExpect, HttpExpectConfig } from "../../types";
-import { mismatchFailure, errorFailure } from "../shared/failure";
-import { applyOperator } from "../shared/operator";
-import { checkDuration } from "../shared/duration";
-import { checkBodyExpect } from "../shared/body";
 import type { ExpectResult } from "../shared/duration";

-export function checkStatus(statusCode: number, allowed: number[]): ExpectResult {
-  if (!allowed.includes(statusCode)) {
-    return {
-      matched: false,
-      failure: mismatchFailure(
-        "status",
-        "status",
-        allowed,
-        statusCode,
-        `status ${statusCode} not in [${allowed}]`,
-      ),
-    };
-  }
-  return { matched: true, failure: null };
-}
+import { checkBodyExpect } from "../shared/body";
+import { checkDuration } from "../shared/duration";
+import { errorFailure, mismatchFailure } from "../shared/failure";
+import { applyOperator } from "../shared/operator";

 export function checkHeaders(
  headers: Record<string, string>,
  headerExpects?: Record<string, HeaderExpect>,
 ): ExpectResult {
-  if (!headerExpects) return { matched: true, failure: null };
+  if (!headerExpects) return { failure: null, matched: true };

  for (const [key, expected] of Object.entries(headerExpects)) {
    const actualValue = headers[key.toLowerCase()];
@@ -34,36 +19,36 @@ export function checkHeaders(
    if (typeof expected === "string") {
      if (actualValue !== expected) {
        return {
-          matched: false,
          failure: mismatchFailure("headers", path, expected, actualValue, `header ${key} mismatch`),
+          matched: false,
        };
      }
    } else {
      if (actualValue === undefined) {
        if (expected.exists !== false) {
          return {
-            matched: false,
            failure: mismatchFailure("headers", path, "defined", undefined, `header ${key} not found`),
+            matched: false,
          };
        }
        continue;
      }
      if (!applyOperator(actualValue, expected)) {
        return {
-          matched: false,
          failure: mismatchFailure("headers", path, expected, actualValue, `header ${key} mismatch`),
+          matched: false,
        };
      }
    }
  }

-  return { matched: true, failure: null };
+  return { failure: null, matched: true };
 }

 export function checkHttpExpect(
  statusCode: number,
  headers: Record<string, string>,
-  body: string | null,
+  body: null | string,
  durationMs: number,
  expect?: HttpExpectConfig,
 ): ExpectResult {
@@ -83,13 +68,29 @@ export function checkHttpExpect(
  if (expect.body && expect.body.length > 0) {
    if (body === null) {
      return {
-        matched: false,
        failure: errorFailure("body", "body", "body is null but body rules are configured"),
+        matched: false,
      };
    }
    const bodyResult = checkBodyExpect(body, expect.body);
    if (!bodyResult.matched) return bodyResult;
  }

-  return { matched: true, failure: null };
+  return { failure: null, matched: true };
+}
+
+export function checkStatus(statusCode: number, allowed: number[]): ExpectResult {
+  if (!allowed.includes(statusCode)) {
+    return {
+      failure: mismatchFailure(
+        "status",
+        "status",
+        allowed,
+        statusCode,
+        `status ${statusCode} not in [${allowed.join(", ")}]`,
+      ),
+      matched: false,
+    };
+  }
+  return { failure: null, matched: true };
 }
--- a/src/server/checker/runner/http/runner.ts
+++ b/src/server/checker/runner/http/runner.ts
@@ -1,51 +1,15 @@
-import type { CheckResult } from "../../types";
 import { isError } from "es-toolkit";
-import type {
-  Checker,
-  CheckerContext,
-  ResolveContext,
-} from "../types";
-import type {
-  HttpExpectConfig,
-  HttpTargetConfig,
-  ResolvedHttpTarget,
-  ResolvedTarget,
-  TargetConfig,
-} from "../../types";
+
+import type { CheckResult, HttpTargetConfig, ResolvedHttpTarget, ResolvedTarget, TargetConfig } from "../../types";
+import type { Checker, CheckerContext, ResolveContext } from "../types";
+
 import { parseSize } from "../../size";
-import { checkHttpExpect } from "./expect";
 import { errorFailure } from "../shared/failure";
+import { checkHttpExpect } from "./expect";

 export class HttpChecker implements Checker {
  readonly type = "http";

-  resolve(target: TargetConfig, context: ResolveContext): ResolvedTarget {
-    const t = target as TargetConfig & { type: "http"; http: HttpTargetConfig };
-    const httpDefaults = context.defaults.http;
-
-    if (!t.http.url || t.http.url.trim() === "") {
-      throw new Error(`target "${t.name}" 缺少 http.url 字段`);
-    }
-
-    const maxBodyBytes = parseSize(t.http.maxBodyBytes ?? httpDefaults?.maxBodyBytes ?? "100MB");
-
-    return {
-      type: "http",
-      name: t.name,
-      group: target.group ?? "default",
-      http: {
-        url: t.http.url,
-        method: t.http.method ?? httpDefaults?.method ?? "GET",
-        headers: { ...(httpDefaults?.headers ?? {}), ...(t.http.headers ?? {}) },
-        body: t.http.body,
-        maxBodyBytes,
-      },
-      intervalMs: context.defaultIntervalMs,
-      timeoutMs: context.defaultTimeoutMs,
-      expect: target.expect as HttpExpectConfig | undefined,
-    } satisfies ResolvedHttpTarget;
-  }
-
  async execute(target: ResolvedTarget, ctx: CheckerContext): Promise<CheckResult> {
    const t = target as ResolvedHttpTarget;
    const timestamp = new Date().toISOString();
@@ -54,9 +18,9 @@ export class HttpChecker implements Checker {
      const start = performance.now();

      const response = await fetch(t.http.url, {
-        method: t.http.method,
-        headers: t.http.headers,
        body: t.http.method !== "GET" && t.http.method !== "HEAD" ? t.http.body : undefined,
+        headers: t.http.headers,
+        method: t.http.method,
        signal: ctx.signal,
      });

@@ -67,19 +31,19 @@ export class HttpChecker implements Checker {
      const hasBodyRules = !!(t.expect?.body && t.expect.body.length > 0);

      const preBodyExpect = t.expect
-        ? { status: t.expect.status, maxDurationMs: t.expect.maxDurationMs, headers: t.expect.headers }
+        ? { headers: t.expect.headers, maxDurationMs: t.expect.maxDurationMs, status: t.expect.status }
        : undefined;

      const preBodyResult = checkHttpExpect(statusCode, responseHeaders, null, durationMs, preBodyExpect);

      if (!hasBodyRules || !preBodyResult.matched) {
        return {
+          durationMs,
+          failure: preBodyResult.failure,
+          matched: preBodyResult.matched,
+          statusDetail: `HTTP ${statusCode}`,
          targetName: t.name,
          timestamp,
-          matched: preBodyResult.matched,
-          durationMs,
-          statusDetail: `HTTP ${statusCode}`,
-          failure: preBodyResult.failure,
        };
      }

@@ -87,16 +51,12 @@ export class HttpChecker implements Checker {

      if (bodyBuffer.byteLength > t.http.maxBodyBytes) {
        return {
+          durationMs,
+          failure: errorFailure("body", "body", `响应体大小 ${bodyBuffer.byteLength} 超过限制 ${t.http.maxBodyBytes}`),
+          matched: false,
+          statusDetail: `HTTP ${statusCode}`,
          targetName: t.name,
          timestamp,
-          matched: false,
-          durationMs,
-          statusDetail: `HTTP ${statusCode}`,
-          failure: errorFailure(
-            "body",
-            "body",
-            `响应体大小 ${bodyBuffer.byteLength} 超过限制 ${t.http.maxBodyBytes}`,
-          ),
        };
      }

@@ -104,42 +64,69 @@ export class HttpChecker implements Checker {
      const fullResult = checkHttpExpect(statusCode, responseHeaders, body, durationMs, t.expect);

      return {
+        durationMs,
+        failure: fullResult.failure,
+        matched: fullResult.matched,
+        statusDetail: `HTTP ${statusCode}`,
        targetName: t.name,
        timestamp,
-        matched: fullResult.matched,
-        durationMs,
-        statusDetail: `HTTP ${statusCode}`,
-        failure: fullResult.failure,
      };
    } catch (error) {
      const isTimeout = ctx.signal.aborted || (error instanceof DOMException && error.name === "AbortError");

      return {
-        targetName: t.name,
-        timestamp,
-        matched: false,
        durationMs: null,
-        statusDetail: null,
        failure: errorFailure(
          "status",
          "request",
          isTimeout ? `请求超时 (${t.timeoutMs}ms)` : isError(error) ? error.message : String(error),
        ),
+        matched: false,
+        statusDetail: null,
+        targetName: t.name,
+        timestamp,
      };
    }
  }

-  serialize(target: ResolvedTarget): { target: string; config: string } {
+  resolve(target: TargetConfig, context: ResolveContext): ResolvedTarget {
+    const t = target as TargetConfig & { http: HttpTargetConfig; type: "http" };
+    const httpDefaults = context.defaults.http;
+
+    if (!t.http.url || t.http.url.trim() === "") {
+      throw new Error(`target "${t.name}" 缺少 http.url 字段`);
+    }
+
+    const maxBodyBytes = parseSize(t.http.maxBodyBytes ?? httpDefaults?.maxBodyBytes ?? "100MB");
+
+    return {
+      expect: target.expect,
+      group: target.group ?? "default",
+      http: {
+        body: t.http.body,
+        headers: { ...(httpDefaults?.headers ?? {}), ...(t.http.headers ?? {}) },
+        maxBodyBytes,
+        method: t.http.method ?? httpDefaults?.method ?? "GET",
+        url: t.http.url,
+      },
+      intervalMs: context.defaultIntervalMs,
+      name: t.name,
+      timeoutMs: context.defaultTimeoutMs,
+      type: "http",
+    } satisfies ResolvedHttpTarget;
+  }
+
+  serialize(target: ResolvedTarget): { config: string; target: string } {
    const t = target as ResolvedHttpTarget;
    return {
-      target: t.http.url,
      config: JSON.stringify({
-        url: t.http.url,
-        method: t.http.method,
-        headers: t.http.headers,
        body: t.http.body,
+        headers: t.http.headers,
        maxBodyBytes: t.http.maxBodyBytes,
+        method: t.http.method,
+        url: t.http.url,
      }),
+      target: t.http.url,
    };
  }
 }