@nestia/core 0.1.5 → 0.1.7

package/src/transformers/NodeTransformer.ts

@@ -1,18 +1,18 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { MethodTransformer } from "./MethodTransformer";
-import { ParameterTransformer } from "./ParameterTransformer";
-
-export namespace NodeTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        node: ts.Node,
-    ): ts.Node {
-        if (ts.isMethodDeclaration(node))
-            return MethodTransformer.transform(project, node);
-        else if (ts.isParameter(node))
-            return ParameterTransformer.transform(project, node);
-        return node;
-    }
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { MethodTransformer } from "./MethodTransformer";
+import { ParameterTransformer } from "./ParameterTransformer";
+
+export namespace NodeTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        node: ts.Node,
+    ): ts.Node {
+        if (ts.isMethodDeclaration(node))
+            return MethodTransformer.transform(project, node);
+        else if (ts.isParameter(node))
+            return ParameterTransformer.transform(project, node);
+        return node;
+    }
+}

package/src/transformers/ParameterTransformer.ts

@@ -1,45 +1,45 @@
-import ts from "typescript";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-import { BodyTransformer } from "./BodyTransformer";
-
-export namespace ParameterTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        param: ts.ParameterDeclaration,
-    ): ts.ParameterDeclaration {
-        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
-            ? ts.getDecorators(param)
-            : (param as any).decorators;
-        if (!decorators?.length) return param;
-
-        const type: ts.Type = project.checker.getTypeAtLocation(param);
-        if (ts.getDecorators !== undefined)
-            return ts.factory.updateParameterDeclaration(
-                param,
-                (param.modifiers || []).map((mod) =>
-                    ts.isDecorator(mod)
-                        ? BodyTransformer.transform(project, type, mod)
-                        : mod,
-                ),
-                param.dotDotDotToken,
-                param.name,
-                param.questionToken,
-                param.type,
-                param.initializer,
-            );
-        // eslint-disable-next-line
-        return ts.factory.updateParameterDeclaration(
-            param,
-            decorators.map((deco) =>
-                BodyTransformer.transform(project, type, deco),
-            ),
-            (param as any).modifiers,
-            param.dotDotDotToken,
-            param.name,
-            param.questionToken,
-            param.type,
-            param.initializer,
-        );
-    }
-}
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { BodyTransformer } from "./BodyTransformer";
+
+export namespace ParameterTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        param: ts.ParameterDeclaration,
+    ): ts.ParameterDeclaration {
+        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+            ? ts.getDecorators(param)
+            : (param as any).decorators;
+        if (!decorators?.length) return param;
+
+        const type: ts.Type = project.checker.getTypeAtLocation(param);
+        if (ts.getDecorators !== undefined)
+            return ts.factory.updateParameterDeclaration(
+                param,
+                (param.modifiers || []).map((mod) =>
+                    ts.isDecorator(mod)
+                        ? BodyTransformer.transform(project, type, mod)
+                        : mod,
+                ),
+                param.dotDotDotToken,
+                param.name,
+                param.questionToken,
+                param.type,
+                param.initializer,
+            );
+        // eslint-disable-next-line
+        return ts.factory.updateParameterDeclaration(
+            param,
+            decorators.map((deco) =>
+                BodyTransformer.transform(project, type, deco),
+            ),
+            (param as any).modifiers,
+            param.dotDotDotToken,
+            param.name,
+            param.questionToken,
+            param.type,
+            param.initializer,
+        );
+    }
+}

package/src/transformers/RouteTransformer.ts

