bk-schema-checker 0.1.0 → 0.1.1

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.1",
   "description": "对照前端 services、Django REST 序列化器，以及可选的 bk-local-mock 响应，做接口协议检查。不启动 Django。",
   "type": "module",
   "author": "austinqli",

package/src/ts.js

@@ -480,7 +480,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 +495,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";
@@ -1747,6 +1775,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 +1803,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 +1811,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 +2059,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 +2102,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;