bk-schema-checker 0.1.0 → 0.1.2

package/README.md

@@ -14,7 +14,7 @@
 
 请求参数不看 mock 读了什么，而看 services 调用的参数类型：GET 的第二个参数是查询参数，POST、PUT、PATCH、DELETE 的第二个参数是请求体。路径参数来自 Django 的 `<str:system_id>` 这类转换器。
 
-后台用 Python 标准库 `ast` 静态读取，包括字段继承、自定义字段子类、`SerializerMethodField` 的返回注解，以及能静态求值的 `choices`。前端 `tsconfig.json` 的 `paths` 用来展开 `@common/const` 这类别名；`export enum`、`export interface` 和 `` `${Enum}` `` 会展开成具体类型再比较。
+后台用 Python 标准库 `ast` 静态读取，包括字段继承、自定义字段子类、`SerializerMethodField` 的返回注解，以及能静态求值的 `choices`。前端 `tsconfig.json` 的 `paths` 用来展开 `@common/const` 这类别名；`export enum`、`export interface`（含 `extends`）、`A & { extra }` 交叉类型和 `` `${Enum}` `` 会展开成具体类型再比较。
 
 ## 环境要求
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bk-schema-checker",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "对照前端 services、Django REST 序列化器，以及可选的 bk-local-mock 响应，做接口协议检查。不启动 Django。",
   "type": "module",
   "author": "austinqli",

package/src/mock-shim.js

@@ -23,7 +23,7 @@ export const listResult = (results) => ({
 });
 
 export const getRequestParam = (config, key) => {
-  const value = config?.params?.[key];
+  const value = config?.params?.[key] ?? new URL(config?.url || "", "https://mock.local").searchParams.get(key);
   return value === undefined || value === null ? "" : String(value);
 };
 
@@ -38,3 +38,5 @@ export const paginatedListResult = (results, config) => {
 };
 
 export const getMethod = (config) => (config?.method || "get").toLowerCase();
+
+export const getPathname = (url) => new URL(url || "", "https://mock.local").pathname;

