@nestia/core 0.1.4 → 0.1.5

package/src/decorators/TypedParam.ts

@@ -1,70 +1,70 @@
-import {
-    BadRequestException,
-    ExecutionContext,
-    createParamDecorator,
-} from "@nestjs/common";
-import type express from "express";
-
-/**
- * URL parameter decorator with type.
- *
- * `TypedParam` is a decorator function getting specific typed parameter from the HTTP
- * request URL. It's almost same with the {@link nest.Param}, but `TypedParam` can specify
- * the parameter type manually. Beside, the {@link nest.Param} always parses all of the
- * parameters as string type.
- *
- * ```typescript
- * \@TypedRoute.Get("shopping/sales/:section/:id/:paused")
- * public async pause
- *     (
- *         \@TypedParam("section", "string") section: string,
- *         \@TypedParam("id", "number") id: number,
- *         \@TypedParam("paused", "boolean", true) paused: boolean | null
- *     ): Promise<void>;
- * ```
- *
- * @param name URL Parameter name
- * @param type Type of the URL parameter
- * @returns Parameter decorator
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export function TypedParam(
-    name: string,
-    type: "boolean" | "number" | "string" | "uuid" = "string",
-    nullable: boolean = false,
-) {
-    return createParamDecorator(function TypedParam(
-        {}: any,
-        ctx: ExecutionContext,
-    ) {
-        const request: express.Request = ctx.switchToHttp().getRequest();
-        const str: string = request.params[name];
-
-        if (nullable === true && str === "null") return null;
-        else if (type === "boolean") {
-            if (str === "true" || str === "1") return true;
-            else if (str === "false" || str === "0") return false;
-            else
-                throw new BadRequestException(
-                    `Value of the URL parameter '${name}' is not a boolean.`,
-                );
-        } else if (type === "number") {
-            const value: number = Number(str);
-            if (isNaN(value))
-                throw new BadRequestException(
-                    `Value of the URL parameter "${name}" is not a number.`,
-                );
-            return value;
-        } else if (type === "uuid") {
-            if (UUID_PATTERN.test(str) === false)
-                throw new BadRequestException(
-                    `Value of the URL parameter "${name}" is not a valid UUID.`,
-                );
-            return str;
-        } else return str;
-    })(name);
-}
-
-const UUID_PATTERN =
-    /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
+import {
+    BadRequestException,
+    ExecutionContext,
+    createParamDecorator,
+} from "@nestjs/common";
+import type express from "express";
+
+/**
+ * URL parameter decorator with type.
+ *
+ * `TypedParam` is a decorator function getting specific typed parameter from the HTTP
+ * request URL. It's almost same with the {@link nest.Param}, but `TypedParam` can specify
+ * the parameter type manually. Beside, the {@link nest.Param} always parses all of the
+ * parameters as string type.
+ *
+ * ```typescript
+ * \@TypedRoute.Get("shopping/sales/:section/:id/:paused")
+ * public async pause
+ *     (
+ *         \@TypedParam("section", "string") section: string,
+ *         \@TypedParam("id", "number") id: number,
+ *         \@TypedParam("paused", "boolean", true) paused: boolean | null
+ *     ): Promise<void>;
+ * ```
+ *
+ * @param name URL Parameter name
+ * @param type Type of the URL parameter
+ * @returns Parameter decorator
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function TypedParam(
+    name: string,
+    type: "boolean" | "number" | "string" | "uuid" = "string",
+    nullable: boolean = false,
+) {
+    return createParamDecorator(function TypedParam(
+        {}: any,
+        ctx: ExecutionContext,
+    ) {
+        const request: express.Request = ctx.switchToHttp().getRequest();
+        const str: string = request.params[name];
+
+        if (nullable === true && str === "null") return null;
+        else if (type === "boolean") {
+            if (str === "true" || str === "1") return true;
+            else if (str === "false" || str === "0") return false;
+            else
+                throw new BadRequestException(
+                    `Value of the URL parameter '${name}' is not a boolean.`,
+                );
+        } else if (type === "number") {
+            const value: number = Number(str);
+            if (isNaN(value))
+                throw new BadRequestException(
+                    `Value of the URL parameter "${name}" is not a number.`,
+                );
+            return value;
+        } else if (type === "uuid") {
+            if (UUID_PATTERN.test(str) === false)
+                throw new BadRequestException(
+                    `Value of the URL parameter "${name}" is not a valid UUID.`,
+                );
+            return str;
+        } else return str;
+    })(name);
+}
+
+const UUID_PATTERN =
+    /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;

package/src/decorators/TypedRoute.ts

@@ -1,149 +1,149 @@
-import {
-    CallHandler,
-    Delete,
-    ExecutionContext,
-    Get,
-    NestInterceptor,
-    Patch,
-    Post,
-    Put,
-    UseInterceptors,
-    applyDecorators,
-} from "@nestjs/common";
-import { HttpArgumentsHost } from "@nestjs/common/interfaces";
-import express from "express";
-import { Observable, catchError, map } from "rxjs";
-import {
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-} from "typia";
-
-import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
-import { get_path_and_stringify } from "./internal/get_path_and_stringify";
-import { route_error } from "./internal/route_error";
-
-/**
- * Safe router decorator functions.
- *
- * `TypedRoute` is a module containing router decorator functions which can boost up
- * JSON string conversion speed about 5x times faster, through
- * [`typia.stringify()`](https://github.com/samchon/typia#fastest-json-string-conversion).
- *
- * Also, router functions in `TypedRoute` can convert custom error classes to the
- * regular {@link nest.HttpException} class automatically, through
- * {@link ExceptionManager}.
- *
- * @author Jeongho Nam - https://github.com/samchon
- */
-export namespace TypedRoute {
-    /**
-     * Router decorator function for the GET method.
-     *
-     * @param path Path of the HTTP request
-     * @returns Method decorator
-     */
-    export const Get = Generator("Get");
-
-    /**
-     * Router decorator function for the POST method.
-     *
-     * @param path Path of the HTTP request
-     * @returns Method decorator
-     */
-    export const Post = Generator("Post");
-
-    /**
-     * Router decorator function for the PATH method.
-     *
-     * @param path Path of the HTTP request
-     * @returns Method decorator
-     */
-    export const Patch = Generator("Patch");
-
-    /**
-     * Router decorator function for the PUT method.
-     *
-     * @param path Path of the HTTP request
-     * @returns Method decorator
-     */
-    export const Put = Generator("Put");
-
-    /**
-     * Router decorator function for the DELETE method.
-     *
-     * @param path Path of the HTTP request
-     * @returns Method decorator
-     */
-    export const Delete = Generator("Delete");
-
-    /**
-     * @internal
-     */
-    function Generator(method: "Get" | "Post" | "Put" | "Patch" | "Delete") {
-        function route(path?: string | string[]): MethodDecorator;
-        function route<T>(
-            stringify?: IResponseBodyStringifier<T>,
-        ): MethodDecorator;
-        function route<T>(
-            path: string | string[],
-            stringify?: IResponseBodyStringifier<T>,
-        ): MethodDecorator;
-
-        function route(...args: any[]): MethodDecorator {
-            const [path, stringify] = get_path_and_stringify(
-                `TypedRoute.${method}`,
-            )(...args);
-            return applyDecorators(
-                ROUTERS[method](path),
-                UseInterceptors(new TypedRouteInterceptor(stringify)),
-            );
-        }
-        return route;
-    }
-}
-for (const method of [
-    assertStringify,
-    isStringify,
-    stringify,
-    validateStringify,
-]) {
-    Object.assign(TypedRoute.Get, method);
-    Object.assign(TypedRoute.Delete, method);
-    Object.assign(TypedRoute.Post, method);
-    Object.assign(TypedRoute.Put, method);
-    Object.assign(TypedRoute.Patch, method);
-}
-
-/**
- * @internal
- */
-class TypedRouteInterceptor implements NestInterceptor {
-    public constructor(private readonly stringify: (input: any) => string) {}
-
-    public intercept(
-        context: ExecutionContext,
-        next: CallHandler,
-    ): Observable<any> {
-        const http: HttpArgumentsHost = context.switchToHttp();
-        const response: express.Response = http.getResponse();
-        response.header("Content-Type", "application/json");
-
-        return next.handle().pipe(
-            map((value) => this.stringify(value)),
-            catchError((err) => route_error(http.getRequest(), err)),
-        );
-    }
-}
-
-/**
- * @internal
- */
-const ROUTERS = {
-    Get,
-    Post,
-    Patch,
-    Put,
-    Delete,
-};
+import {
+    CallHandler,
+    Delete,
+    ExecutionContext,
+    Get,
+    NestInterceptor,
+    Patch,
+    Post,
+    Put,
+    UseInterceptors,
+    applyDecorators,
+} from "@nestjs/common";
+import { HttpArgumentsHost } from "@nestjs/common/interfaces";
+import express from "express";
+import { Observable, catchError, map } from "rxjs";
+import {
+    assertStringify,
+    isStringify,
+    stringify,
+    validateStringify,
+} from "typia";
+
+import { IResponseBodyStringifier } from "../options/IResponseBodyStringifier";
+import { get_path_and_stringify } from "./internal/get_path_and_stringify";
+import { route_error } from "./internal/route_error";
+
+/**
+ * Safe router decorator functions.
+ *
+ * `TypedRoute` is a module containing router decorator functions which can boost up
+ * JSON string conversion speed about 5x times faster, through
+ * [`typia.stringify()`](https://github.com/samchon/typia#fastest-json-string-conversion).
+ *
+ * Also, router functions in `TypedRoute` can convert custom error classes to the
+ * regular {@link nest.HttpException} class automatically, through
+ * {@link ExceptionManager}.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace TypedRoute {
+    /**
+     * Router decorator function for the GET method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Get = Generator("Get");
+
+    /**
+     * Router decorator function for the POST method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Post = Generator("Post");
+
+    /**
+     * Router decorator function for the PATH method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Patch = Generator("Patch");
+
+    /**
+     * Router decorator function for the PUT method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Put = Generator("Put");
+
+    /**
+     * Router decorator function for the DELETE method.
+     *
+     * @param path Path of the HTTP request
+     * @returns Method decorator
+     */
+    export const Delete = Generator("Delete");
+
+    /**
+     * @internal
+     */
+    function Generator(method: "Get" | "Post" | "Put" | "Patch" | "Delete") {
+        function route(path?: string | string[]): MethodDecorator;
+        function route<T>(
+            stringify?: IResponseBodyStringifier<T>,
+        ): MethodDecorator;
+        function route<T>(
+            path: string | string[],
+            stringify?: IResponseBodyStringifier<T>,
+        ): MethodDecorator;
+
+        function route(...args: any[]): MethodDecorator {
+            const [path, stringify] = get_path_and_stringify(
+                `TypedRoute.${method}`,
+            )(...args);
+            return applyDecorators(
+                ROUTERS[method](path),
+                UseInterceptors(new TypedRouteInterceptor(stringify)),
+            );
+        }
+        return route;
+    }
+}
+for (const method of [
+    assertStringify,
+    isStringify,
+    stringify,
+    validateStringify,
+]) {
+    Object.assign(TypedRoute.Get, method);
+    Object.assign(TypedRoute.Delete, method);
+    Object.assign(TypedRoute.Post, method);
+    Object.assign(TypedRoute.Put, method);
+    Object.assign(TypedRoute.Patch, method);
+}
+
+/**
+ * @internal
+ */
+class TypedRouteInterceptor implements NestInterceptor {
+    public constructor(private readonly stringify: (input: any) => string) {}
+
+    public intercept(
+        context: ExecutionContext,
+        next: CallHandler,
+    ): Observable<any> {
+        const http: HttpArgumentsHost = context.switchToHttp();
+        const response: express.Response = http.getResponse();
+        response.header("Content-Type", "application/json");
+
+        return next.handle().pipe(
+            map((value) => this.stringify(value)),
+            catchError((err) => route_error(http.getRequest(), err)),
+        );
+    }
+}
+
+/**
+ * @internal
+ */
+const ROUTERS = {
+    Get,
+    Post,
+    Patch,
+    Put,
+    Delete,
+};

