Implement basic decorator transformer infrastructure

Co-authored-by: samchon <[email protected]>

Author: Copilot

src/programmers/decorators/DecoratorAssertParametersProgrammer.ts

@@ -0,0 +1,50 @@
+import ts from "typescript";
+
+import { FunctionalAssertParametersProgrammer } from "../functional/FunctionalAssertParametersProgrammer";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+export namespace DecoratorAssertParametersProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    method: ts.MethodDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+
+  export const write = (props: IProps): ts.Expression => {
+    // Convert the method to a function declaration for the functional programmer
+    const functionDeclaration = createFunctionDeclarationFromMethod(props.method);
+    
+    // Reuse the functional programmer logic
+    return FunctionalAssertParametersProgrammer.write({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      declaration: functionDeclaration,
+      expression: props.expression,
+      init: props.init,
+    });
+  };
+
+  const createFunctionDeclarationFromMethod = (
+    method: ts.MethodDeclaration,
+  ): ts.FunctionDeclaration => {
+    // Create a synthetic function declaration that matches the method signature
+    return ts.factory.createFunctionDeclaration(
+      method.modifiers?.filter(ts.isModifier),
+      method.asteriskToken,
+      ts.factory.createIdentifier("__method"),
+      method.typeParameters,
+      method.parameters,
+      method.type,
+      method.body || ts.factory.createBlock([]),
+    );
+  };
+}

src/transformers/DecoratorTransformer.ts

@@ -1,14 +1,125 @@
 import ts from "typescript";
 
 import { ITypiaContext } from "./ITypiaContext";
+import { DecoratorGenericTransformer } from "./features/decorators/DecoratorGenericTransformer";
 
 export namespace DecoratorTransformer {
+  export interface IProps {
+    context: ITypiaContext;
+    method: ts.MethodDeclaration;
+  }
+
+  export const transformMethod = (props: IProps): ts.MethodDeclaration => {
+    const decorators = (props.method as any).decorators as ts.Decorator[] | undefined;
+    if (!decorators) {
+      return props.method;
+    }
+
+    let transformedMethod = props.method;
+
+    // Process each decorator
+    for (const decorator of decorators) {
+      const result = transform({
+        context: props.context,
+        decorator,
+        method: transformedMethod,
+      });
+      
+      if (result) {
+        transformedMethod = result;
+      }
+    }
+
+    return transformedMethod;
+  };
+
   export const transform = (props: {
     context: ITypiaContext;
     decorator: ts.Decorator;
-  }): ts.Decorator | null => {
-    // For now, just return the original decorator
-    // TODO: Implement decorator transformation logic
-    return props.decorator;
+    method: ts.MethodDeclaration;
+  }): ts.MethodDeclaration | null => {
+    // Check if this is a typia decorator
+    if (!ts.isCallExpression(props.decorator.expression)) {
+      return null;
+    }
+
+    const callExpression = props.decorator.expression;
+    if (!ts.isPropertyAccessExpression(callExpression.expression)) {
+      return null;
+    }
+
+    const propertyAccess = callExpression.expression;
+    if (!ts.isPropertyAccessExpression(propertyAccess.expression)) {
+      return null;
+    }
+
+    const typia = propertyAccess.expression;
+    if (!ts.isIdentifier(typia.expression) || typia.expression.text !== "typia") {
+      return null;
+    }
+
+    if (!ts.isIdentifier(typia.name) || typia.name.text !== "decorators") {
+      return null;
+    }
+
+    const decoratorName = propertyAccess.name.text;
+
+    // Map decorator names to configurations
+    const config = getDecoratorConfig(decoratorName);
+    if (!config) {
+      return null;
+    }
+
+    // Use the generic transformer
+    return DecoratorGenericTransformer.transform({
+      method: decoratorName,
+      config: config.config,
+      programmer: config.programmer,
+    })({
+      context: props.context,
+      decorator: props.decorator,
+      method: props.method,
+      expression: callExpression,
+    });
+  };
+
+  const getDecoratorConfig = (decoratorName: string) => {
+    // Import the programmers dynamically to avoid circular dependencies
+    const { DecoratorAssertParametersProgrammer } = require("../programmers/decorators/DecoratorAssertParametersProgrammer");
+    
+    const configs: Record<string, DecoratorGenericTransformer.ISpecification> = {
+      assert: {
+        method: "assert",
+        config: { equals: false },
+        programmer: DecoratorAssertParametersProgrammer.write,
+      },
+      assertEquals: {
+        method: "assertEquals", 
+        config: { equals: true },
+        programmer: DecoratorAssertParametersProgrammer.write,
+      },
+      is: {
+        method: "is",
+        config: { equals: false },
+        programmer: DecoratorAssertParametersProgrammer.write, // TODO: Create DecoratorIsParametersProgrammer
+      },
+      equals: {
+        method: "equals",
+        config: { equals: true },
+        programmer: DecoratorAssertParametersProgrammer.write, // TODO: Create DecoratorIsParametersProgrammer
+      },
+      validate: {
+        method: "validate",
+        config: { equals: false },
+        programmer: DecoratorAssertParametersProgrammer.write, // TODO: Create DecoratorValidateParametersProgrammer
+      },
+      validateEquals: {
+        method: "validateEquals",
+        config: { equals: true },
+        programmer: DecoratorAssertParametersProgrammer.write, // TODO: Create DecoratorValidateParametersProgrammer
+      },
+    };
+
+    return configs[decoratorName];
   };
 }

