@nestia/core 3.17.0 → 4.0.0-dev.20241010

package/src/transformers/NodeTransformer.ts

@@ -1,16 +1,23 @@
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { MethodTransformer } from "./MethodTransformer";
 import { ParameterTransformer } from "./ParameterTransformer";
 
 export namespace NodeTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (node: ts.Node): ts.Node =>
-      ts.isMethodDeclaration(node)
-        ? MethodTransformer.transform(project)(node)
-        : ts.isParameter(node)
-          ? ParameterTransformer.transform(project)(node)
-          : node;
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.isMethodDeclaration(props.node)
+      ? MethodTransformer.transform({
+          context: props.context,
+          method: props.node,
+        })
+      : ts.isParameter(props.node)
+        ? ParameterTransformer.transform({
+            context: props.context,
+            param: props.node,
+          })
+        : props.node;
 }

package/src/transformers/ParameterDecoratorTransformer.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { PlainBodyProgrammer } from "../programmers/PlainBodyProgrammer";
 import { TypedBodyProgrammer } from "../programmers/TypedBodyProgrammer";
 import { TypedFormDataBodyProgrammer } from "../programmers/TypedFormDataBodyProgrammer";
@@ -11,105 +11,114 @@ import { TypedQueryBodyProgrammer } from "../programmers/TypedQueryBodyProgramme
 import { TypedQueryProgrammer } from "../programmers/TypedQueryProgrammer";
 
 export namespace ParameterDecoratorTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (type: ts.Type) =>
-    (decorator: ts.Decorator): ts.Decorator => {
-      //----
-      // VALIDATIONS
-      //----
-      // CHECK DECORATOR
-      if (!ts.isCallExpression(decorator.expression)) return decorator;
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    type: ts.Type;
+    decorator: ts.Decorator;
+  }): ts.Decorator => {
+    //----
+    // VALIDATIONS
+    //----
+    // CHECK DECORATOR
+    if (!ts.isCallExpression(props.decorator.expression))
+      return props.decorator;
 
-      // SIGNATURE DECLARATION
-      const declaration: ts.Declaration | undefined =
-        project.checker.getResolvedSignature(decorator.expression)?.declaration;
-      if (declaration === undefined) return decorator;
+    // SIGNATURE DECLARATION
+    const declaration: ts.Declaration | undefined =
+      props.context.checker.getResolvedSignature(
+        props.decorator.expression,
+      )?.declaration;
+    if (declaration === undefined) return props.decorator;
 
-      // FILE PATH
-      const file: string = path.resolve(declaration.getSourceFile().fileName);
-      if (file.indexOf(LIB_PATH) === -1 && file.indexOf(SRC_PATH) === -1)
-        return decorator;
+    // FILE PATH
+    const file: string = path.resolve(declaration.getSourceFile().fileName);
+    if (file.indexOf(LIB_PATH) === -1 && file.indexOf(SRC_PATH) === -1)
+      return props.decorator;
 
-      //----
-      // TRANSFORMATION
-      //----
-      // FIND PROGRAMMER
-      const programmer: Programmer | undefined =
-        FUNCTORS[
-          getName(project.checker.getTypeAtLocation(declaration).symbol)
-        ];
-      if (programmer === undefined) return decorator;
+    //----
+    // TRANSFORMATION
+    //----
+    // FIND PROGRAMMER
+    const programmer: Programmer | undefined =
+      FUNCTORS[
+        getName(props.context.checker.getTypeAtLocation(declaration).symbol)
+      ];
+    if (programmer === undefined) return props.decorator;
 
-      // GET TYPE INFO
-      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
-        type,
-        undefined,
-        undefined,
-      );
-      if (typeNode === undefined) return decorator;
+    // GET TYPE INFO
+    const typeNode: ts.TypeNode | undefined =
+      props.context.checker.typeToTypeNode(props.type, undefined, undefined);
+    if (typeNode === undefined) return props.decorator;
 
