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

package/dist/core/handlers/BaseTypeHandler.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTypeHandler = void 0;
+const Types_1 = require("../Types");
+class BaseTypeHandler {
+    getSerializerName() {
+        return `${this.getTypeName()}Serializer`;
+    }
+    getTypeName() {
+        return this.capitalize(this.kind);
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+    applyWithParam(withParam, defaultInstantiation, structure) {
+        if (!withParam) {
+            return defaultInstantiation;
+        }
+        if (this.containsGenericType(structure)) {
+            return `new WithEntrySerializer(${withParam}, [${this.generateTypeKeySerializers(structure)}])`;
+        }
+        else {
+            return `new WithEntryContextualSerializer(${withParam}, [${this.generateTypeKeys(structure)}])`;
+        }
+    }
+    containsGenericType(structure) {
+        if (structure.kind === Types_1.PropertyKind.GENERIC) {
+            return true;
+        }
+        if (structure.args && structure.args.length > 0) {
+            return structure.args.some(arg => this.containsGenericType(arg));
+        }
+        if (structure.unionDetails && structure.unionDetails.length > 0) {
+            return structure.unionDetails.some(member => this.containsGenericType(member));
+        }
+        return false;
+    }
+    generateTypeKeySerializers(structure) {
+        if (structure.args && structure.args.length > 0) {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            return structure.args.map((arg) => {
+                return TypeHandlerRegistry.getInstance().generateInstantiation(arg);
+            }).join(',\n');
+        }
+        return '';
+    }
+    generateTypeKeys(structure) {
+        if (structure.args && structure.args.length > 0) {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            return structure.args.map(arg => {
+                return TypeHandlerRegistry.getInstance().generateTypeKey(arg);
+            }).join(', ');
+        }
+        return '';
+    }
+}
+exports.BaseTypeHandler = BaseTypeHandler;

package/dist/core/handlers/CustomClassHandler.d.ts

@@ -0,0 +1,21 @@
+import { TypeNode } from 'ts-morph';
+import { BaseTypeHandler } from './BaseTypeHandler';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { PropertyKind, TypeStructure, SerializerMetadata } from '../Types';
+export declare class CustomClassHandler extends BaseTypeHandler implements ITypeHandler {
+    readonly name = "CustomClassHandler";
+    readonly kind = PropertyKind.OBJECT;
+    readonly priority = 10;
+    matches(typeNode: TypeNode): boolean;
+    parse(typeNode: TypeNode, context: TypeContext): TypeStructure;
+    private parseGenericArguments;
+    private handleMissingTypeDependency;
+    private handleTypeAlias;
+    getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+    generateInstantiation(structure: TypeStructure): string;
+    generateTypeDeclaration(structure: TypeStructure, withParam?: string): string;
+    generateTypeKey(structure: TypeStructure): string;
+    generateSendableTypeDeclaration(structure: TypeStructure): string;
+    generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+}
+export declare function createCustomClassHandler(): ITypeHandler;

package/dist/core/handlers/CustomClassHandler.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomClassHandler = void 0;
+exports.createCustomClassHandler = createCustomClassHandler;
+const ts_morph_1 = require("ts-morph");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+const ITypeHandler_1 = require("./ITypeHandler");
+const Types_1 = require("../Types");
+const CustomTypeAnalyzer_1 = require("../analyzers/CustomTypeAnalyzer");
+const ClassAnalyzer_1 = require("../analyzers/ClassAnalyzer");
+const CustomError_1 = require("../utils/CustomError");
+class CustomClassHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'CustomClassHandler';
+        this.kind = Types_1.PropertyKind.OBJECT;
+        this.priority = 10;
+    }
+    matches(typeNode) {
+        return typeNode.getKind() === ts_morph_1.SyntaxKind.TypeReference;
+    }
+    parse(typeNode, context) {
+        const typeRef = typeNode;
+        const customTypeName = typeRef.getTypeName().getText();
+        const typeArgs = typeRef.getTypeArguments();
+        const { dependencies, parsedArgs } = this.parseGenericArguments(typeArgs, context);
+        const typeDependency = CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance()
+            .findDefinition(customTypeName, typeRef.getSourceFile());
+        if (!typeDependency) {
+            return this.handleMissingTypeDependency(customTypeName);
+        }
+        if (typeDependency.typeKind === Types_1.TypeKind.TYPE) {
+            return this.handleTypeAlias(typeDependency, typeNode);
+        }
+        const maxArgDepth = parsedArgs.length > 0
+            ? Math.max(...parsedArgs.map(arg => arg.depth))
+            : 0;
+        if (typeDependency.typeKind === Types_1.TypeKind.INTERFACE) {
+            return {
+                kind: this.kind,
+                depth: parsedArgs.length > 0 ? 1 + maxArgDepth : 0,
+                sourceText: typeNode.getText(),
+                interfaceDetails: typeDependency.details,
+                args: parsedArgs,
+                dependencies: [typeDependency, ...dependencies]
+            };
+        }
+        else if (typeDependency.typeKind === Types_1.TypeKind.CLASS) {
+            return {
+                kind: this.kind,
+                depth: parsedArgs.length > 0 ? 1 + maxArgDepth : 0,
+                sourceText: typeNode.getText(),
+                classDetails: typeDependency.details,
+                args: parsedArgs,
+                dependencies: [typeDependency, ...dependencies]
+            };
+        }
+        else {
+            return {
+                kind: Types_1.PropertyKind.UNKNOWN,
+                depth: 0,
+                sourceText: customTypeName,
+                args: [],
+                dependencies: []
+            };
+        }
+    }
+    parseGenericArguments(typeArgs, context) {
+        const dependencies = [];
+        const parsedArgs = typeArgs.map(arg => {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            const argStructure = TypeHandlerRegistry.getInstance().parseType(arg, {
+                ...context,
+                depth: context.depth + 1
+            });
+            dependencies.push(...argStructure.dependencies);
+            return argStructure;
+        });
+        return { dependencies, parsedArgs };
+    }
+    handleMissingTypeDependency(customTypeName) {
+        return {
+            kind: Types_1.PropertyKind.UNKNOWN,
+            depth: 0,
+            sourceText: customTypeName,
+            args: [],
+            dependencies: []
+        };
+    }
+    handleTypeAlias(typeDependency, typeNode) {
+        const typeAliasDetails = typeDependency.details;
+        return {
+            ...typeAliasDetails.resolvedType,
+            sourceText: typeNode.getText(),
+            dependencies: [typeDependency, ...typeAliasDetails.resolvedType.dependencies]
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        const serializerName = `${structure.sourceText}Serializer`;
+        const defaultInstantiation = this.generateInstantiation(structure);
+        return {
+            name: serializerName,
+            typeDeclaration: this.generateTypeDeclaration(structure, withParam),
+            instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: `${structure.sourceText} | undefined`,
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure) {
+        if (structure.args && structure.args.length > 0) {
+            const typeName = structure.sourceText.slice(0, structure.sourceText.indexOf('<'));
+            const argsSerializers = structure.args.map(arg => {
+                const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+                const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(arg.kind);
+                return handler.generateInstantiation(arg);
+            });
+            return `new ${typeName}SerializerFactory().getSerializer(${argsSerializers.join(', ')})`;
+        }
+        const typeName = structure.sourceText;
+        return `${typeName}Serializer.INSTANCE`;
+    }
+    generateTypeDeclaration(structure, withParam) {
+        if (structure.args && structure.args.length > 0) {
+            return `Serializer<${structure.sourceText}>`;
+        }
+        if (withParam) {
+            return `Serializer<${structure.sourceText}>`;
+        }
+        return `${structure.sourceText}Serializer`;
+    }
+    generateTypeKey(structure) {
+        if (structure.args && structure.args.length > 0) {
+            const classKey = structure.sourceText.slice(0, structure.sourceText.indexOf('<'));
+            const genericKeys = structure.args.map(arg => {
+                const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+                const handler = TypeHandlerRegistry.getInstance().getHandlerForKind(arg.kind);
+                return handler.generateTypeKey(arg);
+            });
+            return `{ classKey: '${classKey}', genericTypes: [${genericKeys.join(', ')}] }`;
+        }
+        return structure.sourceText;
+    }
+    generateSendableTypeDeclaration(structure) {
+        const classDetails = structure.classDetails;
+        if (!classDetails || !classDetails.classDecl) {
+            return structure.sourceText;
+        }
+        const classAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
+        if (classAnalysis.decorators.serializable?.generateSendable) {
+            const typeName = structure.sourceText;
+            if (structure.args && structure.args.length > 0) {
+                const className = typeName.slice(0, typeName.indexOf('<'));
+                const genericPart = typeName.slice(typeName.indexOf('<'));
+                return `Sendable${className}${genericPart}`;
+            }
+            else {
+                return `Sendable${typeName}`;
+            }
+        }
+        if (classDetails.classDecl.getDecorator('Sendable')) {
+            return structure.sourceText;
+        }
+        else {
+            throw new CustomError_1.CustomError(`Type ${classDetails.classDecl.getName()} is not sendable.
+        please add @Sendable or @Serializable({ generateSendable: true })`, CustomError_1.ErrorCodes.NOT_SENDABLE);
+        }
+        return structure.sourceText;
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        const classDetails = structure.classDetails;
+        if (!classDetails || !classDetails.classDecl) {
+            return sourceValue;
+        }
+        const classAnalysis = ClassAnalyzer_1.ClassAnalyzer.analyzeClass(classDetails.classDecl);
+        if (classAnalysis.decorators.serializable?.generateSendable) {
+            if (direction === ITypeHandler_1.ConversionDirection.TO_SENDABLE) {
+                return `${sourceValue}.toSendable()`;
+            }
+            else {
+                return `${sourceValue}.toOrigin()`;
+            }
+        }
+        return sourceValue;
+    }
+}
+exports.CustomClassHandler = CustomClassHandler;
+function createCustomClassHandler() {
+    return new CustomClassHandler();
+}

package/dist/core/handlers/DateHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createDateHandler(): ITypeHandler;

package/dist/core/handlers/DateHandler.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDateHandler = createDateHandler;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+class DateHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'DateHandler';
+        this.kind = Types_1.PropertyKind.Date;
+        this.priority = 95;
+    }
+    matches(typeNode, context) {
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.TypeReference) {
+            const typeRef = typeNode;
+            const refName = typeRef.getTypeName().getText();
+            return refName === 'Date';
+        }
+        return false;
+    }
+    parse(typeNode, context) {
+        return {
+            kind: Types_1.PropertyKind.Date,
+            depth: 0,
+            sourceText: typeNode.getText(),
+            args: [],
+            dependencies: []
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        return {
+            name: 'DateSerializer',
+            typeDeclaration: 'DateSerializer',
+            instantiationTemplate: 'DateSerializer.INSTANCE',
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: 'Date | undefined',
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure) {
+        return 'DateSerializer.INSTANCE';
+    }
+    generateTypeDeclaration(structure) {
+        return 'DateSerializer';
+    }
+    generateTypeKey(structure) {
+        return structure.sourceText;
+    }
+    generateSendableTypeDeclaration(structure) {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        return sourceValue;
+    }
+}
+function createDateHandler() {
+    return new DateHandler();
+}

package/dist/core/handlers/DecimalHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createDecimalHandler(): ITypeHandler;

package/dist/core/handlers/DecimalHandler.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecimalHandler = createDecimalHandler;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+class DecimalHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'DecimalHandler';
+        this.kind = Types_1.PropertyKind.Decimal;
+        this.priority = 95;
+    }
+    matches(typeNode, context) {
+        if (typeNode.getKind() === ts_morph_1.SyntaxKind.TypeReference) {
+            const typeRef = typeNode;
+            const refName = typeRef.getTypeName().getText();
+            return refName === 'Decimal';
+        }
+        return false;
+    }
+    parse(typeNode, context) {
+        return {
+            kind: Types_1.PropertyKind.Decimal,
+            depth: 0,
+            sourceText: typeNode.getText(),
+            args: [],
+            dependencies: []
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        return {
+            name: 'DecimalSerializer',
+            typeDeclaration: 'DecimalSerializer',
+            instantiationTemplate: 'DecimalSerializer.INSTANCE',
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: 'Decimal | undefined',
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure) {
+        return 'DecimalSerializer.INSTANCE';
+    }
+    generateTypeDeclaration(structure) {
+        return 'DecimalSerializer';
+    }
+    generateTypeKey(structure) {
+        return structure.sourceText;
+    }
+    generateSendableTypeDeclaration(structure) {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        return sourceValue;
+    }
+}
+function createDecimalHandler() {
+    return new DecimalHandler();
+}

package/dist/core/handlers/EnumHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createEnumHandler(): ITypeHandler;

package/dist/core/handlers/EnumHandler.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEnumHandler = createEnumHandler;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const CustomTypeAnalyzer_1 = require("../analyzers/CustomTypeAnalyzer");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+const CustomError_1 = require("../utils/CustomError");
+class EnumHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'EnumHandler';
+        this.kind = Types_1.PropertyKind.ENUM;
+        this.priority = 95;
+    }
+    matches(typeNode) {
+        if (typeNode.getKind() !== ts_morph_1.SyntaxKind.TypeReference) {
+            return false;
+        }
+        const typeRef = typeNode;
+        const customTypeName = typeRef.getTypeName().getText();
+        const typeDependency = CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance()
+            .findDefinition(customTypeName, typeRef.getSourceFile());
+        return typeDependency?.typeKind === Types_1.TypeKind.ENUM;
+    }
+    parse(typeNode) {
+        const typeRef = typeNode;
+        const enumName = typeRef.getTypeName().getText();
+        const typeDependency = CustomTypeAnalyzer_1.CustomTypeAnalyzer.getInstance()
+            .findDefinition(enumName, typeRef.getSourceFile());
+        if (!typeDependency || typeDependency.typeKind !== Types_1.TypeKind.ENUM) {
+            throw new CustomError_1.CustomError(`Not an enum type: ${enumName}`, CustomError_1.ErrorCodes.IS_NOT_ENUM);
+        }
+        const enumDetails = typeDependency.details;
+        return {
+            kind: Types_1.PropertyKind.ENUM,
+            depth: 0,
+            sourceText: enumName,
+            args: [],
+            enumDetails: enumDetails,
+            dependencies: [typeDependency]
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        if (!structure.enumDetails) {
+            throw new CustomError_1.CustomError('EnumHandler: missing enumDetails in structure', CustomError_1.ErrorCodes.ENUM_STRUCTURE_NOT_FOUND);
+        }
+        const enumName = structure.sourceText;
+        const valueType = structure.enumDetails.valueType;
+        const defaultInstantiation = this.generateInstantiation(structure);
+        return {
+            name: 'EnumSerializer',
+            typeDeclaration: this.generateTypeDeclaration(structure),
+            instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: `${enumName} | undefined`,
+            needsTypeAssertion: valueType === 'string'
+        };
+    }
+    generateInstantiation(structure) {
+        if (!structure.enumDetails) {
+            throw new CustomError_1.CustomError('EnumHandler: missing enumDetails for instantiation', CustomError_1.ErrorCodes.ENUM_STRUCTURE_NOT_FOUND);
+        }
+        const enumType = structure.enumDetails.valueType;
+        const enumName = `'${structure.sourceText}'`;
+        const enumMembers = structure.enumDetails.members.map(member => `['${member.name}', ${member.literalValue}]`).join(', ');
+        return `new EnumSerializer<${enumType}>(${enumName}, [${enumMembers}])`;
+    }
+    generateTypeDeclaration(structure) {
+        if (!structure.enumDetails) {
+            throw new CustomError_1.CustomError('EnumHandler: missing enumDetails for type declaration', CustomError_1.ErrorCodes.ENUM_STRUCTURE_NOT_FOUND);
+        }
+        const valueType = structure.enumDetails.valueType;
+        return `EnumSerializer<${valueType}>`;
+    }
+    generateTypeKey(structure) {
+        return structure.sourceText;
+    }
+    generateSendableTypeDeclaration(structure) {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(_structure, sourceValue) {
+        return sourceValue;
+    }
+}
+function createEnumHandler() {
+    return new EnumHandler();
+}

package/dist/core/handlers/GenericContainerHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createGenericContainerHandlers(): ITypeHandler[];