@nestia/core 0.1.3 → 0.1.5

package/src/decorators/internal/route_error.ts

@@ -1,41 +1,38 @@
-import { HttpException } from "@nestjs/common";
-import express from "express";
-import { Observable, throwError } from "rxjs";
-
-import { ExceptionManager } from "../../utils/ExceptionManager";
-
-/**
- * @internal
- */
-export function route_error(
-    request: express.Request,
-    error: any,
-): Observable<never> {
-    error = (() => {
-        // HTTP-ERROR
-        if (error instanceof HttpException) return error;
-
-        // CUSTOM-REGISTERED ERROR
-        for (const [creator, closure] of ExceptionManager.tuples)
-            if (error instanceof creator) return closure(error);
-
-        // MAYBE INTERNAL ERROR
-        return error;
-    })();
-
-    try {
-        error.method = request.method;
-        error.path = request.path;
-    } catch {}
-
-    setTimeout(() => {
-        for (const listener of ExceptionManager.listeners) {
-            try {
-                const res: any | Promise<any> = listener(error);
-                if (typeof res === "object" && typeof res.catch === "function")
-                    res.catch(() => {});
-            } catch {}
-        }
-    }, 0);
-    return throwError(() => error);
-}
+import { HttpException } from "@nestjs/common";
+import express from "express";
+import { Observable, throwError } from "rxjs";
+
+import { ExceptionManager } from "../../utils/ExceptionManager";
+
+export function route_error(
+    request: express.Request,
+    error: any,
+): Observable<never> {
+    error = (() => {
+        // HTTP-ERROR
+        if (error instanceof HttpException) return error;
+
+        // CUSTOM-REGISTERED ERROR
+        for (const [creator, closure] of ExceptionManager.tuples)
+            if (error instanceof creator) return closure(error);
+
+        // MAYBE INTERNAL ERROR
+        return error;
+    })();
+
+    try {
+        error.method = request.method;
+        error.path = request.path;
+    } catch {}
+
+    setTimeout(() => {
+        for (const listener of ExceptionManager.listeners) {
+            try {
+                const res: any | Promise<any> = listener(error);
+                if (typeof res === "object" && typeof res.catch === "function")
+                    res.catch(() => {});
+            } catch {}
+        }
+    }, 0);
+    return throwError(() => error);
+}

package/src/decorators/internal/validate_request_body.ts

@@ -1,58 +1,59 @@
-import { BadRequestException } from "@nestjs/common";
-import { IValidation, TypeGuardError } from "typia";
-
-import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
-
-export const validate_request_body =
-    (method: string) =>
-    <T>(validator?: IRequestBodyValidator<T>) => {
-        if (!validator)
-            throw new Error(
-                `Error on nestia.core.${method}(): no transformer.`,
-            );
-        else if (validator.type === "assert") return assert(validator.assert);
-        else if (validator.type === "is") return is(validator.is);
-        else if (validator.type === "validate")
-            return validate(validator.validate);
-        throw new Error(
-            `Error on nestia.core.${method}(): invalid typed validator.`,
-        );
-    };
-
-const assert =
-    <T>(closure: (data: T) => T) =>
-    (data: T) => {
-        try {
-            closure(data);
-        } catch (exp) {
-            if (exp instanceof TypeGuardError) {
-                throw new BadRequestException({
-                    path: exp.path,
-                    reason: exp.message,
-                    expected: exp.expected,
-                    message: MESSAGE,
-                });
-            }
-            throw exp;
-        }
-    };
-
-const is =
-    <T>(closure: (data: T) => boolean) =>
-    (data: T) => {
-        const success: boolean = closure(data);
-        if (success === false) throw new BadRequestException(MESSAGE);
-    };
-
-const validate =
-    <T>(closure: (data: T) => IValidation<T>) =>
-    (data: T) => {
-        const result: IValidation<T> = closure(data);
-        if (result.success === false)
-            throw new BadRequestException({
-                errors: result.errors,
-                message: MESSAGE,
-            });
-    };
-
-const MESSAGE = "Request body data is not following the promised type.";
+import { BadRequestException } from "@nestjs/common";
+import { IValidation, TypeGuardError } from "typia";
+
+import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
+
+export const validate_request_body =
+    (method: string) =>
+    <T>(validator?: IRequestBodyValidator<T>) => {
+        if (!validator)
+            throw new Error(
+                `Error on nestia.core.${method}(): no transformer.`,
+            );
+        else if (validator.type === "assert") return assert(validator.assert);
+        else if (validator.type === "is") return is(validator.is);
+        else if (validator.type === "validate")
+            return validate(validator.validate);
+        throw new Error(
+            `Error on nestia.core.${method}(): invalid typed validator.`,
+        );
+    };
+
+const assert =
+    <T>(closure: (data: T) => T) =>
+    (data: T) => {
+        try {
+            closure(data);
+        } catch (exp) {
+            if (exp instanceof TypeGuardError) {
+                throw new BadRequestException({
+                    path: exp.path,
+                    reason: exp.message,
+                    expected: exp.expected,
+                    value: exp.value,
+                    message: MESSAGE,
+                });
+            }
+            throw exp;
+        }
+    };
+
+const is =
+    <T>(closure: (data: T) => boolean) =>
+    (data: T) => {
+        const success: boolean = closure(data);
+        if (success === false) throw new BadRequestException(MESSAGE);
+    };
+
+const validate =
+    <T>(closure: (data: T) => IValidation<T>) =>
+    (data: T) => {
+        const result: IValidation<T> = closure(data);
+        if (result.success === false)
+            throw new BadRequestException({
+                errors: result.errors,
+                message: MESSAGE,
+            });
+    };
+
+const MESSAGE = "Request body data is not following the promised type.";