-      // DO TRANSFORM
-      return ts.factory.createDecorator(
-        ts.factory.updateCallExpression(
-          decorator.expression,
-          decorator.expression.expression,
-          decorator.expression.typeArguments,
-          programmer(project)(decorator.expression.expression)(
-            decorator.expression.arguments,
-          )(type),
-        ),
-      );
-    };
+    // DO TRANSFORM
+    return ts.factory.createDecorator(
+      ts.factory.updateCallExpression(
+        props.decorator.expression,
+        props.decorator.expression.expression,
+        props.decorator.expression.typeArguments,
+        programmer({
+          context: props.context,
+          modulo: props.decorator.expression.expression,
+          arguments: props.decorator.expression.arguments,
+          type: props.type,
+        }),
+      ),
+    );
+  };
 }
 
-type Programmer = (
-  project: INestiaTransformProject,
-) => (
-  modulo: ts.LeftHandSideExpression,
-) => (
-  parameters: readonly ts.Expression[],
-) => (type: ts.Type) => readonly ts.Expression[];
+type Programmer = (props: {
+  context: INestiaTransformContext;
+  modulo: ts.LeftHandSideExpression;
+  arguments: readonly ts.Expression[];
+  type: ts.Type;
+}) => readonly ts.Expression[];
 
 const FUNCTORS: Record<string, Programmer> = {
-  EncryptedBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
-  TypedBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
-  TypedHeaders: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedHeadersProgrammer.generate(project)(modulo)(type)],
-  TypedParam: (project) => TypedParamProgrammer.generate(project),
-  TypedQuery: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedQueryProgrammer.generate(project)(modulo)(type)],
-  "TypedQuery.Body": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedQueryBodyProgrammer.generate(project)(modulo)(type)],
-  "TypedFormData.Body": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedFormDataBodyProgrammer.generate(project)(modulo)(type)],
-  PlainBody: (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [PlainBodyProgrammer.generate(project)(modulo)(type)],
-  "WebSocketRoute.Header": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedBodyProgrammer.generate(project)(modulo)(type)],
-  "WebSocketRoute.Param": (project) => TypedParamProgrammer.generate(project),
-  "WebSocketRoute.Query": (project) => (modulo) => (parameters) => (type) =>
-    parameters.length
-      ? parameters
-      : [TypedQueryProgrammer.generate(project)(modulo)(type)],
+  EncryptedBody: (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedBodyProgrammer.generate(props)],
+  TypedBody: (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedBodyProgrammer.generate(props)],
+  TypedHeaders: (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedHeadersProgrammer.generate(props)],
+  TypedParam: (props) =>
+    props.arguments.length !== 1
+      ? props.arguments
+      : TypedParamProgrammer.generate(props),
+  TypedQuery: (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedQueryProgrammer.generate(props)],
+  "TypedQuery.Body": (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedQueryBodyProgrammer.generate(props)],
+  "TypedFormData.Body": (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedFormDataBodyProgrammer.generate(props)],
+  PlainBody: (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [PlainBodyProgrammer.generate(props)],
+  "WebSocketRoute.Header": (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedBodyProgrammer.generate(props)],
+  "WebSocketRoute.Param": (props) =>
+    props.arguments.length !== 1
+      ? props.arguments
+      : TypedParamProgrammer.generate(props),
+  "WebSocketRoute.Query": (props) =>
+    props.arguments.length
+      ? props.arguments
+      : [TypedQueryProgrammer.generate(props)],
 };
 
 const LIB_PATH = path.join("@nestia", "core", "lib", "decorators");

package/src/transformers/ParameterTransformer.ts

