@nestia/core 7.0.0-dev.20250607 → 7.0.0

package/src/transformers/WebSocketRouteTransformer.ts

@@ -1,120 +1,120 @@
-import path from "path";
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-
-export namespace WebSocketRouteTransformer {
-  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 =
-      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 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.`,
-        );
-      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(
-        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) => {
-  if (!signature.declaration) return false;
-  const location: string = path.resolve(
-    signature.declaration.getSourceFile().fileName,
-  );
-  return (
-    location.indexOf(LIB_PATH) !== -1 || location.indexOf(MONO_PATH) !== -1
-  );
-};
-
-const LIB_PATH = path.join(
-  "@nestia",
-  "core",
-  "lib",
-  "decorators",
-  `WebSocketRoute.d.ts`,
-);
-const MONO_PATH = path.join(
-  "packages",
-  "core",
-  "lib",
-  "decorators",
-  `WebSocketRoute.d.ts`,
-);
+import path from "path";
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+
+export namespace WebSocketRouteTransformer {
+  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 =
+      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 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.`,
+        );
+      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(
+        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) => {
+  if (!signature.declaration) return false;
+  const location: string = path.resolve(
+    signature.declaration.getSourceFile().fileName,
+  );
+  return (
+    location.indexOf(LIB_PATH) !== -1 || location.indexOf(MONO_PATH) !== -1
+  );
+};
+
+const LIB_PATH = path.join(
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  `WebSocketRoute.d.ts`,
+);
+const MONO_PATH = path.join(
+  "packages",
+  "core",
+  "lib",
+  "decorators",
+  `WebSocketRoute.d.ts`,
+);

package/src/typings/Creator.ts

@@ -1,3 +1,3 @@
-export type Creator<T extends object> = {
-  new (...args: any[]): T;
-};
+export type Creator<T extends object> = {
+  new (...args: any[]): T;
+};

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

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

package/src/utils/ArrayUtil.ts

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