package/src/index.ts

@@ -1,5 +1,5 @@
-import * as core from "./module";
-
-export * from "./module";
-
-export default core;
+import * as core from "./module";
+
+export * from "./module";
+
+export default core;

package/src/module.ts

@@ -1,9 +1,11 @@
-export * from "./decorators/EncryptedBody";
-export * from "./decorators/EncryptedController";
-export * from "./decorators/EncryptedModule";
-export * from "./decorators/EncryptedRoute";
-export * from "./utils/ExceptionManager";
-export * from "./decorators/PlainBody";
-export * from "./decorators/TypedBody";
-export * from "./decorators/TypedParam";
-export * from "./decorators/TypedRoute";
+export * from "./decorators/DynamicModule";
+export * from "./decorators/EncryptedBody";
+export * from "./decorators/EncryptedController";
+export * from "./decorators/EncryptedModule";
+export * from "./decorators/EncryptedRoute";
+export * from "./utils/ExceptionManager";
+export * from "./decorators/PlainBody";
+export * from "./decorators/TypedBody";
+export * from "./decorators/TypedParam";
+export * from "./decorators/TypedRoute";
+export * from "./options/INestiaTransformOptions";

package/src/options/INestiaTransformOptions.ts

@@ -1,6 +1,6 @@
-import { ITransformOptions } from "typia/lib/transformers/ITransformOptions";
-
-export interface INestiaTransformOptions extends ITransformOptions {
-    validate?: "assert" | "is" | "validate";
-    stringify?: "stringify" | "assert" | "is" | "validate";
-}
+import { ITransformOptions } from "typia/lib/transformers/ITransformOptions";
+
+export interface INestiaTransformOptions extends ITransformOptions {
+    validate?: "assert" | "is" | "validate";
+    stringify?: "stringify" | "assert" | "is" | "validate";
+}

package/src/options/INestiaTransformProject.ts

@@ -1,6 +1,7 @@
-import { IProject } from "typia/lib/transformers/IProject";
-import { INestiaTransformOptions } from "./INestiaTransformOptions";
-
-export interface INestiaTransformProject extends Omit<IProject, "options"> {
-    options: INestiaTransformOptions;
-}
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformOptions } from "./INestiaTransformOptions";
+
+export interface INestiaTransformProject extends Omit<IProject, "options"> {
+    options: INestiaTransformOptions;
+}

package/src/options/IRequestBodyValidator.ts

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

package/src/options/IResponseBodyStringifier.ts

@@ -1,25 +1,25 @@
-import { IValidation } from "typia";
-
-export type IResponseBodyStringifier<T> =
-    | IResponseBodyStringifier.IStringify<T>
-    | IResponseBodyStringifier.IIs<T>
-    | IResponseBodyStringifier.IAssert<T>
-    | IResponseBodyStringifier.IValidate<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>;
-    }
-}
+import { IValidation } from "typia";
+
+export type IResponseBodyStringifier<T> =
+    | IResponseBodyStringifier.IStringify<T>
+    | IResponseBodyStringifier.IIs<T>
+    | IResponseBodyStringifier.IAssert<T>
+    | IResponseBodyStringifier.IValidate<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>;
+    }
+}

package/src/transform.ts

@@ -1,20 +1,20 @@
-import ts from "typescript";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
-import { FileTransformer } from "./transformers/FileTransformer";
-
-export default function transform(
-    program: ts.Program,
-    options?: INestiaTransformOptions,
-): ts.TransformerFactory<ts.SourceFile> {
-    const project: IProject = {
-        program,
-        compilerOptions: program.getCompilerOptions(),
-        checker: program.getTypeChecker(),
-        printer: ts.createPrinter(),
-        options: options || {},
-    };
-    return (context) => (file) =>
-        FileTransformer.transform(project, context, file);
-}
+import ts from "typescript";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformOptions } from "./options/INestiaTransformOptions";
+import { FileTransformer } from "./transformers/FileTransformer";
+
+export default function transform(
+    program: ts.Program,
+    options?: INestiaTransformOptions,
+): ts.TransformerFactory<ts.SourceFile> {
+    const project: IProject = {
+        program,
+        compilerOptions: program.getCompilerOptions(),
+        checker: program.getTypeChecker(),
+        printer: ts.createPrinter(),
+        options: options || {},
+    };
+    return (context) => (file) =>
+        FileTransformer.transform(project, context, file);
+}