package/src/decorators/internal/EncryptedConstant.ts

@@ -1,4 +1,4 @@
-/**
- * @internal
- */
-export const ENCRYPTION_METADATA_KEY = "nestia:core:encryption:password";
+/**
+ * @internal
+ */
+export const ENCRYPTION_METADATA_KEY = "nestia:core:encryption:password";

package/src/decorators/internal/get_path_and_stringify.ts

@@ -1,77 +1,77 @@
-import { InternalServerErrorException } from "@nestjs/common";
-import { IValidation, TypeGuardError } from "typia";
-
-import { IResponseBodyStringifier } from "../../options/IResponseBodyStringifier";
-
-export const get_path_and_stringify =
-    (method: string) =>
-    (
-        ...args: any[]
-    ): [string | string[] | undefined, (input: any) => string] => {
-        const path: string | string[] | null | undefined =
-            args[0] === undefined ||
-            typeof args[0] === "string" ||
-            Array.isArray(args[0])
-                ? args[0]
-                : null;
-        const functor: IResponseBodyStringifier<any> | undefined =
-            path === null ? args[0] : args[1];
-        return [path ?? undefined, take(method)(functor)];
-    };
-
-const take =
-    (method: string) =>
-    <T>(functor?: IResponseBodyStringifier<T>) => {
-        if (functor === undefined)
-            throw new Error(
-                `Error on nestia.core.${method}(): no stringify function provided.`,
-            );
-        else if (functor.type === "stringify") return functor.stringify;
-        else if (functor.type === "assert") return assert(functor.assert);
-        else if (functor.type === "is") return is(functor.is);
-        else if (functor.type === "validate") return validate(functor.validate);
-        throw new Error(
-            `Error on nestia.core.${method}(): invalid typed stringify function.`,
-        );
-    };
-
-const assert =
-    <T>(closure: (data: T) => string) =>
-    (data: T) => {
-        try {
-            return closure(data);
-        } catch (exp) {
-            if (exp instanceof TypeGuardError) {
-                throw new InternalServerErrorException({
-                    path: exp.path,
-                    reason: exp.message,
-                    expected: exp.expected,
-                    value: exp.value,
-                    message: MESSAGE,
-                });
-            }
-            throw exp;
-        }
-    };
-
-const is =
-    <T>(closure: (data: T) => string | null) =>
-    (data: T) => {
-        const result: string | null = closure(data);
-        if (result === null) throw new InternalServerErrorException(MESSAGE);
-        return result;
-    };
-
-const validate =
-    <T>(closure: (data: T) => IValidation<string>) =>
-    (data: T) => {
-        const result: IValidation<string> = closure(data);
-        if (result.success === false)
-            throw new InternalServerErrorException({
-                errors: result.errors,
-                message: MESSAGE,
-            });
-        return result.data;
-    };
-
-const MESSAGE = "Response body data is not following the promised type.";
+import { InternalServerErrorException } from "@nestjs/common";
+import { IValidation, TypeGuardError } from "typia";
+
+import { IResponseBodyStringifier } from "../../options/IResponseBodyStringifier";
+
+export const get_path_and_stringify =
+    (method: string) =>
+    (
+        ...args: any[]
+    ): [string | string[] | undefined, (input: any) => string] => {
+        const path: string | string[] | null | undefined =
+            args[0] === undefined ||
+            typeof args[0] === "string" ||
+            Array.isArray(args[0])
+                ? args[0]
+                : null;
+        const functor: IResponseBodyStringifier<any> | undefined =
+            path === null ? args[0] : args[1];
+        return [path ?? undefined, take(method)(functor)];
+    };
+
+const take =
+    (method: string) =>
+    <T>(functor?: IResponseBodyStringifier<T>) => {
+        if (functor === undefined)
+            throw new Error(
+                `Error on nestia.core.${method}(): no stringify function provided.`,
+            );
+        else if (functor.type === "stringify") return functor.stringify;
+        else if (functor.type === "assert") return assert(functor.assert);
+        else if (functor.type === "is") return is(functor.is);
+        else if (functor.type === "validate") return validate(functor.validate);
+        throw new Error(
+            `Error on nestia.core.${method}(): invalid typed stringify function.`,
+        );
+    };
+
+const assert =
+    <T>(closure: (data: T) => string) =>
+    (data: T) => {
+        try {
+            return closure(data);
+        } catch (exp) {
+            if (exp instanceof TypeGuardError) {
+                throw new InternalServerErrorException({
+                    path: exp.path,
+                    reason: exp.message,
+                    expected: exp.expected,
+                    value: exp.value,
+                    message: MESSAGE,
+                });
+            }
+            throw exp;
+        }
+    };
+
+const is =
+    <T>(closure: (data: T) => string | null) =>
+    (data: T) => {
+        const result: string | null = closure(data);
+        if (result === null) throw new InternalServerErrorException(MESSAGE);
+        return result;
+    };
+
+const validate =
+    <T>(closure: (data: T) => IValidation<string>) =>
+    (data: T) => {
+        const result: IValidation<string> = closure(data);
+        if (result.success === false)
+            throw new InternalServerErrorException({
+                errors: result.errors,
+                message: MESSAGE,
+            });
+        return result.data;
+    };
+
+const MESSAGE = "Response body data is not following the promised type.";

