@nestia/core 11.0.0-dev.20260305 → 11.0.0-dev.20260312

package/src/options/IRequestHeadersValidator.ts

@@ -1,22 +1,22 @@
-import { IValidation } from "typia";
-
-export type IRequestHeadersValidator<T> =
-  | IRequestHeadersValidator.IAssert<T>
-  | IRequestHeadersValidator.IIs<T>
-  | IRequestHeadersValidator.IValidate<T>;
-export namespace IRequestHeadersValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: Record<string, string | string[] | undefined>) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: Record<string, string | string[] | undefined>) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (
-      input: Record<string, string | string[] | undefined>,
-    ) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestHeadersValidator<T> =
+  | IRequestHeadersValidator.IAssert<T>
+  | IRequestHeadersValidator.IIs<T>
+  | IRequestHeadersValidator.IValidate<T>;
+export namespace IRequestHeadersValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: Record<string, string | string[] | undefined>) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: Record<string, string | string[] | undefined>) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (
+      input: Record<string, string | string[] | undefined>,
+    ) => IValidation<T>;
+  }
+}

package/src/options/IRequestQueryValidator.ts

@@ -1,20 +1,20 @@
-import { IValidation } from "typia";
-
-export type IRequestQueryValidator<T> =
-  | IRequestQueryValidator.IAssert<T>
-  | IRequestQueryValidator.IIs<T>
-  | IRequestQueryValidator.IValidate<T>;
-export namespace IRequestQueryValidator {
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: URLSearchParams) => T;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: URLSearchParams) => T | null;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: URLSearchParams) => IValidation<T>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IRequestQueryValidator<T> =
+  | IRequestQueryValidator.IAssert<T>
+  | IRequestQueryValidator.IIs<T>
+  | IRequestQueryValidator.IValidate<T>;
+export namespace IRequestQueryValidator {
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: URLSearchParams) => T;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: URLSearchParams) => T | null;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: URLSearchParams) => IValidation<T>;
+  }
+}

package/src/options/IResponseBodyQuerifier.ts

@@ -1,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyQuerifier<T> =
-  | IResponseBodyquerifier.IStringify<T>
-  | IResponseBodyquerifier.IIs<T>
-  | IResponseBodyquerifier.IAssert<T>
-  | IResponseBodyquerifier.IValidate<T>;
-export namespace IResponseBodyquerifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => URLSearchParams;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => URLSearchParams | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => URLSearchParams;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<URLSearchParams>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyQuerifier<T> =
+  | IResponseBodyquerifier.IStringify<T>
+  | IResponseBodyquerifier.IIs<T>
+  | IResponseBodyquerifier.IAssert<T>
+  | IResponseBodyquerifier.IValidate<T>;
+export namespace IResponseBodyquerifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => URLSearchParams;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => URLSearchParams | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => URLSearchParams;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<URLSearchParams>;
+  }
+}

package/src/options/IResponseBodyStringifier.ts

