@nestia/core 12.0.0-rc.2 → 12.0.0-rc.4

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/transform.ts

@@ -1,26 +1,26 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
-
-/**
- * `@nestia/core` ttsc plugin descriptor.
- *
- * `@nestia/sdk` is not a standalone plugin: its Go transform is declared here
- * as a `contributor` that ttsc statically links into this host binary, and only
- * when `@nestia/sdk` is actually resolvable from the project. A project
- * depending on `@nestia/core` alone never compiles any SDK transform code.
- */
-export default function createTtscPlugin(
-  context: ITtscPluginFactoryContext,
-): ITtscPlugin {
-  const requireFrom = createRequire(
-    path.join(context.projectRoot, "package.json"),
-  );
-  const root: string = path.dirname(
-    requireFrom.resolve("@nestia/core/package.json"),
-  );
-  return {
-    name: "@nestia/core",
-    source: path.resolve(root, "native", "cmd", "ttsc-nestia"),
-  };
-}
+import { createRequire } from "node:module";
+import path from "node:path";
+import type { ITtscPlugin, ITtscPluginFactoryContext } from "ttsc";
+
+/**
+ * `@nestia/core` ttsc plugin descriptor.
+ *
+ * `@nestia/sdk` is not a standalone plugin: its Go transform is declared here
+ * as a `contributor` that ttsc statically links into this host binary, and only
+ * when `@nestia/sdk` is actually resolvable from the project. A project
+ * depending on `@nestia/core` alone never compiles any SDK transform code.
+ */
+export default function createTtscPlugin(
+  context: ITtscPluginFactoryContext,
+): ITtscPlugin {
+  const requireFrom = createRequire(
+    path.join(context.projectRoot, "package.json"),
+  );
+  const root: string = path.dirname(
+    requireFrom.resolve("@nestia/core/package.json"),
+  );
+  return {
+    name: "@nestia/core",
+    source: path.resolve(root, "native", "cmd", "ttsc-nestia"),
+  };
+}

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 = {};

package/src/utils/SourceFinder.ts

@@ -1,54 +1,54 @@
-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 = async (pattern: string): Promise<string[]> => {
-    const matches = await glob(pattern);
-    return 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 = async (pattern: string): Promise<string[]> => {
+    const matches = await glob(pattern);
+    return matches.map((str) => path.resolve(str));
+  };
+}
+
+interface IProps {
+  exclude?: string[];
+  include: string[];
+  filter: (location: string) => boolean;
+}

package/src/utils/VersioningStrategy.ts

@@ -1,27 +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}`,
-          )
-        : [];
-    };
-}
+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}`,
+          )
+        : [];
+    };
+}