@mindbase/express-common 1.0.6 → 1.0.8

package/utils/ZodSchemaParser.ts

@@ -0,0 +1,420 @@
+import {
+  Node,
+  SyntaxKind,
+  SourceFile,
+  VariableDeclaration,
+  CallExpression,
+  ObjectLiteralExpression,
+  PropertyAccessExpression,
+  Identifier,
+  StringLiteral,
+  NumericLiteral,
+  AsExpression,
+} from "ts-morph";
+import { FieldValidation, FieldConstraints } from "../types/DocTypes";
+import logger from "./Logger";
+
+/**
+ * Zod Schema AST 解析器
+ * 从 Zod schema 变量定义中提取字段结构
+ */
+export class ZodSchemaParser {
+  /**
+   * 解析 schema 变量，返回字段结构
+   */
+  public parseSchemaVariable(
+    sourceFile: SourceFile,
+    schemaName: string
+  ): Record<string, FieldValidation> | null {
+    try {
+      // 1. 查找 schema 变量声明
+      const variableDecl = this.findVariableDeclaration(sourceFile, schemaName);
+      if (!variableDecl) {
+        logger.warn(`未找到 schema 变量: ${schemaName}`);
+        return null;
+      }
+
+      // 2. 获取初始化表达式
+      const initializer = variableDecl.getInitializer();
+      if (!initializer) {
+        logger.warn(`schema 变量 ${schemaName} 没有初始化表达式`);
+        return null;
+      }
+
+      // 3. 解析 z.object({...}) 调用
+      return this.parseZodObject(initializer);
+    } catch (error) {
+      logger.error(`解析 schema 变量失败: ${schemaName}`, error);
+      return null;
+    }
+  }
+
+  /**
+   * 查找变量声明
+   */
+  private findVariableDeclaration(
+    sourceFile: SourceFile,
+    name: string
+  ): VariableDeclaration | null {
+    for (const decl of sourceFile.getVariableDeclarations()) {
+      if (decl.getName() === name) {
+        return decl;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 解析 z.object({...}) 调用
+   */
+  private parseZodObject(node: Node): Record<string, FieldValidation> | null {
+    // 处理 as any 类型断言
+    let targetNode = node;
+    if (Node.isAsExpression(node)) {
+      targetNode = node.getExpression();
+    }
+
+    // 检查是否是 z.object() 调用
+    if (Node.isCallExpression(targetNode)) {
+      const expr = targetNode.getExpression();
+      if (Node.isPropertyAccessExpression(expr)) {
+        const propText = expr.getText();
+        if (propText === "z.object") {
+          const args = targetNode.getArguments();
+          if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+            return this.parseObjectLiteral(args[0]);
+          }
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 解析对象字面量中的字段定义
+   */
+  private parseObjectLiteral(
+    objLit: ObjectLiteralExpression
+  ): Record<string, FieldValidation> {
+    const fields: Record<string, FieldValidation> = {};
+
+    for (const prop of objLit.getProperties()) {
+      if (Node.isPropertyAssignment(prop)) {
+        const fieldName = prop.getName();
+        const initializer = prop.getInitializer();
+        if (initializer) {
+          fields[fieldName] = this.parseZodField(initializer);
+        }
+      }
+    }
+
+    return fields;
+  }
+
+  /**
+   * 解析单个 Zod 字段定义
+   */
+  private parseZodField(node: Node): FieldValidation {
+    const field: FieldValidation = {
+      type: "any",
+      required: true,
+    };
+
+    // 处理 as any 类型断言
+    let targetNode = node;
+    if (Node.isAsExpression(node)) {
+      targetNode = node.getExpression();
+    }
+
+    // 收集方法调用链
+    const callChain = this.collectCallChain(targetNode);
+
+    // 解析类型和约束
+    for (const call of callChain) {
+      this.applyZodMethod(field, call);
+    }
+
+    return field;
+  }
+
+  /**
+   * 收集方法调用链
+   * 例如: z.string().min(1).optional() -> [{method: "z.string", args: []}, {method: "min", args: [...]}, {method: "optional", args: []}]
+   */
+  private collectCallChain(
+    node: Node
+  ): Array<{ method: string; args: Node[] }> {
+    const chain: Array<{ method: string; args: Node[] }> = [];
+
+    let current: Node | undefined = node;
+    while (current && Node.isCallExpression(current)) {
+      const expr = current.getExpression();
+      const args = current.getArguments();
+
+      if (Node.isPropertyAccessExpression(expr)) {
+        const methodName = expr.getName();
+        chain.unshift({ method: methodName, args: [...args] });
+        current = expr.getExpression();
+      } else if (Node.isIdentifier(expr)) {
+        // z.string, z.number 等基础类型
+        chain.unshift({ method: expr.getText(), args: [] });
+        break;
+      } else if (Node.isPropertyAccessExpression(expr)) {
+        // 处理 z.coerce.number() 这种链式
+        chain.unshift({
+          method: (expr as PropertyAccessExpression).getName(),
+          args: [],
+        });
+        current = (expr as PropertyAccessExpression).getExpression();
+      } else {
+        break;
+      }
+    }
+
+    return chain;
+  }
+
+  /**
+   * 应用 Zod 方法到字段定义
+   */
+  private applyZodMethod(
+    field: FieldValidation,
+    call: { method: string; args: Node[] }
+  ): void {
+    const { method, args } = call;
+
+    switch (method) {
+      // 类型定义
+      case "z.string":
+      case "string":
+        field.type = "string";
+        break;
+      case "z.number":
+      case "number":
+        field.type = "number";
+        break;
+      case "z.boolean":
+      case "boolean":
+        field.type = "boolean";
+        break;
+      case "z.array":
+      case "array":
+        field.type = "array";
+        // 尝试解析数组元素类型
+        if (args.length > 0) {
+          field.items = this.parseZodField(args[0]);
+        }
+        break;
+      case "z.object":
+      case "object":
+        field.type = "object";
+        // 尝试解析对象属性
+        if (args.length > 0 && Node.isObjectLiteralExpression(args[0])) {
+          field.properties = this.parseObjectLiteral(args[0]);
+        }
+        break;
+      case "z.date":
+      case "date":
+        field.type = "date";
+        break;
+      case "z.any":
+      case "any":
+        field.type = "any";
+        break;
+      case "z.unknown":
+      case "unknown":
+        field.type = "any";
+        break;
+      case "z.undefined":
+      case "undefined":
+        field.required = false;
+        field.optional = true;
+        break;
+      case "z.null":
+      case "null":
+        field.nullable = true;
+        break;
+      case "z.void":
+      case "void":
+        field.type = "any";
+        break;
+      case "z.nativeEnum":
+      case "nativeEnum":
+      case "z.enum":
+      case "enum":
+        field.type = "string";
+        break;
+      case "coerce":
+        // z.coerce 是属性访问，不做处理，后续调用会设置类型
+        break;
+
+      // 可选性
+      case "optional":
+        field.required = false;
+        field.optional = true;
+        break;
+      case "nullable":
+        field.nullable = true;
+        break;
+      case "nullish":
+        field.required = false;
+        field.optional = true;
+        field.nullable = true;
+        break;
+
+      // 默认值
+      case "default":
+        if (args.length > 0) {
+          field.defaultValue = this.parseArgumentValue(args[0]);
+          field.required = false;
+        }
+        break;
+
+      // 约束 - 通用
+      case "min":
+        if (args.length > 0) {
+          const minVal = this.parseArgumentValue(args[0]);
+          field.constraints = field.constraints || {};
+          if (field.type === "string") {
+            field.constraints.minLength = minVal;
+          } else if (field.type === "number") {
+            field.constraints.min = minVal;
+          }
+          // 提取错误消息
+          if (args.length > 1) {
+            const msg = this.parseArgumentValue(args[1]);
+            if (typeof msg === "string") {
+              field.constraints.custom = field.constraints.custom || [];
+              field.constraints.custom.push(msg);
+            }
+          }
+        }
+        break;
+      case "max":
+        if (args.length > 0) {
+          const maxVal = this.parseArgumentValue(args[0]);
+          field.constraints = field.constraints || {};
+          if (field.type === "string") {
+            field.constraints.maxLength = maxVal;
+          } else if (field.type === "number") {
+            field.constraints.max = maxVal;
+          }
+        }
+        break;
+      case "length":
+        if (args.length > 0) {
+          const lenVal = this.parseArgumentValue(args[0]);
+          field.constraints = field.constraints || {};
+          field.constraints.minLength = lenVal;
+          field.constraints.maxLength = lenVal;
+        }
+        break;
+
+      // 约束 - 字符串
+      case "email":
+        field.constraints = field.constraints || {};
+        field.constraints.email = true;
+        break;
+      case "url":
+        field.constraints = field.constraints || {};
+        field.constraints.url = true;
+        break;
+      case "uuid":
+        field.constraints = field.constraints || {};
+        field.constraints.uuid = true;
+        break;
+      case "regex":
+      case "pattern":
+        if (args.length > 0) {
+          field.constraints = field.constraints || {};
+          field.constraints.pattern = args[0].getText();
+        }
+        break;
+      case "startsWith":
+      case "endsWith":
+      case "includes":
+      case "trim":
+      case "toLowerCase":
+      case "toUpperCase":
+        // 字符串转换方法，暂不处理
+        break;
+
+      // 约束 - 数字
+      case "int":
+        field.constraints = field.constraints || {};
+        field.constraints.int = true;
+        break;
+      case "positive":
+        field.constraints = field.constraints || {};
+        field.constraints.positive = true;
+        break;
+      case "nonnegative":
+        field.constraints = field.constraints || {};
+        field.constraints.nonnegative = true;
+        break;
+      case "negative":
+        field.constraints = field.constraints || {};
+        field.constraints.max = -1;
+        break;
+      case "nonpositive":
+        field.constraints = field.constraints || {};
+        field.constraints.max = 0;
+        break;
+      case "finite":
+      case "safe":
+        // 数字安全检查，暂不处理
+        break;
+
+      // 约束 - 数组
+      case "nonempty":
+        field.constraints = field.constraints || {};
+        field.constraints.minLength = 1;
+        break;
+
+      // 其他方法
+      case "refine":
+      case "superRefine":
+      case "transform":
+      case "pipe":
+      case " preprocess":
+      case "omit":
+      case "pick":
+      case "partial":
+      case "required":
+      case "strict":
+      case "passthrough":
+      case "extend":
+      case "merge":
+      case "keyof":
+        // 高级方法，暂不处理
+        break;
+    }
+  }
+
+  /**
+   * 解析参数值
+   */
+  private parseArgumentValue(node: Node): any {
+    if (Node.isStringLiteral(node)) {
+      return node.getLiteralValue();
+    } else if (Node.isNumericLiteral(node)) {
+      return node.getLiteralValue();
+    } else if (Node.isTrueLiteral(node)) {
+      return true;
+    } else if (Node.isFalseLiteral(node)) {
+      return false;
+    } else if (Node.isIdentifier(node)) {
+      return node.getText();
+    } else if (Node.isObjectLiteralExpression(node)) {
+      // 返回对象字面量的文本表示
+      return node.getText();
+    } else if (Node.isArrayLiteralExpression(node)) {
+      // 返回数组字面量的文本表示
+      return node.getText();
+    }
+    return node.getText();
+  }
+}
+
+// 导出单例实例
+export const zodSchemaParser = new ZodSchemaParser();

package/zod/Doc.schema.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+// 路由ID参数
+export const routeIdParamsSchema = z.object({
+  id: z.coerce.number().int().positive("无效的路由ID"),
+});
+
+// 类型导出
+export type RouteIdParams = z.infer<typeof routeIdParamsSchema>;