@nestia/core 3.1.0-dev.20240426 → 3.1.0-dev.20240430

package/src/transformers/FileTransformer.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-import { TransformerError } from "typia/lib/transformers/TransformerError";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { NodeTransformer } from "./NodeTransformer";
-
-export namespace FileTransformer {
-  export const transform =
-    (project: Omit<INestiaTransformProject, "context">) =>
-    (context: ts.TransformationContext) =>
-    (file: ts.SourceFile): ts.SourceFile =>
-      file.isDeclarationFile
-        ? file
-        : ts.visitEachChild(
-            file,
-            (node) =>
-              iterate_node({
-                ...project,
-                context,
-              })(context)(file)(node),
-            context,
-          );
-
-  const iterate_node =
-    (project: INestiaTransformProject) =>
-    (context: ts.TransformationContext) =>
-    (file: ts.SourceFile) =>
-    (node: ts.Node): ts.Node =>
-      ts.visitEachChild(
-        try_transform_node(project)(file)(node) ?? node,
-        (child) => iterate_node(project)(context)(file)(child),
-        context,
-      );
-
-  const try_transform_node =
-    (project: INestiaTransformProject) =>
-    (file: ts.SourceFile) =>
-    (node: ts.Node): ts.Node | null => {
-      try {
-        return NodeTransformer.transform(project)(node);
-      } catch (exp) {
-        // ONLY ACCEPT TRANSFORMER-ERROR
-        if (!isTransformerError(exp)) throw exp;
-
-        // AVOID SPECIAL BUG OF TYPESCRIPT COMPILER API
-        (node as any).parent ??= file;
-
-        // REPORT DIAGNOSTIC
-        const diagnostic = ts.createDiagnosticForNode(node, {
-          key: exp.code,
-          category: ts.DiagnosticCategory.Error,
-          message: exp.message,
-          code: `(${exp.code})` as any,
-        });
-        project.extras.addDiagnostic(diagnostic);
-        return null;
-      }
-    };
-}
-
-const isTransformerError = (error: any): error is TransformerError =>
-  typeof error === "object" &&
-  error !== null &&
-  error.constructor.name === "TransformerError" &&
-  typeof error.code === "string" &&
-  typeof error.message === "string";
+import ts from "typescript";
+import { TransformerError } from "typia/lib/transformers/TransformerError";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { NodeTransformer } from "./NodeTransformer";
+
+export namespace FileTransformer {
+  export const transform =
+    (project: Omit<INestiaTransformProject, "context">) =>
+    (context: ts.TransformationContext) =>
+    (file: ts.SourceFile): ts.SourceFile =>
+      file.isDeclarationFile
+        ? file
+        : ts.visitEachChild(
+            file,
+            (node) =>
+              iterate_node({
+                ...project,
+                context,
+              })(context)(file)(node),
+            context,
+          );
+
+  const iterate_node =
+    (project: INestiaTransformProject) =>
+    (context: ts.TransformationContext) =>
+    (file: ts.SourceFile) =>
+    (node: ts.Node): ts.Node =>
+      ts.visitEachChild(
+        try_transform_node(project)(file)(node) ?? node,
+        (child) => iterate_node(project)(context)(file)(child),
+        context,
+      );
+
+  const try_transform_node =
+    (project: INestiaTransformProject) =>
+    (file: ts.SourceFile) =>
+    (node: ts.Node): ts.Node | null => {
+      try {
+        return NodeTransformer.transform(project)(node);
+      } catch (exp) {
+        // ONLY ACCEPT TRANSFORMER-ERROR
+        if (!isTransformerError(exp)) throw exp;
+
+        // AVOID SPECIAL BUG OF TYPESCRIPT COMPILER API
+        (node as any).parent ??= file;
+
+        // REPORT DIAGNOSTIC
+        const diagnostic = ts.createDiagnosticForNode(node, {
+          key: exp.code,
+          category: ts.DiagnosticCategory.Error,
+          message: exp.message,
+          code: `(${exp.code})` as any,
+        });
+        project.extras.addDiagnostic(diagnostic);
+        return null;
+      }
+    };
+}
+
+const isTransformerError = (error: any): error is TransformerError =>
+  typeof error === "object" &&
+  error !== null &&
+  error.constructor.name === "TransformerError" &&
+  typeof error.code === "string" &&
+  typeof error.message === "string";

package/src/transformers/MethodTransformer.ts