src/transformers/NodeTransformer.ts

@@ -1,17 +1,30 @@
 import ts from "typescript";
 
 import { CallExpressionTransformer } from "./CallExpressionTransformer";
+import { DecoratorTransformer } from "./DecoratorTransformer";
 import { ITypiaContext } from "./ITypiaContext";
 
 export namespace NodeTransformer {
   export const transform = (props: {
     context: ITypiaContext;
     node: ts.Node;
-  }): ts.Node | null =>
-    ts.isCallExpression(props.node) && props.node.parent
-      ? CallExpressionTransformer.transform({
-          context: props.context,
-          expression: props.node,
-        })
-      : props.node;
+  }): ts.Node | null => {
+    // Handle call expressions
+    if (ts.isCallExpression(props.node) && props.node.parent) {
+      return CallExpressionTransformer.transform({
+        context: props.context,
+        expression: props.node,
+      });
+    }
+    
+    // Handle method declarations with decorators
+    if (ts.isMethodDeclaration(props.node) && (props.node as any).decorators) {
+      return DecoratorTransformer.transformMethod({
+        context: props.context,
+        method: props.node,
+      });
+    }
+    
+    return props.node;
+  };
 }

src/transformers/features/decorators/DecoratorGenericTransformer.ts

@@ -6,27 +6,98 @@ export namespace DecoratorGenericTransformer {
   export interface IConfig {
     equals: boolean;
   }
+  
   export interface ISpecification {
     method: string;
     config: IConfig;
     programmer: (p: {
       context: ITypiaContext;
       modulo: ts.LeftHandSideExpression;
       expression: ts.Expression;
-      declaration: ts.MethodDeclaration;
+      method: ts.MethodDeclaration;
       config: IConfig;
       init?: ts.Expression;
     }) => ts.Expression;
   }
+  
   export const transform =
-    (_spec: ISpecification) =>
+    (spec: ISpecification) =>
     (props: {
       context: ITypiaContext;
       decorator: ts.Decorator;
+      method: ts.MethodDeclaration;
       expression: ts.CallExpression;
-    }): ts.Decorator | null => {
-      // This is a simplified placeholder - we need to transform the method
-      // that this decorator is applied to. For now, return the original decorator
-      return props.decorator;
+    }): ts.MethodDeclaration => {
+      // Get the error factory from decorator arguments (if provided)
+      const init = props.expression.arguments[0];
+
+      // Create a module reference for the generated code
+      const modulo = ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier("typia"),
+        "functional",
+      );
+
+      // Generate the wrapper function using the programmer
+      const wrapperExpression = spec.programmer({
+        context: props.context,
+        modulo,
+        expression: createMethodReference(props.method),
+        method: props.method,
+        config: spec.config,
+        init,
+      });
+
+      // Create the transformed method body that calls the wrapper
+      const transformedBody = createTransformedMethodBody({
+        method: props.method,
+        wrapperExpression,
+      });
+
+      // Return the method with transformed body and removed decorators
+      const decorators = (props.method as any).decorators as ts.Decorator[] | undefined;
+      const otherDecorators = decorators?.filter(
+        (d: ts.Decorator) => d !== props.decorator,
+      );
+
+      // Use object spread to create a new method with updated properties
+      const newMethod = Object.assign(Object.create(Object.getPrototypeOf(props.method)), props.method, {
+        decorators: otherDecorators,
+        body: transformedBody,
+      });
+
+      return newMethod as ts.MethodDeclaration;
     };