package/src/runtime.js

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -9,12 +10,12 @@ const METHOD_ORDER = ["get", "post", "put", "patch", "delete"];
  * 同一个运行时里模块缓存是共享的，后执行的接口能看到前面写入的内存数据。
  */
 export async function createMockRuntime({ root, mockDir, servicesDir }) {
-  const createJiti = await loadCreateJiti(root);
+  const createJiti = await loadCreateJiti(root, mockDir);
   const jiti = createJiti(import.meta.url, {
     alias: {
       "@mock": mockDir,
       "@services": servicesDir,
-      "bk-local-mock": findMockPackage(root),
+      "bk-local-mock": findMockPackage(root, mockDir),
     },
     interopDefault: true,
     fsCache: false,
@@ -200,7 +201,7 @@ function snapshot(value) {
   }
 }
 
-async function loadCreateJiti(root) {
+async function loadCreateJiti(root, mockDir) {
   try {
     const mod = await import("jiti");
     if (typeof mod.createJiti === "function") {
@@ -209,6 +210,17 @@ async function loadCreateJiti(root) {
   } catch {
     // 检查器自己没装 jiti 时，用前端工程里的那一份。
   }
+  for (const start of moduleResolveStarts(root, mockDir)) {
+    try {
+      const resolved = createRequire(start).resolve("jiti");
+      const mod = await import(pathToFileURL(resolved).href);
+      if (typeof mod.createJiti === "function") {
+        return mod.createJiti;
+      }
+    } catch {
+      // 这一层没有安装，继续往上看。
+    }
+  }
   for (const candidate of jitiCandidates(root)) {
     if (fs.existsSync(candidate)) {
       const mod = await import(pathToFileURL(candidate).href);
@@ -220,13 +232,25 @@ async function loadCreateJiti(root) {
   throw new Error("执行 mock 需要 jiti。请在 frontend 安装依赖，或在 bk-schema-checker 中安装 jiti。");
 }
 
-function findMockPackage(root) {
-  for (const candidate of [
-    path.join(root, "frontend/node_modules/bk-local-mock/index.js"),
-    path.resolve(fileDir(), "../../frontend/node_modules/bk-local-mock/index.js"),
-  ]) {
-    if (fs.existsSync(candidate)) {
-      return candidate;
+function moduleResolveStarts(root, mockDir) {
+  return [
+    mockDir && path.join(mockDir, "handler.js"),
+    root && path.join(root, "package.json"),
+    root && path.join(root, "frontend/package.json"),
+    path.join(fileDir(), "runtime.js"),
+  ].filter(Boolean);
+}
+
+/**
+ * 按 Node 解析规则找已安装的 bk-local-mock。
+ * 配置文件常放在 frontend/，旧逻辑只认 root/frontend/node_modules，会漏掉当前工程自己的依赖。
+ */
+export function findMockPackage(root, mockDir) {
+  for (const start of moduleResolveStarts(root, mockDir)) {
+    try {
+      return createRequire(start).resolve("bk-local-mock");
+    } catch {
+      // 这一层没有安装，继续往上看。
     }
   }
   return path.join(fileDir(), "mock-shim.js");

package/src/ts.js

@@ -6,6 +6,7 @@ import { maskComments, readIdentifier, skipSpace, sliceBalanced, splitTop } from
 const HELPERS = new Set([
   "clone",
   "getMethod",
+  "getPathname",
   "getRequestParam",
   "listResult",
   "paginatedListResult",
@@ -480,7 +481,10 @@ function parseTypeExport(source, cursor, mod) {
   if (interfaceLike || source[bodyAt] === "{") {
     const open = source.indexOf("{", bodyAt);
     const block = sliceBalanced(source, open);
-    mod.types.set(ident.name, { kind: "source", source: source.slice(open, block.end + 1) });
+    const body = source.slice(open, block.end + 1);
+    const parents = interfaceLike ? parseInterfaceExtends(source, bodyAt, open) : [];
+    const composed = parents.length ? `${parents.join(" & ")} & ${body}` : body;
+    mod.types.set(ident.name, { kind: "source", source: composed });
     return block.end + 1;
   }
   if (source[bodyAt] === "=") {
@@ -492,6 +496,31 @@ function parseTypeExport(source, cursor, mod) {
   return skipStatement(source, cursor).end;
 }
 
+function parseInterfaceExtends(source, start, open) {
+  const text = source.slice(start, open).trim();
+  if (!/^extends\b/.test(text)) {
+    return [];
+  }
+  const names = [];
+  let cursor = skipSpace(text, "extends".length);
+  while (cursor < text.length) {
+    const ident = readIdentifier(text, cursor);
+    if (!ident) {
+      break;
+    }
+    names.push(ident.name);
+    cursor = skipSpace(text, ident.end);
+    if (text[cursor] === "<") {
+      const generic = sliceAngles(text, cursor);
+      cursor = skipSpace(text, generic ? generic.end + 1 : cursor + 1);
+    }
+    if (text[cursor] === ",") {
+      cursor = skipSpace(text, cursor + 1);
+    }
+  }
+  return names;
+}
+
 function parseEnumExport(source, cursor, mod) {
   const head = source.slice(cursor, cursor + 24);
   const keyword = /^export\s+const\s+enum\b/.test(head) ? "export const enum" : "export enum";
@@ -1504,7 +1533,7 @@ function evalCall(node, env) {
     }
     return new Partial("string");
   }
-  if (callee?.helper === "getMethod") {
+  if (callee?.helper === "getMethod" || callee?.helper === "getPathname") {
     return new Partial("string");
   }
   if (callee && callee.kind === "function") {
@@ -1747,6 +1776,17 @@ function skeleton(type) {
     value.fields = Object.fromEntries(type.props.map((prop) => [prop.name, skeleton(prop.type)]));
     return value;
   }
+  if (type.kind === "intersection") {
+    const value = new Partial("object");
+    value.fields = {};
+    for (const item of type.types) {
+      const next = skeleton(item);
+      if (next instanceof Partial && next.fields) {
+        Object.assign(value.fields, next.fields);
+      }
+    }
+    return value;
+  }
   return new Partial();
 }
 
@@ -1764,7 +1804,7 @@ function parseTypeAt(source, cursor) {
 }
 
 function parseUnionType(source, cursor) {
-  let current = parsePrimaryType(source, cursor);
+  let current = parseIntersectionType(source, cursor);
   const types = [current.type];
   let end = current.end;
   while (true) {
@@ -1772,13 +1812,29 @@ function parseUnionType(source, cursor) {
     if (source[next] !== "|") {
       break;
     }
-    current = parsePrimaryType(source, next + 1);
+    current = parseIntersectionType(source, next + 1);
     types.push(current.type);
     end = current.end;
   }
   return { type: types.length === 1 ? types[0] : { kind: "union", types }, end };
 }
 
+function parseIntersectionType(source, cursor) {
+  let current = parsePrimaryType(source, cursor);
+  const types = [current.type];
+  let end = current.end;
+  while (true) {
+    const next = skipSpace(source, end);
+    if (source[next] !== "&") {
+      break;
+    }
+    current = parsePrimaryType(source, next + 1);
+    types.push(current.type);
+    end = current.end;
+  }
+  return { type: types.length === 1 ? types[0] : { kind: "intersection", types }, end };
+}
+
 function parsePrimaryType(source, cursor) {
   const start = skipSpace(source, cursor);
   if (source[start] === "{") {
@@ -2004,16 +2060,19 @@ function splitTypeProps(source) {
 export function resolveTsType(type, mod, index, seen = new Set()) {
   if (!type || type.kind !== "ref" && type.kind !== "index" && type.kind !== "parameters") {
     if (type?.kind === "array") {
-      return { kind: "array", item: resolveTsType(type.item, mod, index, seen) };
+      return { kind: "array", item: resolveTsType(type.item, mod, index, new Set(seen)) };
     }
     if (type?.kind === "union") {
-      return { kind: "union", types: type.types.map((item) => resolveTsType(item, mod, index, seen)) };
+      return { kind: "union", types: type.types.map((item) => resolveTsType(item, mod, index, new Set(seen))) };
+    }
+    if (type?.kind === "intersection") {
+      return mergeResolvedTypes(type.types.map((item) => resolveTsType(item, mod, index, new Set(seen))));
     }
     if (type?.kind === "object") {
       return {
         kind: "object",
         open: Boolean(type.open),
-        props: type.props.map((prop) => ({ ...prop, type: resolveTsType(prop.type, mod, index, seen) })),
+        props: type.props.map((prop) => ({ ...prop, type: resolveTsType(prop.type, mod, index, new Set(seen)) })),
       };
     }
     return type || { kind: "any" };
@@ -2044,6 +2103,59 @@ export function resolveTsType(type, mod, index, seen = new Set()) {
   return resolved;
 }
 
+function mergeResolvedTypes(types) {
+  const parts = types.flatMap((type) => (type?.kind === "intersection" ? type.types : [type])).filter(Boolean);
+  const unions = parts.filter((type) => type.kind === "union");
+  if (unions.length) {
+    const rest = parts.filter((type) => type.kind !== "union");
+    return {
+      kind: "union",
+      types: unions[0].types.map((item) => mergeResolvedTypes([item, ...unions.slice(1), ...rest])),
+    };
+  }
+  const objects = parts.filter((type) => type.kind === "object");
+  if (objects.length) {
+    return mergeObjectTypes(objects);
+  }
+  const concrete = parts.filter((type) => type.kind !== "any" && type.kind !== "null");
+  return concrete[0] || parts[0] || { kind: "any" };
+}
+
+function mergeObjectTypes(objects) {
+  const props = [];
+  let open = false;
+  for (const object of objects) {
+    open = open || Boolean(object.open);
+    for (const prop of object.props || []) {
+      const index = props.findIndex((item) => item.name === prop.name);
+      if (index === -1) {
+        props.push({ ...prop });
+        continue;
+      }
+      const prev = props[index];
+      props[index] = {
+        name: prop.name,
+        optional: Boolean(prev.optional && prop.optional),
+        type: mergePropertyType(prev.type, prop.type),
+      };
+    }
+  }
+  return { kind: "object", props, open };
+}
+
+function mergePropertyType(left, right) {
+  if (!left || left.kind === "any") {
+    return right;
+  }
+  if (!right || right.kind === "any") {
+    return left;
+  }
+  if (left.kind === "object" && right.kind === "object") {
+    return mergeObjectTypes([left, right]);
+  }
+  return right;
+}
+
 function lookupType(mod, name, index, stack = new Set()) {
   if (!mod || stack.has(mod.file)) {
     return null;