Let @WebSocketRoute() to generate compilation errors.

package.json

@@ -1,7 +1,7 @@
 {
   "private": true,
   "name": "@nestia/station",
-  "version": "3.1.0-dev.20240426",
+  "version": "3.1.0-dev.20240429",
   "description": "Nestia station",
   "scripts": {
     "build": "node build/index.js",

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/core",
-  "version": "3.1.0-dev.20240426",
+  "version": "3.1.0-dev.20240429",
   "description": "Super-fast validation decorators of NestJS",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -36,10 +36,10 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@nestia/fetcher": "^3.1.0-dev.20240426",
+    "@nestia/fetcher": "^3.1.0-dev.20240429",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
-    "@samchon/openapi": "^0.1.18",
+    "@samchon/openapi": "^0.1.21",
     "detect-ts-node": "^1.0.5",
     "glob": "^7.2.0",
     "multer": "1.4.5-lts.1",
@@ -52,7 +52,7 @@
     "ws": "^7.5.3"
   },
   "peerDependencies": {
-    "@nestia/fetcher": ">=3.1.0-dev.20240426",
+    "@nestia/fetcher": ">=3.1.0-dev.20240429",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "reflect-metadata": ">=0.1.12",

packages/core/src/adaptors/WebSocketAdaptor.ts

@@ -13,6 +13,7 @@ import { InstanceWrapper } from "@nestjs/core/injector/instance-wrapper";
 import { Module } from "@nestjs/core/injector/module";
 import getFunctionLocation from "get-function-location";
 import { IncomingMessage, Server } from "http";
+import path from "path";
 import { Path } from "path-parser";
 import { Duplex } from "stream";
 import { WebAcceptor } from "tgrid";
@@ -127,46 +128,41 @@ const visitApplication = async (
       Reflect.getMetadata(MODULE_PATH, m.metatype) ??
       "";
     for (const controller of m.controllers.values())
-      visitController({
+      await visitController({
         config,
         errors,
         operators,
         controller,
         modulePrefix,
       });
   }
-  if (errors.length) {
+  if (errors.length)
     throw new Error(
       [
         `WebSocketAdaptor: ${errors.length} error(s) found:`,
         ``,
         ...errors.map((e) =>
           [
             `  - controller: ${e.name}`,
-            `  - methods:`,
+            `    methods:`,
             ...e.methods.map((m) =>
               [
-                `  - name: ${m.name}`,
-                `  - file: ${m.source}:${m.line}:${m.column}`,
-                `  - reasons:`,
+                `    - name: ${m.name}:`,
+                `      file: ${m.source}:${m.line}:${m.column}`,
+                `      reasons:`,
                 ...m.messages.map(
                   (msg) =>
-                    `  - ${msg
+                    `        - ${msg
                       .split("\n")
-                      .map((str) => `  ${str}`)
+                      .map((str, i) => (i == 0 ? str : `        ${str}`))
                       .join("\n")}`,
                 ),
-              ]
-                .map((str) => `  ${str}`)
-                .join("\n"),
+              ].join("\n"),
             ),
-          ]
-            .map((str) => `  ${str}`)
-            .join("\n"),
+          ].join("\n"),
         ),
       ].join("\n"),
     );
-  }
   return operators;
 };
 
@@ -224,12 +220,18 @@ const visitController = async (props: {
       },
       report: (msg) => errorMessages.push(msg),
     });
-    if (errorMessages.length)
+    if (errorMessages.length) {
+      const file = await getFunctionLocation(controller.prototype[mk]);
       methodErrors.push({
         name: mk,
         messages: errorMessages,
-        ...(await getFunctionLocation(controller.prototype[mk])),
+        ...file,
+        source: path.relative(
+          process.cwd(),
+          file.source.replace("file:///", ""),
+        ),
       });
+    }
   }
 
   if (methodErrors.length)

packages/core/src/transformers/MethodTransformer.ts

@@ -3,6 +3,7 @@ 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 =
@@ -22,10 +23,12 @@ export namespace MethodTransformer {
 
       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;
+      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(

packages/core/src/transformers/TypedExceptionTransformer.ts

@@ -21,8 +21,7 @@ export namespace TypedExceptionTransformer {
         const location: string = path.resolve(
           signature.declaration.getSourceFile().fileName,
         );
-        if (location.indexOf(LIB_PATH) === -1 && location !== SRC_PATH)
-          return false;
+        if (location.indexOf(LIB_PATH) === -1) return false;
 
         // CHECK DUPLICATED
         return decorator.expression.arguments.length !== 3;
@@ -34,15 +33,12 @@ export namespace TypedExceptionTransformer {
         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`),
-  );
 }
+
+const LIB_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `TypedException.d.ts`,
+);

packages/core/src/transformers/TypedRouteTransformer.ts

@@ -23,11 +23,7 @@ export namespace TypedRouteTransformer {
         const location: string = path.resolve(
           signature.declaration.getSourceFile().fileName,
         );
-        if (
-          LIB_PATHS.every((str) => location.indexOf(str) === -1) &&
-          SRC_PATHS.every((str) => location !== str)
-        )
-          return null;
+        if (LIB_PATHS.every((str) => location.indexOf(str) === -1)) return null;
 
         // CHECK DUPLICATE BOOSTER
         if (decorator.expression.arguments.length >= 2) return false;
@@ -82,7 +78,4 @@ export namespace TypedRouteTransformer {
   const LIB_PATHS = CLASSES.map((cla) =>
     path.join("@nestia", "core", "lib", "decorators", `${cla}.d.ts`),
   );
-  const SRC_PATHS = CLASSES.map((cla) =>
-    path.resolve(path.join(__dirname, "..", "decorators", `${cla}.ts`)),
-  );
 }

packages/core/src/transformers/WebSocketRouteTransformer.ts

@@ -0,0 +1,103 @@
+import path from "path";
+import ts from "typescript";
+
+import { INestiaTransformProject } 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;
+
+      // 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;
+
+      const errors: ts.DiagnosticWithLocation[] = [];
+      let accepted: boolean = false;
+
+      const report = (node: ts.Node, message: string) => {
+        errors.push(
+          ts.createDiagnosticForNode(node, {
+            category: ts.DiagnosticCategory.Error,
+            key: "nestia.core.WebSocketRoute",
+            code: "(nestia.core.WebSocketRoute)" as any,
+            message,
+          }),
+        );
+      };
+      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
+          );
+        })();
+        if (category === null)
+          report(
+            param,
+            `parameter ${JSON.stringify(param.name.getText())} is not decorated with nested function of WebSocketRoute module.`,
+          );
+        else if (category === "Acceptor") {
+          accepted = true;
+          if (
+            param.type
+              ?.getText()
+              .split(".")
+              .at(-1)
+              ?.startsWith("WebAcceptor") !== true
+          )
+            report(
+              param,
+              `parameter ${JSON.stringify(param.name.getText())} must have WebAcceptor<Header, Provider, Listener> type.`,
+            );
+        } else if (category === "Driver") {
+          if (
+            param.type?.getText().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;
+    };
+}
+
+const isLocated = (signature: ts.Signature) => {
+  if (!signature.declaration) return false;
+  const location: string = path.resolve(
+    signature.declaration.getSourceFile().fileName,
+  );
+  return location.indexOf(LIB_PATH) !== -1;
+};
+
+const LIB_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `WebSocketRoute.d.ts`,
+);

packages/fetcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/fetcher",
-  "version": "3.1.0-dev.20240426",
+  "version": "3.1.0-dev.20240429",
   "description": "Fetcher library of Nestia SDK",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestia/sdk",
-  "version": "3.1.0-dev.20240426",
+  "version": "3.1.0-dev.20240429",
   "description": "Nestia SDK and Swagger generator",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -32,8 +32,8 @@
   },
   "homepage": "https://nestia.io",
   "dependencies": {
-    "@nestia/fetcher": "^3.1.0-dev.20240426",
-    "@samchon/openapi": "^0.1.18",
+    "@nestia/fetcher": "^3.1.0-dev.20240429",
+    "@samchon/openapi": "^0.1.21",
     "cli": "^1.0.1",
     "get-function-location": "^2.0.0",
     "glob": "^7.2.0",
@@ -46,7 +46,7 @@
     "typia": "^6.0.3"
   },
   "peerDependencies": {
-    "@nestia/fetcher": ">=3.1.0-dev.20240426",
+    "@nestia/fetcher": ">=3.1.0-dev.20240429",
     "@nestjs/common": ">=7.0.1",
     "@nestjs/core": ">=7.0.1",
     "reflect-metadata": ">=0.1.12",

packages/sdk/src/generates/SwaggerGenerator.ts

@@ -123,7 +123,7 @@ export namespace SwaggerGenerator {
       if (errors.length) {
         for (const e of errors)
           console.error(
-            `${path.relative(e.route.location, process.cwd())}:${
+            `${path.relative(process.cwd(), e.route.location)}:${
               e.route.controller.name
             }.${e.route.name}:${
               e.from

test/features/websocket-error-invalid-acceptor/nestia.config.ts

@@ -0,0 +1,15 @@
+import { INestiaConfig } from "@nestia/sdk";
+
+export const NESTIA_CONFIG: INestiaConfig = {
+  input: ["src/controllers"],
+  output: "src/api",
+  swagger: {
+    output: "swagger.json",
+    security: {
+      bearer: {
+        type: "apiKey",
+      },
+    },
+  },
+};
+export default NESTIA_CONFIG;

test/features/websocket-error-invalid-acceptor/src/api/structures/ICalculator.ts

@@ -0,0 +1,6 @@
+export interface ICalculator {
+  plus(x: number, y: number): number;
+  minus(x: number, y: number): number;
+  multiply(x: number, y: number): number;
+  divide(x: number, y: number): number;
+}

test/features/websocket-error-invalid-acceptor/src/api/structures/IListener.ts

@@ -0,0 +1,11 @@
+export interface IListener {
+  on(event: IListener.IEvent): void;
+}
+export namespace IListener {
+  export interface IEvent {
+    operator: "plus" | "minus" | "multiply" | "divide";
+    x: number;
+    y: number;
+    z: number;
+  }
+}

test/features/websocket-error-invalid-acceptor/src/api/structures/IPrecision.ts

@@ -0,0 +1,3 @@
+export interface IPrecision {
+  value: number;
+}