@@ -1,30 +1,30 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-  | IResponseBodyStringifier.IStringify<T>
-  | IResponseBodyStringifier.IIs<T>
-  | IResponseBodyStringifier.IAssert<T>
-  | IResponseBodyStringifier.IValidate<T>
-  | IResponseBodyStringifier.IValidateLog<T>;
-export namespace IResponseBodyStringifier {
-  export interface IStringify<T> {
-    type: "stringify";
-    stringify: (input: T) => string;
-  }
-  export interface IIs<T> {
-    type: "is";
-    is: (input: T) => string | null;
-  }
-  export interface IAssert<T> {
-    type: "assert";
-    assert: (input: T) => string;
-  }
-  export interface IValidate<T> {
-    type: "validate";
-    validate: (input: T) => IValidation<string>;
-  }
-  export interface IValidateLog<T> {
-    type: "validate.log";
-    validate: (input: T) => IValidation<string>;
-  }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+  | IResponseBodyStringifier.IStringify<T>
+  | IResponseBodyStringifier.IIs<T>
+  | IResponseBodyStringifier.IAssert<T>
+  | IResponseBodyStringifier.IValidate<T>
+  | IResponseBodyStringifier.IValidateLog<T>;
+export namespace IResponseBodyStringifier {
+  export interface IStringify<T> {
+    type: "stringify";
+    stringify: (input: T) => string;
+  }
+  export interface IIs<T> {
+    type: "is";
+    is: (input: T) => string | null;
+  }
+  export interface IAssert<T> {
+    type: "assert";
+    assert: (input: T) => string;
+  }
+  export interface IValidate<T> {
+    type: "validate";
+    validate: (input: T) => IValidation<string>;
+  }
+  export interface IValidateLog<T> {
+    type: "validate.log";
+    validate: (input: T) => IValidation<string>;
+  }
+}

package/src/transformers/NodeTransformer.ts

@@ -1,23 +1,23 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { MethodTransformer } from "./MethodTransformer";
-import { ParameterTransformer } from "./ParameterTransformer";
-
-export namespace NodeTransformer {
-  export const transform = (props: {
-    context: INestiaTransformContext;
-    node: ts.Node;
-  }): ts.Node =>
-    ts.isMethodDeclaration(props.node)
-      ? MethodTransformer.transform({
-          context: props.context,
-          method: props.node,
-        })
-      : ts.isParameter(props.node)
-        ? ParameterTransformer.transform({
-            context: props.context,
-            param: props.node,
-          })
-        : props.node;
-}
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { MethodTransformer } from "./MethodTransformer";
+import { ParameterTransformer } from "./ParameterTransformer";
+
+export namespace NodeTransformer {
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.isMethodDeclaration(props.node)
+      ? MethodTransformer.transform({
+          context: props.context,
+          method: props.node,
+        })
+      : ts.isParameter(props.node)
+        ? ParameterTransformer.transform({
+            context: props.context,
+            param: props.node,
+          })
+        : props.node;
+}

package/src/transformers/ParameterTransformer.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { INestiaTransformContext } from "../options/INestiaTransformProject";
-import { ParameterDecoratorTransformer } from "./ParameterDecoratorTransformer";
-
-export namespace ParameterTransformer {
-  export const transform = (props: {
-    context: INestiaTransformContext;
-    param: ts.ParameterDeclaration;
-  }): ts.ParameterDeclaration => {
-    // CHECK DECORATOR
-    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-      ? ts.getDecorators(props.param)
-      : (props.param as any).decorators;
-    if (!decorators?.length) return props.param;
-
-    // GET TYPE INFO
-    const type: ts.Type = props.context.checker.getTypeAtLocation(props.param);
-
-    // WHEN LATEST TS VERSION
-    if (ts.getDecorators !== undefined)
-      return ts.factory.updateParameterDeclaration(
-        props.param,
-        (props.param.modifiers || []).map((mod) =>
-          ts.isDecorator(mod)
-            ? ParameterDecoratorTransformer.transform({
-                context: props.context,
-                decorator: mod,
-                type,
-              })
-            : mod,
-        ),
-        props.param.dotDotDotToken,
-        props.param.name,
-        props.param.questionToken,
-        props.param.type,
-        props.param.initializer,
-      );
-    // eslint-disable-next-line
-    return (ts.factory.updateParameterDeclaration as any)(
-      props.param,
-      decorators.map((deco) =>
-        ParameterDecoratorTransformer.transform({
-          context: props.context,
-          decorator: deco,
-          type,
-        }),
-      ),
-      (props.param as any).modifiers,
-      props.param.dotDotDotToken,
-      props.param.name,
-      props.param.questionToken,
-      props.param.type,
-      props.param.initializer,
-    );
-  };
-}
+import ts from "typescript";
+
+import { INestiaTransformContext } from "../options/INestiaTransformProject";
+import { ParameterDecoratorTransformer } from "./ParameterDecoratorTransformer";
+
+export namespace ParameterTransformer {
+  export const transform = (props: {
+    context: INestiaTransformContext;
+    param: ts.ParameterDeclaration;
+  }): ts.ParameterDeclaration => {
+    // CHECK DECORATOR
+    const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+      ? ts.getDecorators(props.param)
+      : (props.param as any).decorators;
+    if (!decorators?.length) return props.param;
+
+    // GET TYPE INFO
+    const type: ts.Type = props.context.checker.getTypeAtLocation(props.param);
+
+    // WHEN LATEST TS VERSION
+    if (ts.getDecorators !== undefined)
+      return ts.factory.updateParameterDeclaration(
+        props.param,
+        (props.param.modifiers || []).map((mod) =>
+          ts.isDecorator(mod)
+            ? ParameterDecoratorTransformer.transform({
+                context: props.context,
+                decorator: mod,
+                type,
+              })
+            : mod,
+        ),
+        props.param.dotDotDotToken,
+        props.param.name,
+        props.param.questionToken,
+        props.param.type,
+        props.param.initializer,
+      );
+    // eslint-disable-next-line
+    return (ts.factory.updateParameterDeclaration as any)(
+      props.param,
+      decorators.map((deco) =>
+        ParameterDecoratorTransformer.transform({
+          context: props.context,
+          decorator: deco,
+          type,
+        }),
+      ),
+      (props.param as any).modifiers,
+      props.param.dotDotDotToken,
+      props.param.name,
+      props.param.questionToken,
+      props.param.type,
+      props.param.initializer,
+    );
+  };
+}

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,115 +1,115 @@
-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
-     * @returns 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
+     * @returns 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,16 +1,16 @@
-/** @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 = {};