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

package/src/core/handlers/GenericHandler.ts

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeNode, SyntaxKind, TypeReferenceNode } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata } from '../Types';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { BaseTypeHandler } from './BaseTypeHandler';
+
+export class GenericHandler extends BaseTypeHandler implements ITypeHandler {
+  readonly name = 'GenericHandler';
+  readonly kind = PropertyKind.GENERIC;
+  readonly priority = 95; // 高优先级，在CustomClassHandler之前
+
+  // ==================== 阶段1: 类型识别 ====================
+
+  matches(typeNode: TypeNode, context: TypeContext): boolean {
+    // 必须是TypeReference且不能有泛型参数
+    if (typeNode.getKind() !== SyntaxKind.TypeReference) {
+      return false;
+    }
+
+    const typeRef = typeNode as TypeReferenceNode;
+    const typeName = typeRef.getTypeName().getText();
+
+    // 没有泛型参数（如果有泛型参数说明是泛型类，不是泛型参数）
+    if (typeRef.getTypeArguments().length > 0) {
+      return false;
+    }
+
+    return context.genericParams.includes(typeName);
+  }
+
+  // ==================== 阶段2: 类型解析 ====================
+
+  parse(typeNode: TypeNode): TypeStructure {
+    const typeRef = typeNode as TypeReferenceNode;
+    const typeName = typeRef.getTypeName().getText();
+
+    return {
+      kind: this.kind,
+      depth: 0,
+      sourceText: typeName,
+      args: [],
+      dependencies: []
+    };
+  }
+
+  // ==================== 阶段3: 序列化器配置 ====================
+
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+    const defaultInstantiation = this.generateInstantiation(structure);
+
+    return {
+      name: 'Serializer',
+      typeDeclaration: this.generateTypeDeclaration(structure),
+      instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+      encodeMethod: 'encodeSerializableElement',
+      decodeMethod: 'deserialize',
+      decoderType: `${structure.sourceText} | undefined`,
+      needsTypeAssertion: false
+    };
+  }
+
+  // ==================== 阶段4: 代码生成 ====================
+
+  generateInstantiation(structure: TypeStructure): string {
+    const typeName = structure.sourceText;
+    const lowerName = typeName.toLowerCase();
+    return `${lowerName}Serializer`; // 如 tSerializer
+  }
+
+  generateTypeDeclaration(structure: TypeStructure): string {
+    const typeName = structure.sourceText;
+    return `Serializer<${typeName}>`;
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+    const typeName = structure.sourceText;
+    return `'${typeName}'`; // 泛型参数的typeKey就是参数名
+  }
+
+  // ==================== Sendable转换 ====================
+
+  generateSendableTypeDeclaration(structure: TypeStructure): string {
+    // 泛型参数类型保持不变（泛型参数本身没有Sendable/非Sendable之分）
+    return structure.sourceText;
+  }
+
+  generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {
+
+    if (direction === ConversionDirection.TO_SENDABLE) {
+      return `((): ${structure.sourceText}${structure.isOptional ? ' | undefined' : ''} => {
+                const sendable: ESObject = ${sourceValue};
+                if (sendable.toSendable) {
+                  return sendable.toSendable();
+                } else {
+                  return ${sourceValue}${structure.isOptional ? '' : '!'};
+                }
+              })()`;
+    } else {
+      return `((): ${structure.sourceText}${structure.isOptional ? ' | undefined' : ''} => {
+                const origin: ESObject = ${sourceValue};
+                if (origin.toOrigin) {
+                  return origin.toOrigin();
+                } else {
+                  return ${sourceValue}${structure.isOptional ? '' : '!'};
+                }
+              })()`;
+    }
+  }
+}
+
+/**
+ * 工厂函数
+ */
+export function createGenericHandler(): ITypeHandler {
+  return new GenericHandler();
+}