package/src/decorators/internal/headers_to_object.ts

@@ -1,13 +1,10 @@
-import http from "http";
-
-/**
- * @internal
- */
-export function headers_to_object(
-    headers: http.IncomingHttpHeaders,
-): Record<string, string> {
-    const output: Record<string, string> = {};
-    for (const [key, value] of Object.entries(headers))
-        output[key] = value instanceof Array ? value[0] : value || "";
-    return output;
-}
+import http from "http";
+
+export function headers_to_object(
+    headers: http.IncomingHttpHeaders,
+): Record<string, string> {
+    const output: Record<string, string> = {};
+    for (const [key, value] of Object.entries(headers))
+        output[key] = value instanceof Array ? value[0] : value || "";
+    return output;
+}

package/src/decorators/internal/load_controller.ts

@@ -0,0 +1,35 @@
+import is_ts_node from "detect-ts-node";
+import fs from "fs";
+
+import { Creator } from "../../typings/Creator";
+
+export async function load_controllers(
+    path: string,
+): Promise<Creator<object>[]> {
+    const output: any[] = [];
+    await iterate(output, path);
+    return output;
+}
+
+async function iterate(
+    controllers: Creator<object>[],
+    path: string,
+): Promise<void> {
+    const directory: string[] = await fs.promises.readdir(path);
+    for (const file of directory) {
+        const current: string = `${path}/${file}`;
+        const stats: fs.Stats = await fs.promises.lstat(current);
+
+        if (stats.isDirectory() === true) await iterate(controllers, current);
+        else if (file.substring(file.length - 3) === `.${EXTENSION}`) {
+            const external: any = await import(current);
+            for (const key in external) {
+                const instance: Creator<object> = external[key];
+                if (Reflect.getMetadata("path", instance) !== undefined)
+                    controllers.push(instance);
+            }
+        }
+    }
+}
+
+const EXTENSION = is_ts_node ? "ts" : "js";