@@ -1,112 +1,112 @@
-import { HttpError } from "@nestia/fetcher";
-import { HttpException } from "@nestjs/common";
-
-import { Creator } from "../typings/Creator";
-
-/**
- * Exception manager for HTTP server.
- *
- * `ExceptionManager` is an utility class who can insert or erase custom error class with
- * its conversion method to a regular {@link nest.HttpException} instance.
- *
- * If you define an API function through {@link TypedRoute} or {@link EncryptedRoute}
- * instead of the basic router decorator functions like {@link nest.Get} or
- * {@link nest.Post} and the API function throws a custom error whose class has been
- * {@link ExceptionManager.insert inserted} in this `EntityManager`, the error would be
- * automatically converted to the regular {@link nest.HttpException} instance by the
- * {@link ExceptionManager.Closure} function.
- *
- * Therefore, with this `ExceptionManager` and {@link TypedRoute} or {@link EncryptedRoute},
- * you can manage your custom error classes much systemtically. You can avoid 500 internal
- * server error or hard coding implementation about the custom error classes.
- *
- * Below error classes are defaultly configured in this `ExceptionManager`
- *
- *   - `typia.TypeGuardError`
- *   - `@nestia/fetcher.HttpError`
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace ExceptionManager {
-  /**
-   * Insert an error class with converter.
-   *
-   * If you've inserted an duplicated error class, the closure would be overwritten.
-   *
-   * @param creator Target error class
-   * @param closure A closure function converting to the `HttpException` class
-   */
-  export function insert<T extends Error>(
-    creator: Creator<T>,
-    closure: Closure<T>,
-  ): void {
-    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
-    if (index !== -1) tuples.splice(index, 1);
-
-    tuples.push([creator, closure]);
-    tuples.sort(([x], [y]) => (x.prototype instanceof y ? -1 : 1));
-  }
-
-  /**
-   * Erase an error class.
-   *
-   * @param creator Target error class
-   * @returns Whether be erased or not
-   */
-  export function erase<T extends Error>(creator: Creator<T>): boolean {
-    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
-    if (index === -1) return false;
-
-    tuples.splice(index, 1);
-    return true;
-  }
-
-  export function on(closure: (error: any) => any): void {
-    listeners.add(closure);
-  }
-
-  export function off(closure: (error: any) => any): void {
-    listeners.delete(closure);
-  }
-
-  /**
-   * Type of a closure function converting to the regular {@link nest.HttpException}.
-   *
-   * `ExceptionManager.Closure` is a type of closure function who are converting from
-   * custom error to the regular {@link nest.HttpException} instance. It would be used
-   * in the {@link ExceptionManager} with {@link TypedRoute} or {@link EncryptedRoute}.
-   */
-  export interface Closure<T extends Error> {
-    /**
-     * Error converter.
-     *
-     * Convert from custom error to the regular {@link nest.HttpException} instance.
-     *
-     * @param exception Custom error instance
-     * @return Regular {@link nest.HttpException} instance
-     */
-    (exception: T): HttpException;
-  }
-
-  /**
-   * @internal
-   */
-  export const tuples: Array<[Creator<any>, Closure<any>]> = [];
-
-  /**
-   * @internal
-   */
-  export const listeners: Set<(error: any) => any> = new Set();
-}
-
-ExceptionManager.insert(
-  HttpError,
-  (error) =>
-    new HttpException(
-      {
-        path: error.path,
-        message: error.message,
-      },
-      error.status,
-    ),
-);
+import { HttpError } from "@nestia/fetcher";
+import { HttpException } from "@nestjs/common";
+
+import { Creator } from "../typings/Creator";
+
+/**
+ * Exception manager for HTTP server.
+ *
+ * `ExceptionManager` is an utility class who can insert or erase custom error class with
+ * its conversion method to a regular {@link nest.HttpException} instance.
+ *
+ * If you define an API function through {@link TypedRoute} or {@link EncryptedRoute}
+ * instead of the basic router decorator functions like {@link nest.Get} or
+ * {@link nest.Post} and the API function throws a custom error whose class has been
+ * {@link ExceptionManager.insert inserted} in this `EntityManager`, the error would be
+ * automatically converted to the regular {@link nest.HttpException} instance by the
+ * {@link ExceptionManager.Closure} function.
+ *
+ * Therefore, with this `ExceptionManager` and {@link TypedRoute} or {@link EncryptedRoute},
+ * you can manage your custom error classes much systemtically. You can avoid 500 internal
+ * server error or hard coding implementation about the custom error classes.
+ *
+ * Below error classes are defaultly configured in this `ExceptionManager`
+ *
+ *   - `typia.TypeGuardError`
+ *   - `@nestia/fetcher.HttpError`
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace ExceptionManager {
+  /**
+   * Insert an error class with converter.
+   *
+   * If you've inserted an duplicated error class, the closure would be overwritten.
+   *
+   * @param creator Target error class
+   * @param closure A closure function converting to the `HttpException` class
+   */
+  export function insert<T extends Error>(
+    creator: Creator<T>,
+    closure: Closure<T>,
+  ): void {
+    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
+    if (index !== -1) tuples.splice(index, 1);
+
+    tuples.push([creator, closure]);
+    tuples.sort(([x], [y]) => (x.prototype instanceof y ? -1 : 1));
+  }
+
+  /**
+   * Erase an error class.
+   *
+   * @param creator Target error class
+   * @returns Whether be erased or not
+   */
+  export function erase<T extends Error>(creator: Creator<T>): boolean {
+    const index: number = tuples.findIndex((tuple) => tuple[0] === creator);
+    if (index === -1) return false;
+
+    tuples.splice(index, 1);
+    return true;
+  }
+
+  export function on(closure: (error: any) => any): void {
+    listeners.add(closure);
+  }
+
+  export function off(closure: (error: any) => any): void {
+    listeners.delete(closure);
+  }
+
+  /**
+   * Type of a closure function converting to the regular {@link nest.HttpException}.
+   *
+   * `ExceptionManager.Closure` is a type of closure function who are converting from
+   * custom error to the regular {@link nest.HttpException} instance. It would be used
+   * in the {@link ExceptionManager} with {@link TypedRoute} or {@link EncryptedRoute}.
+   */
+  export interface Closure<T extends Error> {
+    /**
+     * Error converter.
+     *
+     * Convert from custom error to the regular {@link nest.HttpException} instance.
+     *
+     * @param exception Custom error instance
+     * @return Regular {@link nest.HttpException} instance
+     */
+    (exception: T): HttpException;
+  }
+
+  /**
+   * @internal
+   */
+  export const tuples: Array<[Creator<any>, Closure<any>]> = [];
+
+  /**
+   * @internal
+   */
+  export const listeners: Set<(error: any) => any> = new Set();
+}
+
+ExceptionManager.insert(
+  HttpError,
+  (error) =>
+    new HttpException(
+      {
+        path: error.path,
+        message: error.message,
+      },
+      error.status,
+    ),
+);

package/src/utils/Singleton.ts

