@nestia/core 0.1.0

package/src/transformers/MethodTransformer.ts

@@ -0,0 +1,91 @@
+import ts from "typescript";
+
+import { INestiaTransformProject } from "../options/INestiaTransformProject";
+import { RouteTransformer } from "./RouteTransformer";
+
+export namespace MethodTransformer {
+    export function transform(
+        project: INestiaTransformProject,
+        method: ts.MethodDeclaration,
+    ): ts.MethodDeclaration {
+        const decorators: readonly ts.Decorator[] | undefined = ts.getDecorators
+            ? ts.getDecorators(method)
+            : (method as any).decorators;
+        if (!decorators?.length) return method;
+
+        const signature: ts.Signature | undefined =
+            project.checker.getSignatureFromDeclaration(method);
+        const original: ts.Type | undefined =
+            signature && project.checker.getReturnTypeOfSignature(signature);
+        const escaped: ts.Type | undefined =
+            original && get_escaped_type(project.checker, original);
+
+        if (escaped === undefined) return method;
+
+        if (ts.getDecorators !== undefined)
+            return ts.factory.updateMethodDeclaration(
+                method,
+                (method.modifiers || []).map((mod) =>
+                    ts.isDecorator(mod)
+                        ? RouteTransformer.transform(project, escaped, mod)
+                        : mod,
+                ),
+                method.asteriskToken,
+                method.name,
+                method.questionToken,
+                method.typeParameters,
+                method.parameters,
+                method.type,
+                method.body,
+            );
+        // eslint-disable-next-line
+        return ts.factory.updateMethodDeclaration(
+            method,
+            decorators.map((deco) =>
+                RouteTransformer.transform(project, escaped, deco),
+            ),
+            (method as any).modifiers,
+            method.asteriskToken,
+            method.name,
+            method.questionToken,
+            method.typeParameters,
+            method.parameters,
+            method.type,
+            method.body,
+        );
+    }
+}
+
+function get_escaped_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const symbol: ts.Symbol | undefined = type.getSymbol() || type.aliasSymbol;
+    return symbol && get_name(symbol) === "Promise"
+        ? escape_promise(checker, type)
+        : type;
+}
+
+function escape_promise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const generic: readonly ts.Type[] = checker.getTypeArguments(
+        type as ts.TypeReference,
+    );
+    if (generic.length !== 1)
+        throw new Error(
+            "Error on ImportAnalyzer.analyze(): invalid promise type.",
+        );
+    return generic[0];
+}
+
+function get_name(symbol: ts.Symbol): string {
+    return explore_name(
+        symbol.escapedName.toString(),
+        symbol.getDeclarations()![0].parent,
+    );
+}
+
+function explore_name(name: string, decl: ts.Node): string {
+    return ts.isModuleBlock(decl)
+        ? explore_name(
+              `${decl.parent.name.getText()}.${name}`,
+              decl.parent.parent,
+          )
+        : name;
+}

package/src/transformers/NodeTransformer.ts

@@ -0,0 +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;
+    }
+}

package/src/transformers/ParameterTransformer.ts

@@ -0,0 +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,
+        );
+    }
+}

package/src/transformers/RouteTransformer.ts

@@ -0,0 +1,134 @@
+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 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 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 (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 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 === undefined ||
+                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

@@ -0,0 +1,3 @@
+export type Creator<T extends object> = {
+    new (...args: any[]): T;
+};

package/src/utils/ExceptionManager.ts

@@ -0,0 +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,
+        ),
+);

package/src/utils/Singleton.ts

@@ -0,0 +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 = {};