package/src/core/handlers/HandlerBootstrap.ts

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeHandlerRegistry } from './TypeHandlerRegistry';
+import { createPrimitiveHandlers } from './PrimitiveHandler';
+import { createGenericContainerHandlers } from './GenericContainerHandler';
+import { createUnionTypeHandlers } from './UnionTypeHandler';
+import { createEnumHandler } from './EnumHandler';
+import { createGenericHandler } from './GenericHandler';
+import { createCustomClassHandler } from './CustomClassHandler';
+import { createTupleTypeHandlers } from './TupleHandler';
+import { createDateHandler } from './DateHandler';
+import { createDecimalHandler } from './DecimalHandler';
+
+/**
+ * 初始化类型处理器注册表
+ * 注册所有内置的类型处理器
+ */
+export function initializeTypeHandlers(): TypeHandlerRegistry {
+  const registry = TypeHandlerRegistry.getInstance();
+
+  // 1. 注册基础类型处理器（6个Handler）
+  registry.registerAll(createPrimitiveHandlers());
+
+  // 2. 注册泛型容器处理器（7个Handler）
+  registry.registerAll(createGenericContainerHandlers());
+
+  // 3. 注册联合类型处理器（3个Handler）
+  registry.registerAll(createUnionTypeHandlers());
+
+  // 4. 注册枚举类型处理器（1个Handler）
+  registry.register(createEnumHandler());
+
+  // 5. 注册泛型参数处理器（1个Handler，优先级95，高于CustomClass）
+  registry.register(createGenericHandler());
+
+  // 6. 注册自定义类处理器（1个Handler，fallback，优先级最低）
+  registry.register(createCustomClassHandler());
+
+  // 7. 注册元组处理器（1个Handler）
+  registry.register(createTupleTypeHandlers());
+
+  // 8. 注册日期处理器（1个Handler）
+  registry.register(createDateHandler());
+
+  // 9. 注册其他处理器（如DecimalHandler）
+  registry.registerAll([
+    createDecimalHandler()
+  ]);
+
+  return registry;
+}

package/src/core/handlers/ITypeHandler.ts

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeNode } from 'ts-morph';
+import { PropertyKind, SerializerMetadata, TypeStructure } from '..';
+
+/**
+ * 类型处理器接口
+ * 包含类型从识别到代码生成的完整生命周期
+ *
+ * 设计原则：
+ * - 一个Handler只处理一个PropertyKind
+ * - Handler包含完整生命周期：识别→解析→配置→生成→验证
+ */
+export interface ITypeHandler {
+  /** 处理器名称（用于日志和调试） */
+  readonly name: string;
+
+  /** 处理的类型种类（一个Handler只处理一个Kind） */
+  readonly kind: PropertyKind;
+
+  /** 优先级（用于类型匹配冲突解决，数值越大优先级越高） */
+  readonly priority: number;
+
+  /**
+   * 判断是否能处理当前类型
+   * @param typeNode AST节点
+   * @param context 上下文
+   */
+  matches(typeNode: TypeNode, context: TypeContext): boolean;
+
+  /**
+   * 解析类型节点为类型结构
+   * @param typeNode AST节点
+   * @param context 上下文
+   */
+  parse(typeNode: TypeNode, context: TypeContext): TypeStructure;
+
+  /**
+   * 获取序列化器元数据
+   * @param structure 类型结构（parse阶段的输出）
+   * @param withParam 是否有with参数
+   */
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+
+  /**
+   * 生成序列化器实例化代码
+   * @param structure 类型结构
+   */
+  generateInstantiation(structure: TypeStructure): string;
+
+  /**
+   * 生成类型声明
+   * @param structure 类型结构
+   */
+  generateTypeDeclaration(structure: TypeStructure): string;
+
+  /**
+   * 生成类型键表达式（用于with序列化器）
+   * @param structure 类型结构
+   */
+  generateTypeKey(structure: TypeStructure): string;
+
+  // ==================== Sendable转换相关 ====================
+
+  /**
+   * 生成Sendable类型声明
+   * 将普通类型转换为Sendable兼容的类型声明
+   *
+   * @param structure 类型结构
+   * @returns Sendable类型声明字符串
+   *
+   * @example
+   * // 基础类型：string -> string
+   * // 数组：Array<User> -> collections.Array<SendableUser>
+   * // 自定义类：User -> SendableUser（如果启用了generateSendable）
+   */
+  generateSendableTypeDeclaration(structure: TypeStructure): string;
+
+  /**
+   * 生成属性转换代码
+   * 用于生成toSendable/toOrigin方法中的属性转换逻辑
+   *
+   * @param structure 类型结构
+   * @param sourceValue 源值表达式（如"this.name"）
+   * @param direction 转换方向
+   * @returns 转换后的代码表达式
+   *
+   * @example
+   * // 数组转换（toSendable）：
+   * //   sourceValue="this.users" -> "new collections.Array(...this.users)"
+   * // 数组转换（toOrigin）：
+   * //   sourceValue="this.users" -> "new Array(...this.users)"
+   * // 基础类型：
+   * //   sourceValue="this.name" -> "this.name"（直接传递）
+   */
+  generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+}
+
+/**
+ * 类型上下文
+ * 贯穿整个处理流程
+ */
+export interface TypeContext {
+  /** 当前泛型参数 */
+  genericParams: string[];
+
+  /** 递归深度 */
+  depth: number;
+}
+
+/**
+ * 转换方向枚举
+ */
+export enum ConversionDirection {
+  /** 普通类型 -> Sendable类型 (toSendable) */
+  TO_SENDABLE = 'TO_SENDABLE',
+
+  /** Sendable类型 -> 普通类型 (toOrigin) */
+  TO_ORIGIN = 'TO_ORIGIN'
+}