@@ -1,48 +1,57 @@
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { ParameterDecoratorTransformer } from "./ParameterDecoratorTransformer";
 
 export namespace ParameterTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (param: ts.ParameterDeclaration): ts.ParameterDeclaration => {
-      // CHECK DECORATOR
-      const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-        ? ts.getDecorators(param)
-        : (param as any).decorators;
-      if (!decorators?.length) return param;
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    param: ts.ParameterDeclaration;
+  }): ts.ParameterDeclaration => {
+    // CHECK DECORATOR
+    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+      ? ts.getDecorators(props.param)
+      : (props.param as any).decorators;
+    if (!decorators?.length) return props.param;
 
-      // GET TYPE INFO
-      const type: ts.Type = project.checker.getTypeAtLocation(param);
+    // GET TYPE INFO
+    const type: ts.Type = props.context.checker.getTypeAtLocation(props.param);
 
-      // WHEN LATEST TS VERSION
-      if (ts.getDecorators !== undefined)
-        return ts.factory.updateParameterDeclaration(
-          param,
-          (param.modifiers || []).map((mod) =>
-            ts.isDecorator(mod)
-              ? ParameterDecoratorTransformer.transform(project)(type)(mod)
-              : mod,
-          ),
-          param.dotDotDotToken,
-          param.name,
-          param.questionToken,
-          param.type,
-          param.initializer,
-        );
-      // eslint-disable-next-line
-      return (ts.factory.updateParameterDeclaration as any)(
-        param,
-        decorators.map((deco) =>
-          ParameterDecoratorTransformer.transform(project)(type)(deco),
+    // WHEN LATEST TS VERSION
+    if (ts.getDecorators !== undefined)
+      return ts.factory.updateParameterDeclaration(
+        props.param,
+        (props.param.modifiers || []).map((mod) =>
+          ts.isDecorator(mod)
+            ? ParameterDecoratorTransformer.transform({
+                context: props.context,
+                decorator: mod,
+                type,
+              })
+            : mod,
         ),
-        (param as any).modifiers,
-        param.dotDotDotToken,
-        param.name,
-        param.questionToken,
-        param.type,
-        param.initializer,
+        props.param.dotDotDotToken,
+        props.param.name,
+        props.param.questionToken,
+        props.param.type,
+        props.param.initializer,
       );
-    };
+    // eslint-disable-next-line
+    return (ts.factory.updateParameterDeclaration as any)(
+      props.param,
+      decorators.map((deco) =>
+        ParameterDecoratorTransformer.transform({
+          context: props.context,
+          decorator: deco,
+          type,
+        }),
+      ),
+      (props.param as any).modifiers,
+      props.param.dotDotDotToken,
+      props.param.name,
+      props.param.questionToken,
+      props.param.type,
+      props.param.initializer,
+    );
+  };
 }

package/src/transformers/TypedRouteTransformer.ts

@@ -1,70 +1,73 @@
 import path from "path";
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 import { TypedQueryRouteProgrammer } from "../programmers/TypedQueryRouteProgrammer";
 import { TypedRouteProgrammer } from "../programmers/TypedRouteProgrammer";
 
 export namespace TypedRouteTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (type: ts.Type) =>
-    (decorator: ts.Decorator): ts.Decorator => {
-      if (!ts.isCallExpression(decorator.expression)) return decorator;
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    decorator: ts.Decorator;
+    type: ts.Type;
+  }): ts.Decorator => {
+    if (!ts.isCallExpression(props.decorator.expression))
+      return props.decorator;
 
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return decorator;
+    // CHECK SIGNATURE
+    const signature: ts.Signature | undefined =
+      props.context.checker.getResolvedSignature(props.decorator.expression);
+    if (!signature || !signature.declaration) return props.decorator;
 
-      // CHECK TO BE TRANSFORMED
-      const modulo = (() => {
-        // CHECK FILENAME
-        const location: string = path.resolve(
-          signature.declaration.getSourceFile().fileName,
-        );
-        if (LIB_PATHS.every((str) => location.indexOf(str) === -1)) return null;
+    // CHECK TO BE TRANSFORMED
+    const modulo = (() => {
+      // CHECK FILENAME
+      const location: string = path.resolve(
+        signature.declaration.getSourceFile().fileName,
+      );
+      if (LIB_PATHS.every((str) => location.indexOf(str) === -1)) return null;
 
-        // CHECK DUPLICATE BOOSTER
-        if (decorator.expression.arguments.length >= 2) return false;
-        else if (decorator.expression.arguments.length === 1) {
-          const last: ts.Expression =
-            decorator.expression.arguments[
-              decorator.expression.arguments.length - 1
-            ];
-          const type: ts.Type = project.checker.getTypeAtLocation(last);
-          if (isObject(project.checker)(type)) return false;
-        }
-        return location.split(path.sep).at(-1)?.split(".")[0] === "TypedQuery"
-          ? "TypedQuery"
-          : "TypedRoute";
-      })();
-      if (modulo === null) return decorator;
+      // CHECK DUPLICATE BOOSTER
+      if (props.decorator.expression.arguments.length >= 2) return false;
+      else if (props.decorator.expression.arguments.length === 1) {
+        const last: ts.Expression =
+          props.decorator.expression.arguments[
+            props.decorator.expression.arguments.length - 1
+          ];
+        const type: ts.Type = props.context.checker.getTypeAtLocation(last);
+        if (isObject(props.context.checker)(type)) return false;
+      }
+      return location.split(path.sep).at(-1)?.split(".")[0] === "TypedQuery"
+        ? "TypedQuery"
+        : "TypedRoute";
+    })();
+    if (modulo === null) return props.decorator;
 
-      // CHECK TYPE NODE
-      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
-        type,
-        undefined,
-        undefined,
-      );
-      if (typeNode === undefined) return decorator;
+    // CHECK TYPE NODE
+    const typeNode: ts.TypeNode | undefined =
+      props.context.checker.typeToTypeNode(props.type, undefined, undefined);
+    if (typeNode === undefined) return props.decorator;
 