@@ -1,131 +1,131 @@
-import path from "path";
-import ts from "typescript";
-import { AssertStringifyProgrammer } from "typia/lib/programmers/AssertStringifyProgrammer";
-import { IsStringifyProgrammer } from "typia/lib/programmers/IsStringifyProgrammer";
-import { StringifyProgrammer } from "typia/lib/programmers/StringifyProgrammer";
-import { ValidateStringifyProgrammer } from "typia/lib/programmers/ValidateStringifyProgrammer";
-import { IProject } from "typia/lib/transformers/IProject";
-
-import { INestiaTransformProject } from "../options/INestiaTransformProject";
-
-export namespace RouteTransformer {
-    export function transform(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        decorator: ts.Decorator,
-    ): ts.Decorator {
-        if (!ts.isCallExpression(decorator.expression)) return decorator;
-        return ts.factory.createDecorator(
-            stringify(project, type, decorator.expression),
-        );
-    }
-
-    function stringify(
-        project: INestiaTransformProject,
-        type: ts.Type,
-        expression: ts.CallExpression,
-    ): ts.LeftHandSideExpression {
-        //----
-        // VALIDATIONS
-        //----
-        // CHECK SIGNATURE
-        const signature: ts.Signature | undefined =
-            project.checker.getResolvedSignature(expression);
-        if (!signature || !signature.declaration) return expression;
-
-        // CHECK TO BE TRANSFORMED
-        const done: 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 DUPLICATE BOOSTER
-            if (expression.arguments.length >= 2) return false;
-            else if (expression.arguments.length === 1) {
-                const last: ts.Expression =
-                    expression.arguments[expression.arguments.length - 1];
-                const type: ts.Type = project.checker.getTypeAtLocation(last);
-                if (isObject(project.checker, type)) return false;
-            }
-            return true;
-        })();
-        if (done === false) return expression;
-
-        // CHECK TYPE NODE
-        const typeNode: ts.TypeNode | undefined =
-            project.checker.typeToTypeNode(type, undefined, undefined);
-        if (typeNode === undefined) return expression;
-
-        //----
-        // TRANSFORMATION
-        //----
-        // GENERATE STRINGIFY 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 stringify: ts.ObjectLiteralExpression = (() => {
-            if (project.options.stringify === "stringify")
-                return parameter("stringify", StringifyProgrammer.generate);
-            else if (project.options.stringify === "assert")
-                return parameter("assert", AssertStringifyProgrammer.generate);
-            else if (project.options.stringify === "validate")
-                return parameter(
-                    "validate",
-                    ValidateStringifyProgrammer.generate,
-                );
-            return parameter("is", IsStringifyProgrammer.generate);
-        })();
-
-        // UPDATE DECORATOR FUNCTION CALL
-        return ts.factory.updateCallExpression(
-            expression,
-            expression.expression,
-            expression.typeArguments,
-            [...expression.arguments, stringify],
-        );
-    }
-
-    function isObject(checker: ts.TypeChecker, type: ts.Type): boolean {
-        return (
-            (type.getFlags() & ts.TypeFlags.Object) !== 0 &&
-            !(checker as any).isTupleType(type) &&
-            !(checker as any).isArrayType(type) &&
-            !(checker as any).isArrayLikeType(type)
-        );
-    }
-
-    const CLASSES = ["EncryptedRoute", "TypedRoute"];
-    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 { AssertStringifyProgrammer } from "typia/lib/programmers/AssertStringifyProgrammer";
+import { IsStringifyProgrammer } from "typia/lib/programmers/IsStringifyProgrammer";
+import { StringifyProgrammer } from "typia/lib/programmers/StringifyProgrammer";
+import { ValidateStringifyProgrammer } from "typia/lib/programmers/ValidateStringifyProgrammer";
+import { IProject } from "typia/lib/transformers/IProject";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+
+export namespace RouteTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        decorator: ts.Decorator,
+    ): ts.Decorator {
+        if (!ts.isCallExpression(decorator.expression)) return decorator;
+        return ts.factory.createDecorator(
+            stringify(project, type, decorator.expression),
+        );
+    }
+
+    function stringify(
+        project: INestiaTransformProject,
+        type: ts.Type,
+        expression: ts.CallExpression,
+    ): ts.LeftHandSideExpression {
+        //----
+        // VALIDATIONS
+        //----
+        // CHECK SIGNATURE
+        const signature: ts.Signature | undefined =
+            project.checker.getResolvedSignature(expression);
+        if (!signature || !signature.declaration) return expression;
+
+        // CHECK TO BE TRANSFORMED
+        const done: 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 DUPLICATE BOOSTER
+            if (expression.arguments.length >= 2) return false;
+            else if (expression.arguments.length === 1) {
+                const last: ts.Expression =
+                    expression.arguments[expression.arguments.length - 1];
+                const type: ts.Type = project.checker.getTypeAtLocation(last);
+                if (isObject(project.checker, type)) return false;
+            }
+            return true;
+        })();
+        if (done === false) return expression;
+
+        // CHECK TYPE NODE
+        const typeNode: ts.TypeNode | undefined =
+            project.checker.typeToTypeNode(type, undefined, undefined);
+        if (typeNode === undefined) return expression;
+
+        //----
+        // TRANSFORMATION
+        //----
+        // GENERATE STRINGIFY 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 stringify: ts.ObjectLiteralExpression = (() => {
+            if (project.options.stringify === "stringify")
+                return parameter("stringify", StringifyProgrammer.generate);
+            else if (project.options.stringify === "assert")
+                return parameter("assert", AssertStringifyProgrammer.generate);
+            else if (project.options.stringify === "validate")
+                return parameter(
+                    "validate",
+                    ValidateStringifyProgrammer.generate,
+                );
+            return parameter("is", IsStringifyProgrammer.generate);
+        })();
+
+        // UPDATE DECORATOR FUNCTION CALL
+        return ts.factory.updateCallExpression(
+            expression,
+            expression.expression,
+            expression.typeArguments,
+            [...expression.arguments, stringify],
+        );
+    }
+
+    function isObject(checker: ts.TypeChecker, type: ts.Type): boolean {
+        return (
+            (type.getFlags() & ts.TypeFlags.Object) !== 0 &&
+            !(checker as any).isTupleType(type) &&
+            !(checker as any).isArrayType(type) &&
+            !(checker as any).isArrayLikeType(type)
+        );
+    }
+
+    const CLASSES = ["EncryptedRoute", "TypedRoute"];
+    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`)),
+    );
+}

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/utils/ExceptionManager.ts

@@ -1,126 +1,126 @@
-import { HttpError } from "@nestia/fetcher";
-import { HttpException } from "@nestjs/common";
-import { TypeGuardError } from "typia";
-
-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(
-    TypeGuardError,
-    (error) =>
-        new HttpException(
-            {
-                path: error.path,
-                reason: error.message,
-                message: "Request message is not following the promised type.",
-            },
-            400,
-        ),
-);
-
-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 { TypeGuardError } from "typia";
+
+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(
+    TypeGuardError,
+    (error) =>
+        new HttpException(
+            {
+                path: error.path,
+                reason: error.message,
+                message: "Request message is not following the promised type.",
+            },
+            400,
+        ),
+);
+
+ExceptionManager.insert(
+    HttpError,
+    (error) =>
+        new HttpException(
+            {
+                path: error.path,
+                message: error.message,
+            },
+            error.status,
+        ),
+);