package/src/core/handlers/PrimitiveHandler.ts

@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeNode, SyntaxKind } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata } from '../Types';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { ITypeHandler } from './ITypeHandler';
+
+abstract class PrimitiveHandler extends BaseTypeHandler implements ITypeHandler {
+  abstract readonly name: string;
+  abstract readonly kind: PropertyKind;
+  abstract readonly syntaxKind: SyntaxKind;
+
+  readonly priority = 100; // 基础类型高优先级
+
+  // ==================== 阶段1: 类型识别 ====================
+
+  matches(typeNode: TypeNode): boolean {
+    return typeNode.getKind() === this.syntaxKind;
+  }
+
+  // ==================== 阶段2: 类型解析 ====================
+
+  parse(typeNode: TypeNode): TypeStructure {
+    return {
+      kind: this.kind,
+      depth: 0,
+      sourceText: typeNode.getText(),
+      args: [], // 基础类型没有泛型参数
+      dependencies: [] // 基础类型不需要依赖其他类型
+    };
+  }
+
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+    const serializerName = this.getSerializerName();
+    const defaultInstantiation = this.generateInstantiation(); // 基础类型使用单例
+
+    return {
+      name: serializerName,
+      typeDeclaration: serializerName,
+      instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+      encodeMethod: `encode${this.getTypeName()}Element`,
+      decodeMethod: `decode${this.getTypeName()}`,
+      decoderType: `${structure.sourceText} | undefined`,
+      needsTypeAssertion: false
+    };
+  }
+
+  // ==================== 阶段4: 代码生成 ====================
+
+  generateInstantiation(): string {
+    const serializerName = this.getSerializerName();
+    return `${serializerName}.INSTANCE`;
+  }
+
+  generateTypeDeclaration(): string {
+    return this.getSerializerName();
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+    // 类型键为字符串形式
+    return `'${structure.sourceText}'`;
+  }
+
+  // ==================== Sendable转换 ====================
+
+  generateSendableTypeDeclaration(structure: TypeStructure): string {
+    // 基础类型在Sendable中不需要转换，直接返回原类型
+    return structure.sourceText;
+  }
+
+  generatePropertyConversion(_structure: TypeStructure, sourceValue: string): string {
+    // 基础类型在两个方向都直接传递，不需要转换
+    return sourceValue;
+  }
+}
+
+class StringHandler extends PrimitiveHandler {
+  readonly name = 'StringHandler';
+  readonly kind = PropertyKind.STRING;
+  readonly syntaxKind = SyntaxKind.StringKeyword;
+}
+
+class NumberHandler extends PrimitiveHandler {
+  readonly name = 'NumberHandler';
+  readonly kind = PropertyKind.NUMBER;
+  readonly syntaxKind = SyntaxKind.NumberKeyword;
+}
+
+class BooleanHandler extends PrimitiveHandler {
+  readonly name = 'BooleanHandler';
+  readonly kind = PropertyKind.BOOLEAN;
+  readonly syntaxKind = SyntaxKind.BooleanKeyword;
+}
+
+class BigintHandler extends PrimitiveHandler {
+  readonly name = 'BigintHandler';
+  readonly kind = PropertyKind.BIGINT;
+  readonly syntaxKind = SyntaxKind.BigIntKeyword;
+}
+
+class NullHandler extends PrimitiveHandler {
+  readonly name = 'NullHandler';
+  readonly kind = PropertyKind.NULL;
+  readonly syntaxKind = SyntaxKind.NullKeyword;
+
+  // Override matches: null类型的节点是LiteralType
+  matches(typeNode: TypeNode): boolean {
+    // 检查是否是字面量类型节点
+    if (typeNode.getKind() === SyntaxKind.LiteralType) {
+      const literal = typeNode.asKindOrThrow(SyntaxKind.LiteralType);
+      const literalValue = literal.getLiteral();
+      return literalValue.getKind() === SyntaxKind.NullKeyword;
+    }
+    // 兼容直接的NullKeyword节点
+    return typeNode.getKind() === SyntaxKind.NullKeyword;
+  }
+}
+
+class UndefinedHandler extends PrimitiveHandler {
+  readonly name = 'UndefinedHandler';
+  readonly kind = PropertyKind.UNDEFINED;
+  readonly syntaxKind = SyntaxKind.UndefinedKeyword;
+
+  // Override matches: undefined也可能以字面量形式出现
+  matches(typeNode: TypeNode): boolean {
+    // 检查是否是字面量类型节点
+    if (typeNode.getKind() === SyntaxKind.LiteralType) {
+      const literal = typeNode.asKindOrThrow(SyntaxKind.LiteralType);
+      const literalValue = literal.getLiteral();
+      return literalValue.getKind() === SyntaxKind.UndefinedKeyword;
+    }
+    // 兼容直接的UndefinedKeyword节点
+    return typeNode.getKind() === SyntaxKind.UndefinedKeyword;
+  }
+}
+
+export function createPrimitiveHandlers(): ITypeHandler[] {
+  return [
+    new StringHandler(),
+    new NumberHandler(),
+    new BooleanHandler(),
+    new BigintHandler(),
+    new NullHandler(),
+    new UndefinedHandler()
+  ];
+}

