@nestia/core 3.0.0-dev.20231209 → 3.0.0

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

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;
+}

package/lib/decorators/internal/get_binary_body.js

@@ -1,66 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.get_binary_body = void 0;
-var raw_body_1 = __importDefault(require("raw-body"));
-/**
- * @internal
- */
-var get_binary_body = function (request) { return __awaiter(void 0, void 0, void 0, function () { var _a; return __generator(this, function (_b) {
-    switch (_b.label) {
-        case 0:
-            if (!isExpressRequest(request)) return [3 /*break*/, 2];
-            return [4 /*yield*/, (0, raw_body_1.default)(request)];
-        case 1:
-            _a = _b.sent();
-            return [3 /*break*/, 3];
-        case 2:
-            _a = request.body;
-            _b.label = 3;
-        case 3: return [2 /*return*/, _a];
-    }
-}); }); };
-exports.get_binary_body = get_binary_body;
-/**
- * @internal
- */
-var isExpressRequest = function (request) { return request.app !== undefined; };
-//# sourceMappingURL=get_binary_body.js.map

package/lib/decorators/internal/get_binary_body.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get_binary_body.js","sourceRoot":"","sources":["../../../src/decorators/internal/get_binary_body.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,sDAA2B;AAE3B;;GAEG;AACI,IAAM,eAAe,GAAG,UAC7B,OAAyC;;;iBAEzC,gBAAgB,CAAC,OAAO,CAAC,EAAzB,wBAAyB;YAAG,qBAAM,IAAA,kBAAG,EAAC,OAAO,CAAC,EAAA;;YAAlB,KAAA,SAAkB,CAAA;;;YAAG,KAAC,OAAO,CAAC,IAAmB,CAAA;;gBAA7E,0BAA6E;;SAAA,CAAC;AAHnE,QAAA,eAAe,mBAGoD;AAEhF;;GAEG;AACH,IAAM,gBAAgB,GAAG,UACvB,OAAyC,IACV,OAAC,OAA2B,CAAC,GAAG,KAAK,SAAS,EAA9C,CAA8C,CAAC"}

package/src/decorators/internal/get_binary_body.ts

@@ -1,18 +0,0 @@
-import type express from "express";
-import type { FastifyRequest } from "fastify";
-import raw from "raw-body";
-
-/**
- * @internal
- */
-export const get_binary_body = async (
-  request: express.Request | FastifyRequest,
-): Promise<Uint8Array> =>
-  isExpressRequest(request) ? await raw(request) : (request.body as Uint8Array);
-
-/**
- * @internal
- */
-const isExpressRequest = (
-  request: express.Request | FastifyRequest,
-): request is express.Request => (request as express.Request).app !== undefined;