@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/dist/core/analyzers/ClassAnalyzer.d.ts

@@ -0,0 +1,23 @@
+import { ClassDeclaration, InterfaceDeclaration } from 'ts-morph';
+import { ClassAnalysis, InterfaceAnalysis } from '../Types';
+export declare class ClassAnalyzer {
+    static analyzeClass(classDecl: ClassDeclaration): ClassAnalysis;
+    static analyzeInterface(interfaceDecl: InterfaceDeclaration): InterfaceAnalysis;
+    private static analyzeInheritanceInfo;
+    private static analyzeConstructorParameters;
+    private static parseSerializableOptions;
+    private static parseSerialNameOptions;
+    private static analyzeOwnProperties;
+    private static classifyProperties;
+    private static collectAllAncestorProperties;
+    private static extractConstructorParams;
+    private static createPropertyAnalysis;
+    private static analyzePropertyType;
+    private static simplifyImportType;
+    private static getTypeFromInitializer;
+    private static isOptional;
+    private static analyzeDefaultValue;
+    private static hasUndefinedInUnion;
+    private static splitUnionType;
+    private static analyzePropertyDecorators;
+}

package/dist/core/analyzers/ClassAnalyzer.js

@@ -0,0 +1,480 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassAnalyzer = void 0;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const constants_1 = require("../constants");
+const GenericTypeSubstitutionUtil_1 = require("../utils/GenericTypeSubstitutionUtil");
+const handlers_1 = require("../handlers");
+const CustomTypeAnalyzer_1 = require("./CustomTypeAnalyzer");
+const CustomError_1 = require("../utils/CustomError");
+const Logger_1 = require("../logger/Logger");
+const TsMorphUtil_1 = require("../utils/TsMorphUtil");
+class ClassAnalyzer {
+    static analyzeClass(classDecl) {
+        Logger_1.Logger.debug(`Analyzing class ${classDecl.wasForgotten()}`);
+        const className = classDecl.getNameOrThrow(`Class name is undefined in ${classDecl.getSourceFile().getFilePath()}`);
+        const sourceFilePath = classDecl.getSourceFile().getFilePath();
+        Logger_1.Logger.warn(`Analyzing class ${className} ${sourceFilePath}`);
+        const generics = {
+            isGeneric: classDecl.getTypeParameters().length > 0,
+            parameters: classDecl.getTypeParameters().map((p) => p.getName())
+        };
+        const inheritance = this.analyzeInheritanceInfo(classDecl);
+        const constructorParams = this.analyzeConstructorParameters(classDecl, inheritance);
+        const decorators = {
+            serializable: this.parseSerializableOptions(classDecl.getDecorator(constants_1.DecoratorConstants.SERIALIZABLE)),
+            serialName: this.parseSerialNameOptions(classDecl.getDecorator(constants_1.DecoratorConstants.SERIAL_NAME))
+        };
+        const ownProperties = this.analyzeOwnProperties(classDecl, constructorParams, generics.parameters);
+        const propertyClassification = this.classifyProperties(ownProperties, inheritance, generics.parameters);
+        return {
+            className,
+            sourceFilePath,
+            originalClass: classDecl,
+            generics,
+            inheritance,
+            decorators,
+            ownProperties,
+            inheritedProperties: propertyClassification.inheritedProperties,
+            overriddenProperties: propertyClassification.overriddenProperties,
+            properties: propertyClassification.properties,
+            constructorParams
+        };
+    }
+    static analyzeInterface(interfaceDecl) {
+        const interfaceName = interfaceDecl.getName();
+        if (!interfaceName) {
+            throw new CustomError_1.CustomError(`Interface name is undefined in ${interfaceDecl.getSourceFile().getFilePath()}`, CustomError_1.ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
+        }
+        const sourceFilePath = interfaceDecl.getSourceFile().getFilePath();
+        const generics = {
+            isGeneric: interfaceDecl.getTypeParameters().length > 0,
+            parameters: interfaceDecl.getTypeParameters().map((p) => p.getName())
+        };
+        const inheritance = this.analyzeInheritanceInfo(interfaceDecl);
+        const ownProperties = this.analyzeOwnProperties(interfaceDecl, [], generics.parameters);
+        const propertyClassification = this.classifyProperties(ownProperties, inheritance, generics.parameters);
+        return {
+            className: interfaceName,
+            sourceFilePath,
+            originalInterface: interfaceDecl,
+            generics,
+            inheritance,
+            ownProperties,
+            inheritedProperties: propertyClassification.inheritedProperties,
+            overriddenProperties: propertyClassification.overriddenProperties,
+            properties: propertyClassification.properties,
+        };
+    }
+    static analyzeInheritanceInfo(cls) {
+        const heritageClaus = cls.getHeritageClauses();
+        Logger_1.Logger.debug(`分析类的继承信息: ${cls.getName()} ${heritageClaus.length} ${heritageClaus.map(c => c.getText()).join(',')}`);
+        for (const clause of heritageClaus) {
+            const token = clause.getToken();
+            if (token !== ts_morph_1.SyntaxKind.ExtendsKeyword) {
+                continue;
+            }
+            const typeNode = clause.getTypeNodes()[0];
+            const className = typeNode.getExpression().getText();
+            const args = typeNode.getTypeArguments();
+            Logger_1.Logger.debug(`继承信息: text: ${className} getTypeArguments: ${args.map(type => type.getText()).join(', ')}`);
+            const classDecl = CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance().findClassDeclFromClassName(className, cls.getSourceFile());
+            if (!classDecl) {
+                throw new CustomError_1.CustomError(`class ${className} decl does not exist ${cls.getName} implement ${className}`, CustomError_1.ErrorCodes.CLASS_DECLARATION_NOT_FOUND);
+            }
+            if (classDecl instanceof ts_morph_1.InterfaceDeclaration) {
+                const baseClassAnalysis = this.analyzeInterface(classDecl);
+                return {
+                    isInherited: true,
+                    baseClassAnalysis,
+                    genericTypeArguments: args
+                };
+            }
+            else {
+                const baseClassAnalysis = this.analyzeClass(classDecl);
+                return {
+                    isInherited: true,
+                    baseClassAnalysis,
+                    genericTypeArguments: args
+                };
+            }
+        }
+        return { isInherited: false };
+    }
+    static analyzeConstructorParameters(classDecl, inheritanceInfo) {
+        const constructors = classDecl.getConstructors();
+        if (constructors.length > 0) {
+            return this.extractConstructorParams(constructors[0]);
+        }
+        if (inheritanceInfo && inheritanceInfo.isInherited) {
+            const baseClassAnalysis = inheritanceInfo.baseClassAnalysis;
+            return this.analyzeConstructorParameters(baseClassAnalysis.originalClass, baseClassAnalysis.inheritance);
+        }
+        return [];
+    }
+    static parseSerializableOptions(decorator) {
+        if (!decorator) {
+            return undefined;
+        }
+        const args = decorator.getArguments();
+        let generateSendable;
+        let _with;
+        let deserializationMode;
+        const firstArg = args[0];
+        if (!firstArg) {
+            return {};
+        }
+        if (firstArg.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+            const properties = firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperties();
+            for (const prop of properties) {
+                if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
+                    const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
+                    const propertyName = propAssignment.getName();
+                    const initializer = propAssignment.getInitializer();
+                    if (propertyName === 'generateSendable' && initializer) {
+                        if (initializer.getKind() === ts_morph_1.SyntaxKind.TrueKeyword) {
+                            generateSendable = true;
+                        }
+                        else if (initializer.getKind() === ts_morph_1.SyntaxKind.FalseKeyword) {
+                            generateSendable = false;
+                        }
+                    }
+                    else if (propertyName === 'with' && initializer) {
+                        _with = initializer.getText();
+                    }
+                    else if (propertyName === 'deserializationMode' && initializer) {
+                        const modeText = initializer.getText().replace(/['"]/g, '');
+                        if (modeText === Types_1.DeserializationMode.PERFORMANCE || modeText === Types_1.DeserializationMode.STRICT) {
+                            deserializationMode = modeText;
+                        }
+                    }
+                }
+            }
+        }
+        return { with: _with, generateSendable, deserializationMode };
+    }
+    static parseSerialNameOptions(decorator) {
+        if (!decorator) {
+            return undefined;
+        }
+        const args = decorator.getArguments();
+        if (args.length === 0) {
+            return undefined;
+        }
+        const firstArg = args[0];
+        if (firstArg.getKind() === ts_morph_1.SyntaxKind.ObjectLiteralExpression) {
+            const properties = firstArg.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression).getProperties();
+            for (const prop of properties) {
+                if (prop.getKind() === ts_morph_1.SyntaxKind.PropertyAssignment) {
+                    const propAssignment = prop.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAssignment);
+                    const name = propAssignment.getName();
+                    if (name === 'name') {
+                        const initializer = propAssignment.getInitializer();
+                        if (initializer && initializer.getKind() === ts_morph_1.SyntaxKind.StringLiteral) {
+                            const stringLiteral = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.StringLiteral);
+                            return stringLiteral.getLiteralValue();
+                        }
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    static analyzeOwnProperties(cls, constructorParams, genericParameters) {
+        const ownProperties = [];
+        const props = cls.getProperties();
+        for (const prop of props) {
+            const propertyAnalysis = this.createPropertyAnalysis(prop, constructorParams, genericParameters);
+            if (propertyAnalysis.type.kind === Types_1.PropertyKind.UNKNOWN) {
+                const hasTransient = propertyAnalysis.decorators?.isTransient;
+                const hasCustomSerializer = !!propertyAnalysis.decorators?.with;
+                if (!hasTransient && !hasCustomSerializer) {
+                    if (prop instanceof ts_morph_1.PropertyDeclaration) {
+                        throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (类: ${cls.getName()})。\n` +
+                            `请选择以下任一解决方案：\n` +
+                            `  1. 添加 @Transient() 跳过序列化（属性仍会参与 Sendable 转换和对象拷贝）：\n` +
+                            `     @Transient()\n` +
+                            `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};\n\n` +
+                            `  2. 添加 @Serializable({with: CustomSerializer}) 指定自定义序列化器：\n` +
+                            `     @Serializable({with: DateSerializer.INSTANCE})\n` +
+                            `     ${propertyAnalysis.name}: ${propertyAnalysis.type.sourceText};`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+                    }
+                    else {
+                        throw new CustomError_1.CustomError(`不支持的类型 '${propertyAnalysis.type.sourceText}' 用于属性 '${propertyAnalysis.name}' (接口: ${cls.getName()})`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+                    }
+                }
+            }
+            ownProperties.push(propertyAnalysis);
+        }
+        return ownProperties;
+    }
+    static classifyProperties(ownProperties, inheritance, currentClassGenericParams = []) {
+        if (!inheritance.isInherited || !inheritance.baseClassAnalysis) {
+            return {
+                inheritedProperties: [],
+                overriddenProperties: [],
+                properties: [...ownProperties]
+            };
+        }
+        const allAncestorProperties = this.collectAllAncestorProperties(inheritance.baseClassAnalysis, inheritance.genericTypeArguments || [], currentClassGenericParams);
+        const ownPropertyNames = new Set(ownProperties.map((prop) => prop.name));
+        const inheritedProperties = [];
+        for (const ancestorProp of allAncestorProperties) {
+            if (!ownPropertyNames.has(ancestorProp.name)) {
+                inheritedProperties.push(ancestorProp);
+            }
+        }
+        const overriddenProperties = ownProperties.filter((prop) => allAncestorProperties.some((ancestorProp) => ancestorProp.name === prop.name));
+        const properties = [...inheritedProperties, ...ownProperties];
+        return {
+            inheritedProperties,
+            overriddenProperties,
+            properties
+        };
+    }
+    static collectAllAncestorProperties(classAnalysis, childGenericArguments = [], currentClassGenericParams = []) {
+        const allProperties = [];
+        const parentGenericParams = classAnalysis.generics.parameters || [];
+        const genericMapping = GenericTypeSubstitutionUtil_1.GenericTypeSubstitutionUtil.buildGenericMapping(parentGenericParams, childGenericArguments);
+        const substitutedProperties = classAnalysis.ownProperties.map((property) => GenericTypeSubstitutionUtil_1.GenericTypeSubstitutionUtil.substitutePropertyType(property, genericMapping, currentClassGenericParams));
+        allProperties.push(...substitutedProperties);
+        if (classAnalysis.inheritance.isInherited && classAnalysis.inheritance.baseClassAnalysis) {
+            const ancestorProperties = this.collectAllAncestorProperties(classAnalysis.inheritance.baseClassAnalysis, classAnalysis.inheritance.genericTypeArguments || [], currentClassGenericParams);
+            allProperties.push(...ancestorProperties);
+        }
+        return allProperties;
+    }
+    static extractConstructorParams(constructor) {
+        const parameters = [];
+        for (const param of constructor.getParameters()) {
+            parameters.push({
+                name: param.getName(),
+                type: param.getTypeNodeOrThrow().getText(),
+                isOptional: param.hasQuestionToken(),
+                defaultValue: param.hasInitializer() ? param.getInitializerOrThrow().getText() : undefined
+            });
+        }
+        return parameters;
+    }
+    static createPropertyAnalysis(prop, constructorParams, genericParameters) {
+        const name = prop.getName();
+        let typeNode = prop.getTypeNode();
+        if (!typeNode) {
+            typeNode = this.analyzePropertyType(prop);
+        }
+        if (!typeNode) {
+            throw new CustomError_1.CustomError(`无法分析属性 '${name}' 的类型。请检查属性声明。`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+        }
+        const defaultValue = prop instanceof ts_morph_1.PropertyDeclaration ? this.analyzeDefaultValue(prop, constructorParams) : undefined;
+        const decorators = prop instanceof ts_morph_1.PropertyDeclaration ? this.analyzePropertyDecorators(prop) : undefined;
+        const type = handlers_1.TypeHandlerRegistry.getInstance().parseType(typeNode, { genericParams: genericParameters, depth: 0 });
+        type.isOptional = prop.hasQuestionToken();
+        const constructorParam = constructorParams.find((param) => param.name === name);
+        const isParamOptional = constructorParam
+            ? constructorParam.isOptional ||
+                constructorParam.defaultValue !== undefined ||
+                this.hasUndefinedInUnion(constructorParam.type)
+            : true;
+        let isMust;
+        if (constructorParam) {
+            isMust = !isParamOptional;
+        }
+        else {
+            isMust = decorators?.isRequired || !this.isOptional(prop, defaultValue, type);
+        }
+        if (decorators?.isTransient && constructorParam && !isParamOptional) {
+            throw new CustomError_1.CustomError(`@Transient 属性 '${name}' 的构造函数参数必须是可选的或有默认值。\n` +
+                `因为 @Transient 属性不参与序列化，反序列化时无法从外部数据获取值。\n` +
+                `请修改构造函数参数为以下任一形式：\n` +
+                `  1. 可选参数: constructor(..., ${name}?: ${constructorParam.type})\n` +
+                `  2. 带默认值: constructor(..., ${name}: ${constructorParam.type} = defaultValue)`, CustomError_1.ErrorCodes.TRANSIENT_ATTR_OPTIONAL);
+        }
+        return {
+            name,
+            defaultValue,
+            decorators,
+            type,
+            isMust
+        };
+    }
+    static analyzePropertyType(prop) {
+        const name = prop.getName();
+        let typeNode = prop.getTypeNode();
+        if (typeNode) {
+            return typeNode;
+        }
+        Logger_1.Logger.warn(`无法获取属性${name}的类型，使用typeChecker方式获取类型`);
+        let type = TsMorphUtil_1.TsMorphUtil.getTypeChecker().getTypeAtLocation(prop);
+        let typeText = type.getText();
+        Logger_1.Logger.warn(`typeChecker方式获取类型: ${typeText} `);
+        typeText = this.simplifyImportType(typeText);
+        if (typeText === 'any') {
+            const result = this.getTypeFromInitializer(prop, name);
+            if (result) {
+                return result;
+            }
+        }
+        if (typeText === 'any') {
+            throw new CustomError_1.CustomError(`无法获取属性${name}的类型，需要显示声明`, CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+        }
+        Logger_1.Logger.info(`使用typeChecker方式获取类型成功: ${typeText}`);
+        prop.setType(typeText);
+        return prop.getTypeNode();
+    }
+    static simplifyImportType(typeText) {
+        const importPattern = /import\s*\(\s*['"][^'"]*['"]\s*\)\.(.+)/;
+        const match = typeText.match(importPattern);
+        if (match) {
+            return match[1];
+        }
+        return typeText;
+    }
+    static getTypeFromInitializer(prop, propName) {
+        const initializer = prop.getInitializer();
+        if (!initializer) {
+            return undefined;
+        }
+        Logger_1.Logger.warn(`无法获取属性${propName}的类型，使用初始化器获取类型: ${initializer.getText()}`);
+        const initializerType = TsMorphUtil_1.TsMorphUtil.getTypeChecker().getTypeAtLocation(initializer);
+        let typeText = initializerType.getText();
+        Logger_1.Logger.warn(`使用初始化器获取类型: ${typeText}`);
+        if (typeText !== 'any') {
+            prop.setType(typeText);
+            return prop.getTypeNode();
+        }
+        if (initializer.getKind() !== ts_morph_1.SyntaxKind.NewExpression) {
+            return undefined;
+        }
+        const newExpression = initializer;
+        const expression = newExpression.getExpression();
+        if (!expression) {
+            return undefined;
+        }
+        const exprText = expression.getText();
+        const supportedTypes = ['Map', 'Set', 'WeakMap', 'WeakSet', 'Array', 'Object', 'ArrayList', 'HashMap', 'HashSet', 'LinkedList', 'Decimal', 'List'];
+        if (!supportedTypes.includes(exprText)) {
+            return undefined;
+        }
+        const typeArgs = newExpression.getTypeArguments();
+        if (typeArgs.length > 0) {
+            typeText = `${exprText}<${typeArgs.map(arg => arg.getText()).join(', ')}>`;
+        }
+        else {
+            typeText = exprText;
+        }
+        prop.setType(typeText);
+        return prop.getTypeNode();
+    }
+    static isOptional(node, defaultValue, type) {
+        if (node.hasQuestionToken()) {
+            return true;
+        }
+        if (defaultValue !== undefined) {
+            return true;
+        }
+        if (type.kind === Types_1.PropertyKind.UNDEFINED || type.kind === Types_1.PropertyKind.OPTIONAL) {
+            return true;
+        }
+        if (type.kind === Types_1.PropertyKind.UNION &&
+            type.unionDetails &&
+            type.unionDetails.some((member) => member.kind === Types_1.PropertyKind.UNDEFINED)) {
+            return true;
+        }
+        return false;
+    }
+    static analyzeDefaultValue(prop, constructorParams) {
+        const param = constructorParams.find((item) => item.name === prop.getName());
+        if (param && param.defaultValue) {
+            return param.defaultValue;
+        }
+        if (prop.hasInitializer()) {
+            return prop.getInitializerOrThrow().getText();
+        }
+        return undefined;
+    }
+    static hasUndefinedInUnion(typeText) {
+        const normalized = typeText.replace(/\s/g, '');
+        if (normalized === 'undefined') {
+            return true;
+        }
+        const parts = this.splitUnionType(normalized);
+        return parts.some(part => part === 'undefined');
+    }
+    static splitUnionType(typeText) {
+        const parts = [];
+        let current = '';
+        let depth = 0;
+        for (let i = 0; i < typeText.length; i++) {
+            const char = typeText[i];
+            if (char === '<' || char === '[' || char === '(') {
+                depth++;
+                current += char;
+            }
+            else if (char === '>' || char === ']' || char === ')') {
+                depth--;
+                current += char;
+            }
+            else if (char === '|' && depth === 0) {
+                if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            parts.push(current);
+        }
+        return parts;
+    }
+    static analyzePropertyDecorators(prop) {
+        const decorators = prop.getDecorators();
+        let isRequired = false;
+        let isTransient = false;
+        let serialName;
+        let _with;
+        decorators.forEach((decorator) => {
+            const name = decorator.getName();
+            switch (name) {
+                case constants_1.DecoratorConstants.SERIAL_NAME:
+                    serialName = this.parseSerialNameOptions(decorator);
+                    break;
+                case constants_1.DecoratorConstants.REQUIRED:
+                    isRequired = true;
+                    break;
+                case constants_1.DecoratorConstants.TRANSIENT:
+                    isTransient = true;
+                    break;
+                case constants_1.DecoratorConstants.SERIALIZABLE:
+                    _with = this.parseSerializableOptions(decorator).with;
+            }
+        });
+        if (isTransient) {
+            const conflictingDecorators = [];
+            if (isRequired) {
+                conflictingDecorators.push('@Required');
+            }
+            if (serialName) {
+                conflictingDecorators.push('@SerialName');
+            }
+            if (_with) {
+                conflictingDecorators.push('@Serializable');
+            }
+            if (conflictingDecorators.length > 0) {
+                throw new CustomError_1.CustomError(`属性 '${prop.getName()}' 的注解冲突：@Transient 与 ${conflictingDecorators.join(', ')} 不能同时使用。\n` +
+                    `@Transient 表示跳过序列化，与其他序列化配置注解互斥。\n` +
+                    `请移除 @Transient 或移除其他序列化注解。`, CustomError_1.ErrorCodes.ANNOTATION_CONFLICT);
+            }
+        }
+        return {
+            isRequired,
+            isTransient,
+            serialName,
+            with: _with
+        };
+    }
+}
+exports.ClassAnalyzer = ClassAnalyzer;

package/dist/core/analyzers/CustomTypeAnalyzer.d.ts

@@ -0,0 +1,21 @@
+import { ClassDeclaration, InterfaceDeclaration, SourceFile } from 'ts-morph';
+import { TypeDependency } from '..';
+export declare class CustomTypeAnalyzer {
+    private static readonly INSTANCE;
+    private searchCache;
+    private constructor();
+    static getInstance(): CustomTypeAnalyzer;
+    findDefinition(targetName: string, sourceFile: SourceFile): TypeDependency | null;
+    findClassDeclFromClassName(className: string, sourceFile: SourceFile): ClassDeclaration | InterfaceDeclaration | null;
+    clearCache(): void;
+    private findInCurrentFile;
+    private findInImports;
+    private findInCrossModule;
+    private searchInSourceFile;
+    private parseEnumDetails;
+    private parseClassDetails;
+    private parseInterfaceDetails;
+    private parseTypeAliasDetails;
+    private resolveImportPath;
+    private getOrLoadSourceFile;
+}