package/src/core/handlers/TupleHandler.ts

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TypeNode, SyntaxKind, TupleTypeNode } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata, TypeDependency } from '../Types';
+import { ConversionDirection, ITypeHandler, TypeContext } from './ITypeHandler';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { CustomError, ErrorCodes } from '../utils/CustomError';
+import { Logger } from '../logger/Logger';
+
+class TupleHandler extends BaseTypeHandler implements ITypeHandler {
+  readonly name = 'TupleHandler';
+  readonly kind = PropertyKind.TUPLE;
+  readonly priority = 95;
+
+  // ==================== 阶段1: 类型识别 ====================
+
+  matches(typeNode: TypeNode): boolean {
+    return typeNode.getKind() === SyntaxKind.TupleType;
+  }
+
+  // ==================== 阶段2: 类型解析 ====================
+
+  parse(typeNode: TypeNode, context: TypeContext): TypeStructure {
+    const tupleType = typeNode as TupleTypeNode;
+    const elementTypes = tupleType.getElements();
+
+    // 解析所有元素类型
+    const elements: TypeStructure[] = [];
+    const allDependencies: TypeDependency[] = [];
+    let maxDepth = 0;
+
+    for (const elementType of elementTypes) {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const elementStructure = TypeHandlerRegistry.getInstance().parseType(elementType, {
+        ...context,
+        depth: context.depth + 1
+      });
+
+      Logger.info(`tuple element type: ${elementType.getText()}, ${elementStructure.kind}`);
+      elements.push(elementStructure);
+      allDependencies.push(...elementStructure.dependencies);
+      maxDepth = Math.max(maxDepth, elementStructure.depth);
+    }
+
+    return {
+      kind: this.kind,
+      depth: maxDepth + 1,
+      sourceText: typeNode.getText(),
+      args: elements,
+      dependencies: allDependencies
+    };
+  }
+
+  // ==================== 阶段3: 序列化器配置 ====================
+
+  getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata {
+    const serializerName = this.getSerializerName();
+    const defaultInstantiation = this.generateInstantiation(structure);
+
+    return {
+      name: serializerName,
+      typeDeclaration: this.generateTypeDeclaration(structure),
+      instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+      encodeMethod: 'encodeSerializableElement',
+      decodeMethod: 'deserialize',
+      decoderType: `${structure.sourceText} | undefined`,
+      needsTypeAssertion: false
+    };
+  }
+
+  // ==================== 阶段4: 代码生成 ====================
+
+  generateInstantiation(structure: TypeStructure): string {
+
+    const serializerName = this.getSerializerName();
+
+    // 为每个元组元素生成序列化器
+    const elementSerializers = structure.args.map(element => {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(element.kind);
+      return handler.generateInstantiation(element);
+    });
+
+    return `new ${serializerName}([${elementSerializers.join(', ')}])`;
+  }
+
+  generateTypeDeclaration(structure: TypeStructure): string {
+    const serializerName = this.getSerializerName();
+    return `${serializerName}<${structure.sourceText}>`;
+  }
+
+  generateTypeKey(structure: TypeStructure): string {
+
+    const elementKeys = structure.args.map(element => {
+      const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+      const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(element.kind);
+      return handler.generateTypeKey(element);
+    });
+
+    return `[${elementKeys.join(', ')}]`;
+  }
+
+  protected getSerializerName(): string {
+    return 'TupleSerializer';
+  }
+
+  // ==================== Sendable转换 ====================
+
+  generateSendableTypeDeclaration(structure: TypeStructure): string {
+
+    const registry = require('./TypeHandlerRegistry').TypeHandlerRegistry.getInstance();
+    const sendableElementTypes = structure.args.map(element => {
+      const handler = registry.getHandlerForKind(element.kind);
+      if (!handler) {
+        throw new CustomError(`TupleHandler: no handler for element type: ${element.kind}`, ErrorCodes.HANDLER_NOT_FOUND);
+      }
+      return handler.generateSendableTypeDeclaration(element);
+    });
+
+    return `[${sendableElementTypes.join(', ')}]`;
+  }
+
+  generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string {
+    // 元组类型的转换无法在编译时确定具体类型，直接传递
+    // 实际转换由运行时的具体类型决定
+    return sourceValue;
+  }
+}
+
+export function createTupleTypeHandlers(): ITypeHandler {
+  return new TupleHandler();
+}