@@ -1,20 +1,20 @@
-/**
- * @internal
- */
-export class Singleton<T> {
-  private value_: T | object;
-
-  public constructor(private readonly closure_: () => T) {
-    this.value_ = NOT_MOUNTED_YET;
-  }
-
-  public get(): T {
-    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_();
-    return this.value_ as T;
-  }
-}
-
-/**
- * @internal
- */
-const NOT_MOUNTED_YET = {};
+/**
+ * @internal
+ */
+export class Singleton<T> {
+  private value_: T | object;
+
+  public constructor(private readonly closure_: () => T) {
+    this.value_ = NOT_MOUNTED_YET;
+  }
+
+  public get(): T {
+    if (this.value_ === NOT_MOUNTED_YET) this.value_ = this.closure_();
+    return this.value_ as T;
+  }
+}
+
+/**
+ * @internal
+ */
+const NOT_MOUNTED_YET = {};

package/src/utils/SourceFinder.ts

@@ -1,57 +1,57 @@
-import fs from "fs";
-import glob from "glob";
-import path from "path";
-
-export namespace SourceFinder {
-  export const find = async (props: IProps): Promise<string[]> => {
-    const dict: Set<string> = new Set();
-
-    await emplace(props.filter)(props.include)((str) => dict.add(str));
-    if (props.exclude?.length)
-      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
-
-    return [...dict];
-  };
-
-  const emplace =
-    (filter: (file: string) => boolean) =>
-    (input: string[]) =>
-    async (closure: (location: string) => void): Promise<void> => {
-      for (const pattern of input) {
-        for (const file of await _Glob(path.resolve(pattern))) {
-          const stats: fs.Stats = await fs.promises.stat(file);
-          if (stats.isDirectory() === true)
-            await iterate(filter)(closure)(file);
-          else if (stats.isFile() && filter(file)) closure(file);
-        }
-      }
-    };
-
-  const iterate =
-    (filter: (location: string) => boolean) =>
-    (closure: (location: string) => void) =>
-    async (location: string): Promise<void> => {
-      const directory: string[] = await fs.promises.readdir(location);
-      for (const file of directory) {
-        const next: string = path.resolve(`${location}/${file}`);
-        const stats: fs.Stats = await fs.promises.stat(next);
-
-        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
-        else if (stats.isFile() && filter(next)) closure(next);
-      }
-    };
-
-  const _Glob = (pattern: string): Promise<string[]> =>
-    new Promise((resolve, reject) => {
-      glob(pattern, (err, matches) => {
-        if (err) reject(err);
-        else resolve(matches.map((str) => path.resolve(str)));
-      });
-    });
-}
-
-interface IProps {
-  exclude?: string[];
-  include: string[];
-  filter: (location: string) => boolean;
-}
+import fs from "fs";
+import glob from "glob";
+import path from "path";
+
+export namespace SourceFinder {
+  export const find = async (props: IProps): Promise<string[]> => {
+    const dict: Set<string> = new Set();
+
+    await emplace(props.filter)(props.include)((str) => dict.add(str));
+    if (props.exclude?.length)
+      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
+
+    return [...dict];
+  };
+
+  const emplace =
+    (filter: (file: string) => boolean) =>
+    (input: string[]) =>
+    async (closure: (location: string) => void): Promise<void> => {
+      for (const pattern of input) {
+        for (const file of await _Glob(path.resolve(pattern))) {
+          const stats: fs.Stats = await fs.promises.stat(file);
+          if (stats.isDirectory() === true)
+            await iterate(filter)(closure)(file);
+          else if (stats.isFile() && filter(file)) closure(file);
+        }
+      }
+    };
+
+  const iterate =
+    (filter: (location: string) => boolean) =>
+    (closure: (location: string) => void) =>
+    async (location: string): Promise<void> => {
+      const directory: string[] = await fs.promises.readdir(location);
+      for (const file of directory) {
+        const next: string = path.resolve(`${location}/${file}`);
+        const stats: fs.Stats = await fs.promises.stat(next);
+
+        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
+        else if (stats.isFile() && filter(next)) closure(next);
+      }
+    };
+
+  const _Glob = (pattern: string): Promise<string[]> =>
+    new Promise((resolve, reject) => {
+      glob(pattern, (err, matches) => {
+        if (err) reject(err);
+        else resolve(matches.map((str) => path.resolve(str)));
+      });
+    });
+}
+
+interface IProps {
+  exclude?: string[];
+  include: string[];
+  filter: (location: string) => boolean;
+}