package/src/transformers/BodyTransformer.ts

@@ -1,106 +1,106 @@
-import path from "path";
-import ts from "typescript";
-import { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
-import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
-import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace BodyTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        decorator: ts.Decorator,
-    ): ts.Decorator {
-        if (!ts.isCallExpression(decorator.expression)) return decorator;
-        return ts.factory.createDecorator(
-            validate(project, type, decorator.expression),
-        );
-    }
-
-    function validate(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        expression: ts.CallExpression,
-    ): ts.LeftHandSideExpression {
-        // CHECK SIGNATURE
-        const signature: ts.Signature | undefined =
-            project.checker.getResolvedSignature(expression);
-        if (!signature || !signature.declaration) return expression;
-
-        // CHECK TO BE TRANSFORMED
-        const validate: boolean = (() => {
-            // 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 false;
-
-            // CHECK DUPLICATED TRANSFORMATION
-            return expression.arguments.length === 0;
-        })();
-        if (validate === false) return expression;
-
-        // CHECK TYPE NODE
-        const typeNode: ts.TypeNode | undefined =
-            project.checker.typeToTypeNode(type, undefined, undefined);
-        if (typeNode === undefined) return expression;
-
-        //----
-        // TRANSFORMATION
-        //----
-        // GENERATE VALIDATION PLAN
-        const parameter = (
-            key: string,
-            programmer: (
-                project: IProject,
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type) => ts.ArrowFunction,
-        ) =>
-            ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(
-                    ts.factory.createIdentifier("type"),
-                    ts.factory.createStringLiteral(key),
-                ),
-                ts.factory.createPropertyAssignment(
-                    ts.factory.createIdentifier(key),
-                    programmer(project, expression.expression)(type),
-                ),
-            ]);
-        const validator: ts.ObjectLiteralExpression = (() => {
-            if (project.options.validate === "is")
-                return parameter("is", IsProgrammer.generate);
-            else if (project.options.validate === "validate")
-                return parameter("validate", ValidateProgrammer.generate);
-            return parameter("assert", AssertProgrammer.generate);
-        })();
-
-        // UPDATE DECORATOR FUNCTION CALL
-        return ts.factory.updateCallExpression(
-            expression,
-            expression.expression,
-            expression.typeArguments,
-            [validator],
-        );
-    }
-
-    const CLASSES = ["EncryptedBody", "TypedBody"];
-    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 { AssertProgrammer } from "typia/lib/programmers/AssertProgrammer";
+import { IsProgrammer } from "typia/lib/programmers/IsProgrammer";
+import { ValidateProgrammer } from "typia/lib/programmers/ValidateProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace BodyTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        decorator: ts.Decorator,
+    ): ts.Decorator {
+        if (!ts.isCallExpression(decorator.expression)) return decorator;
+        return ts.factory.createDecorator(
+            validate(project, type, decorator.expression),
+        );
+    }
+
+    function validate(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        expression: ts.CallExpression,
+    ): ts.LeftHandSideExpression {
+        // CHECK SIGNATURE
+        const signature: ts.Signature | undefined =
+            project.checker.getResolvedSignature(expression);
+        if (!signature || !signature.declaration) return expression;
+
+        // CHECK TO BE TRANSFORMED
+        const validate: boolean = (() => {
+            // 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 false;
+
+            // CHECK DUPLICATED TRANSFORMATION
+            return expression.arguments.length === 0;
+        })();
+        if (validate === false) return expression;
+
+        // CHECK TYPE NODE
+        const typeNode: ts.TypeNode | undefined =
+            project.checker.typeToTypeNode(type, undefined, undefined);
+        if (typeNode === undefined) return expression;
+
+        //----
+        // TRANSFORMATION
+        //----
+        // GENERATE VALIDATION PLAN
+        const parameter = (
+            key: string,
+            programmer: (
+                project: IProject,
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type) => ts.ArrowFunction,
+        ) =>
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("type"),
+                    ts.factory.createStringLiteral(key),
+                ),
+                ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier(key),
+                    programmer(project, expression.expression)(type),
+                ),
+            ]);
+        const validator: ts.ObjectLiteralExpression = (() => {
+            if (project.options.validate === "is")
+                return parameter("is", IsProgrammer.generate);
+            else if (project.options.validate === "validate")
+                return parameter("validate", ValidateProgrammer.generate);
+            return parameter("assert", AssertProgrammer.generate);
+        })();
+
+        // UPDATE DECORATOR FUNCTION CALL
+        return ts.factory.updateCallExpression(
+            expression,
+            expression.expression,
+            expression.typeArguments,
+            [validator],
+        );
+    }
+
+    const CLASSES = ["EncryptedBody", "TypedBody"];
+    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`)),
+    );
+}