@@ -1,94 +1,97 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { TypedExceptionTransformer } from "./TypedExceptionTransformer";
-import { TypedRouteTransformer } from "./TypedRouteTransformer";
-
-export namespace MethodTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (method: ts.MethodDeclaration): ts.MethodDeclaration => {
-      const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-        ? ts.getDecorators(method)
-        : (method as any).decorators;
-      if (!decorators?.length) return method;
-
-      const signature: ts.Signature | undefined =
-        project.checker.getSignatureFromDeclaration(method);
-      const original: ts.Type | undefined =
-        signature && project.checker.getReturnTypeOfSignature(signature);
-      const escaped: ts.Type | undefined =
-        original && get_escaped_type(project.checker)(original);
-
-      if (escaped === undefined) return method;
-
-      const operator = (deco: ts.Decorator): ts.Decorator => {
-        deco = TypedExceptionTransformer.transform(project)(deco);
-        deco = TypedRouteTransformer.transform(project)(escaped)(deco);
-        return deco;
-      };
-      if (ts.getDecorators !== undefined)
-        return ts.factory.updateMethodDeclaration(
-          method,
-          (method.modifiers || []).map((mod) =>
-            ts.isDecorator(mod) ? operator(mod) : mod,
-          ),
-          method.asteriskToken,
-          method.name,
-          method.questionToken,
-          method.typeParameters,
-          method.parameters,
-          method.type,
-          method.body,
-        );
-      // eslint-disable-next-line
-      return (ts.factory.updateMethodDeclaration as any)(
-        method,
-        decorators.map(operator),
-        (method as any).modifiers,
-        method.asteriskToken,
-        method.name,
-        method.questionToken,
-        method.typeParameters,
-        method.parameters,
-        method.type,
-        method.body,
-      );
-    };
-}
-
-const get_escaped_type =
-  (checker: ts.TypeChecker) =>
-  (type: ts.Type): ts.Type => {
-    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
-    return symbol && get_name(symbol) === "Promise"
-      ? escape_promise(checker)(type)
-      : type;
-  };
-
-const escape_promise =
-  (checker: ts.TypeChecker) =>
-  (type: ts.Type): ts.Type => {
-    const generic: readonly ts.Type[] = checker.getTypeArguments(
-      type as ts.TypeReference,
-    );
-    if (generic.length !== 1)
-      throw new Error(
-        "Error on ImportAnalyzer.analyze(): invalid promise type.",
-      );
-    return generic[0];
-  };
-
-const get_name = (symbol: ts.Symbol): string =>
-  explore_name(symbol.getDeclarations()![0].parent)(
-    symbol.escapedName.toString(),
-  );
-
-const explore_name =
-  (decl: ts.Node) =>
-  (name: string): string =>
-    ts.isModuleBlock(decl)
-      ? explore_name(decl.parent.parent)(
-          `${decl.parent.name.getFullText().trim()}.${name}`,
-        )
-      : name;
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { TypedExceptionTransformer } from "./TypedExceptionTransformer";
+import { TypedRouteTransformer } from "./TypedRouteTransformer";
+import { WebSocketRouteTransformer } from "./WebSocketRouteTransformer";
+
+export namespace MethodTransformer {
+  export const transform =
+    (project: INestiaTransformProject) =>
+    (method: ts.MethodDeclaration): ts.MethodDeclaration => {
+      const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+        ? ts.getDecorators(method)
+        : (method as any).decorators;
+      if (!decorators?.length) return method;
+
+      const signature: ts.Signature | undefined =
+        project.checker.getSignatureFromDeclaration(method);
+      const original: ts.Type | undefined =
+        signature && project.checker.getReturnTypeOfSignature(signature);
+      const escaped: ts.Type | undefined =
+        original && get_escaped_type(project.checker)(original);
+
+      if (escaped === undefined) return method;
+
+      const operator = (decorator: ts.Decorator): ts.Decorator => {
+        decorator = TypedExceptionTransformer.transform(project)(decorator);
+        decorator =
+          TypedRouteTransformer.transform(project)(escaped)(decorator);
+        WebSocketRouteTransformer.validate(project)(decorator, method);
+        return decorator;
+      };
+      if (ts.getDecorators !== undefined)
+        return ts.factory.updateMethodDeclaration(
+          method,
+          (method.modifiers || []).map((mod) =>
+            ts.isDecorator(mod) ? operator(mod) : mod,
+          ),
+          method.asteriskToken,
+          method.name,
+          method.questionToken,
+          method.typeParameters,
+          method.parameters,
+          method.type,
+          method.body,
+        );
+      // eslint-disable-next-line
+      return (ts.factory.updateMethodDeclaration as any)(
+        method,
+        decorators.map(operator),
+        (method as any).modifiers,
+        method.asteriskToken,
+        method.name,
+        method.questionToken,
+        method.typeParameters,
+        method.parameters,
+        method.type,
+        method.body,
+      );
+    };
+}
+
+const get_escaped_type =
+  (checker: ts.TypeChecker) =>
+  (type: ts.Type): ts.Type => {
+    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
+    return symbol && get_name(symbol) === "Promise"
+      ? escape_promise(checker)(type)
+      : type;
+  };
+
+const escape_promise =
+  (checker: ts.TypeChecker) =>
+  (type: ts.Type): ts.Type => {
+    const generic: readonly ts.Type[] = checker.getTypeArguments(
+      type as ts.TypeReference,
+    );
+    if (generic.length !== 1)
+      throw new Error(
+        "Error on ImportAnalyzer.analyze(): invalid promise type.",
+      );
+    return generic[0];
+  };
+
+const get_name = (symbol: ts.Symbol): string =>
+  explore_name(symbol.getDeclarations()![0].parent)(
+    symbol.escapedName.toString(),
+  );
+
+const explore_name =
+  (decl: ts.Node) =>
+  (name: string): string =>
+    ts.isModuleBlock(decl)
+      ? explore_name(decl.parent.parent)(
+          `${decl.parent.name.getFullText().trim()}.${name}`,
+        )
+      : name;

