@nestia/core 2.4.3 → 3.0.0-dev.20231209

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,49 +1,49 @@
-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(
-    "node_modules",
-    "@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 && 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(
+    "node_modules",
+    "@nestia",
+    "core",
+    "lib",
+    "decorators",
+    `TypedException.d.ts`,
+  );
+  const SRC_PATH = path.resolve(
+    path.join(__dirname, "..", "decorators", `TypedException.ts`),
+  );
+}

package/src/transformers/TypedRouteTransformer.ts

@@ -1,95 +1,95 @@
-import path from "path";
-import ts from "typescript";
-
-import { INestiaTransformProject } 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;
-
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return 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) &&
-          SRC_PATHS.every((str) => location !== str)
-        )
-          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 TYPE NODE
-      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
-        type,
-        undefined,
-        undefined,
-      );
-      if (typeNode === undefined) return 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),
-          ],
-        ),
-      );
-    };
-
-  const isObject =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type): boolean =>
-      (type.getFlags() & ts.TypeFlags.Object) !== 0 &&
-      !(checker as any).isTupleType(type) &&
-      !(checker as any).isArrayType(type) &&
-      !(checker as any).isArrayLikeType(type);
-
-  const CLASSES = ["EncryptedRoute", "TypedRoute", "TypedQuery"];
-  const LIB_PATHS = CLASSES.map((cla) =>
-    path.join(
-      "node_modules",
-      "@nestia",
-      "core",
-      "lib",
-      "decorators",
-      `${cla}.d.ts`,
-    ),
-  );
-  const SRC_PATHS = CLASSES.map((cla) =>
-    path.resolve(path.join(__dirname, "..", "decorators", `${cla}.ts`)),
-  );
-}
+import path from "path";
+import ts from "typescript";
+
+import { INestiaTransformProject } 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;
+
+      // CHECK SIGNATURE
+      const signature: ts.Signature | undefined =
+        project.checker.getResolvedSignature(decorator.expression);
+      if (!signature || !signature.declaration) return 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) &&
+          SRC_PATHS.every((str) => location !== str)
+        )
+          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 TYPE NODE
+      const typeNode: ts.TypeNode | undefined = project.checker.typeToTypeNode(
+        type,
+        undefined,
+        undefined,
+      );
+      if (typeNode === undefined) return 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),
+          ],
+        ),
+      );
+    };
+
+  const isObject =
+    (checker: ts.TypeChecker) =>
+    (type: ts.Type): boolean =>
+      (type.getFlags() & ts.TypeFlags.Object) !== 0 &&
+      !(checker as any).isTupleType(type) &&
+      !(checker as any).isArrayType(type) &&
+      !(checker as any).isArrayLikeType(type);
+
+  const CLASSES = ["EncryptedRoute", "TypedRoute", "TypedQuery"];
+  const LIB_PATHS = CLASSES.map((cla) =>
+    path.join(
+      "node_modules",
+      "@nestia",
+      "core",
+      "lib",
+      "decorators",
+      `${cla}.d.ts`,
+    ),
+  );
+  const SRC_PATHS = CLASSES.map((cla) =>
+    path.resolve(path.join(__dirname, "..", "decorators", `${cla}.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/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 convertion 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 convertion 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 = {};