+
+  const createMethodReference = (method: ts.MethodDeclaration): ts.Expression => {
+    // Create a function expression that represents the original method
+    return ts.factory.createArrowFunction(
+      method.modifiers?.filter(ts.isModifier),
+      method.typeParameters,
+      method.parameters,
+      method.type,
+      ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      method.body || ts.factory.createBlock([]),
+    );
+  };
+
+  const createTransformedMethodBody = (props: {
+    method: ts.MethodDeclaration;
+    wrapperExpression: ts.Expression;
+  }): ts.Block => {
+    // Create parameter references for the wrapper call
+    const parameterNames = props.method.parameters.map((param) =>
+      ts.isIdentifier(param.name) ? param.name : ts.factory.createIdentifier("param"),
+    );
+
+    // Call the generated wrapper function with the parameters
+    const wrapperCall = ts.factory.createCallExpression(
+      props.wrapperExpression,
+      undefined,
+      parameterNames,
+    );
+
+    return ts.factory.createBlock([
+      ts.factory.createReturnStatement(wrapperCall),
+    ]);
+  };
 }

test/src/features/decorators/test_decorator_basic.ts

@@ -6,18 +6,45 @@ interface UserQuery {
 }
 
 class UserService {
-  // Test the decorator - for now it's just a stub
+  // Test the decorator - should validate parameters
   @typia.decorators.assertEquals()
   async findMany(query: UserQuery): Promise<UserQuery[]> {
-    // Implementation here
+    // This should be validated by the decorator
+    return [query];
+  }
+
+  // Test regular method for comparison
+  async findManyUnsafe(query: UserQuery): Promise<UserQuery[]> {
     return [query];
   }
 }
 
-export const test_decorator_basic = (): void => {
-  console.log("Decorators module is available");
+export const test_decorator_basic = async (): Promise<void> => {
+  console.log("Testing decorators module...");
 
   // Test that we can instantiate the class with decorator
   const service = new UserService();
   console.log("Service created successfully with decorator");
+
+  // Test valid input
+  const validQuery: UserQuery = { name: "John", age: 30 };
+  try {
+    const result = await service.findMany(validQuery);
+    console.log("Valid query succeeded:", result);
+  } catch (error) {
+    console.error("Valid query failed:", error);
+    throw error;
+  }
+
+  // Test invalid input should throw an error
+  const invalidQuery = { name: "John", age: "thirty" } as any;
+  try {
+    const result = await service.findMany(invalidQuery);
+    console.error("Invalid query should have failed but didn't:", result);
+    throw new Error("Invalid query should have thrown an error");
+  } catch (error) {
+    console.log("Invalid query correctly failed:", error.message);
+  }
+
+  console.log("All decorator tests passed!");
 };