package/src/transformers/NodeTransformer.ts

@@ -1,16 +1,16 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } 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;
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } 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;
+}

package/src/transformers/ParameterTransformer.ts

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } 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;
-
-      // GET TYPE INFO
-      const type: ts.Type = project.checker.getTypeAtLocation(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),
-        ),
-        (param as any).modifiers,
-        param.dotDotDotToken,
-        param.name,
-        param.questionToken,
-        param.type,
-        param.initializer,
-      );
-    };
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } 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;
+
+      // GET TYPE INFO
+      const type: ts.Type = project.checker.getTypeAtLocation(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),
+        ),
+        (param as any).modifiers,
+        param.dotDotDotToken,
+        param.name,
+        param.questionToken,
+        param.type,
+        param.initializer,
+      );
+    };
+}

package/src/transformers/TypedExceptionTransformer.ts

@@ -1,48 +1,44 @@
-import path from "path";
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { TypedExceptionProgrammer } from "../programmers/TypedExceptionProgrammer";
-
-export namespace TypedExceptionTransformer {
-  export const transform =
-    (project: INestiaTransformProject) =>
-    (decorator: ts.Decorator): ts.Decorator => {
-      if (!ts.isCallExpression(decorator.expression)) return decorator;
-
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return decorator;
-
-      // CHECK TO BE TRANSFORMED
-      const done: boolean = (() => {
-        // CHECK FILENAME
-        const location: string = path.resolve(
-          signature.declaration.getSourceFile().fileName,
-        );
-        if (location.indexOf(LIB_PATH) === -1 && location !== SRC_PATH)
-          return false;
-
-        // CHECK DUPLICATED
-        return decorator.expression.arguments.length !== 3;
-      })();
-      if (done === false) return decorator;
-
-      // DO TRANSFORM
-      return ts.factory.createDecorator(
-        TypedExceptionProgrammer.generate(project)(decorator.expression),
-      );
-    };
-
-  const LIB_PATH = path.join(
-    "@nestia",
-    "core",
-    "lib",
-    "decorators",
-    `TypedException.d.ts`,
-  );
-  const SRC_PATH = path.resolve(
-    path.join(__dirname, "..", "decorators", `TypedException.ts`),
-  );
-}
+import path from "path";
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { TypedExceptionProgrammer } from "../programmers/TypedExceptionProgrammer";
+
+export namespace TypedExceptionTransformer {
+  export const transform =
+    (project: INestiaTransformProject) =>
+    (decorator: ts.Decorator): ts.Decorator => {
+      if (!ts.isCallExpression(decorator.expression)) return decorator;
+
+      // CHECK SIGNATURE
+      const signature: ts.Signature | undefined =
+        project.checker.getResolvedSignature(decorator.expression);
+      if (!signature || !signature.declaration) return decorator;
+
+      // CHECK TO BE TRANSFORMED
+      const done: boolean = (() => {
+        // CHECK FILENAME
+        const location: string = path.resolve(
+          signature.declaration.getSourceFile().fileName,
+        );
+        if (location.indexOf(LIB_PATH) === -1) return false;
+
+        // CHECK DUPLICATED
+        return decorator.expression.arguments.length !== 3;
+      })();
+      if (done === false) return decorator;
+
+      // DO TRANSFORM
+      return ts.factory.createDecorator(
+        TypedExceptionProgrammer.generate(project)(decorator.expression),
+      );
+    };
+}
+
+const LIB_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `TypedException.d.ts`,
+);