-      // DO TRANSFORM
-      return ts.factory.createDecorator(
-        ts.factory.updateCallExpression(
-          decorator.expression,
-          decorator.expression.expression,
-          decorator.expression.typeArguments,
-          [
-            ...decorator.expression.arguments,
-            (modulo === "TypedQuery"
-              ? TypedQueryRouteProgrammer
-              : TypedRouteProgrammer
-            ).generate(project)(decorator.expression.expression)(type),
-          ],
-        ),
-      );
-    };
+    // DO TRANSFORM
+    return ts.factory.createDecorator(
+      ts.factory.updateCallExpression(
+        props.decorator.expression,
+        props.decorator.expression.expression,
+        props.decorator.expression.typeArguments,
+        [
+          ...props.decorator.expression.arguments,
+          (modulo === "TypedQuery"
+            ? TypedQueryRouteProgrammer
+            : TypedRouteProgrammer
+          ).generate({
+            context: props.context,
+            type: props.type,
+            modulo: props.decorator.expression.expression,
+          }),
+        ],
+      ),
+    );
+  };
 
   const isObject =
     (checker: ts.TypeChecker) =>

package/src/transformers/WebSocketRouteTransformer.ts

@@ -1,94 +1,97 @@
 import path from "path";
 import ts from "typescript";
 
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
 
 export namespace WebSocketRouteTransformer {
-  export const validate =
-    (project: INestiaTransformProject) =>
-    (decorator: ts.Decorator, method: ts.MethodDeclaration): ts.Decorator => {
-      if (!ts.isCallExpression(decorator.expression)) return decorator;
+  export const validate = (props: {
+    context: INestiaTransformContext;
+    decorator: ts.Decorator;
+    method: ts.MethodDeclaration;
+  }): ts.Decorator => {
+    if (!ts.isCallExpression(props.decorator.expression))
+      return props.decorator;
 
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return decorator;
-      else if (isLocated(signature) === false) return decorator;
+    // CHECK SIGNATURE
+    const signature: ts.Signature | undefined =
+      props.context.checker.getResolvedSignature(props.decorator.expression);
+    if (!signature || !signature.declaration) return props.decorator;
+    else if (isLocated(signature) === false) return props.decorator;
 
-      const errors: ts.DiagnosticWithLocation[] = [];
-      let accepted: boolean = false;
+    const errors: ts.DiagnosticWithLocation[] = [];
+    let accepted: boolean = false;
 
-      const report = (node: ts.Node, message: string) => {
-        errors.push(
-          (ts as any).createDiagnosticForNode(node, {
-            category: ts.DiagnosticCategory.Error,
-            key: "nestia.core.WebSocketRoute",
-            code: "(nestia.core.WebSocketRoute)" as any,
-            message,
-          }),
+    const report = (node: ts.Node, message: string) => {
+      errors.push(
+        (ts as any).createDiagnosticForNode(node, {
+          category: ts.DiagnosticCategory.Error,
+          key: "nestia.core.WebSocketRoute",
+          code: "(nestia.core.WebSocketRoute)" as any,
+          message,
+        }),
+      );
+    };
+    props.method.parameters.forEach((param) => {
+      const paramDecos: ts.Decorator[] = (param.modifiers ?? []).filter((m) =>
+        ts.isDecorator(m),
+      ) as ts.Decorator[];
+      const category: string | null = (() => {
+        if (paramDecos.length !== 1) return null;
+        const decorator: ts.Decorator = paramDecos[0];
+        const signature: ts.Signature | undefined = ts.isCallExpression(
+          decorator.expression,
+        )
+          ? props.context.checker.getResolvedSignature(decorator.expression)
+          : undefined;
+        if (signature === undefined || isLocated(signature) === false)
+          return null;
+        return (
+          decorator.expression.getText().split(".").at(-1)?.split("(")[0] ??
+          null
+        );
+      })();
+      if (category === null)
+        report(
+          param,
+          `parameter ${JSON.stringify(param.name.getText())} is not decorated with nested function of WebSocketRoute module.`,
         );
-      };
-      method.parameters.forEach((param) => {
-        const paramDecos: ts.Decorator[] = (param.modifiers ?? []).filter((m) =>
-          ts.isDecorator(m),
-        ) as ts.Decorator[];
-        const category: string | null = (() => {
-          if (paramDecos.length !== 1) return null;
-          const decorator: ts.Decorator = paramDecos[0];
-          const signature: ts.Signature | undefined = ts.isCallExpression(
-            decorator.expression,
-          )
-            ? project.checker.getResolvedSignature(decorator.expression)
-            : undefined;
-          if (signature === undefined || isLocated(signature) === false)
-            return null;
-          return (
-            decorator.expression.getText().split(".").at(-1)?.split("(")[0] ??
-            null
+      else if (category === "Acceptor") {
+        accepted = true;
+        if (
+          param.type
+            ?.getText()
+            .split("<")[0]
+            ?.split(".")
+            .at(-1)
+            ?.startsWith("WebSocketAcceptor") !== true
+        )
+          report(
+            param,
+            `parameter ${JSON.stringify(param.name.getText())} must have WebSocketAcceptor<Header, Provider, Listener> type.`,
           );
-        })();
-        if (category === null)
+      } else if (category === "Driver") {
+        if (
+          param.type
+            ?.getText()
+            .split("<")[0]
+            ?.split(".")
+            .at(-1)
+            ?.startsWith("Driver") !== true
+        )
           report(
             param,
-            `parameter ${JSON.stringify(param.name.getText())} is not decorated with nested function of WebSocketRoute module.`,
+            `parameter ${JSON.stringify(param.name.getText())} must have Driver<Listener> type.`,
           );
-        else if (category === "Acceptor") {
-          accepted = true;
-          if (
-            param.type
-              ?.getText()
-              .split("<")[0]
-              ?.split(".")
-              .at(-1)
-              ?.startsWith("WebSocketAcceptor") !== true
-          )
-            report(
-              param,
-              `parameter ${JSON.stringify(param.name.getText())} must have WebSocketAcceptor<Header, Provider, Listener> type.`,
-            );
-        } else if (category === "Driver") {
-          if (
-            param.type
-              ?.getText()
-              .split("<")[0]
-              ?.split(".")
-              .at(-1)
-              ?.startsWith("Driver") !== true
-          )
-            report(
-              param,
-              `parameter ${JSON.stringify(param.name.getText())} must have Driver<Listener> type.`,
-            );
-        }
-      });
-      if (accepted === false)
-        report(
-          method,
-          `method ${JSON.stringify(method.name.getText())} must have at least one parameter decorated by @WebSocketRoute.Acceptor().`,
-        );
-      for (const e of errors) project.extras.addDiagnostic(e);
-      return decorator;
-    };
+      }
+    });
+    if (accepted === false)
+      report(
+        props.method,
+        `method ${JSON.stringify(props.method.name.getText())} must have at least one parameter decorated by @WebSocketRoute.Acceptor().`,
+      );
+    for (const e of errors) props.context.extras.addDiagnostic(e);
+    return props.decorator;
+  };
 }
 
 const isLocated = (signature: ts.Signature) => {