@nestia/core 3.0.5 → 3.1.0-dev.20240429

package/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`)),
-  );
 }

package/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`,
+);

package/src/typings/get-function-location.d.ts

@@ -0,0 +1,7 @@
+declare module "get-function-location" {
+  export default function (func: any): Promise<{
+    source: string;
+    line: number;
+    column: number;
+  }>;
+}

package/src/utils/ArrayUtil.ts

@@ -0,0 +1,7 @@
+export namespace ArrayUtil {
+  export function has<T>(array: T[], ...items: T[]): boolean {
+    return items.every(
+      (elem) => array.find((org) => org === elem) !== undefined,
+    );
+  }
+}

package/src/utils/VersioningStrategy.ts

@@ -0,0 +1,27 @@
+import { VERSION_NEUTRAL, VersionValue } from "@nestjs/common/interfaces";
+
+export namespace VersioningStrategy {
+  export interface IConfig {
+    prefix: string;
+    defaultVersion?: VersionValue;
+  }
+
+  export const cast = (
+    value: VersionValue | undefined,
+  ): Array<string | typeof VERSION_NEUTRAL> =>
+    value === undefined ? [] : Array.isArray(value) ? value : [value];
+
+  export const merge =
+    (config: IConfig | undefined) =>
+    (values: Array<string | typeof VERSION_NEUTRAL>): string[] => {
+      if (config === undefined) return [""];
+      const set: Set<string | typeof VERSION_NEUTRAL> = new Set(values);
+      const array: Array<string | typeof VERSION_NEUTRAL> =
+        set.size === 0 ? cast(config.defaultVersion) : Array.from(set);
+      return !!array?.length
+        ? array.map((x) =>
+            typeof x === "symbol" ? "" : `${config.prefix}${x}`,
+          )
+        : [];
+    };
+}