@nestia/core 0.1.5 → 0.1.7

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,10 +1,10 @@
-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;
-}
+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/route_error.ts

@@ -1,38 +1,38 @@
-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);
-}
+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,59 +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,
-                    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.";
+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/executable/core.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { CommandParser } from "./internal/CommandParser";
+import { CoreSetupWizard } from "./internal/CoreSetupWizard";
+
+const USAGE = `Wrong command has been detected. Use like below:
+
+  npx @nestia/core setup \\
+    --compiler (ttypescript|ts-patch) \\
+    --manager (npm|pnpm|yarn)
+
+  - npx @nestia/core setup
+  - npx @nestia/core setup --compiler ttypescript
+  - npx @nestia/core setup --compiler ts-patch
+  - npx @nestia/core setup --manager pnpm`;
+
+function halt(desc: string): never {
+    console.error(desc);
+    process.exit(-1);
+}
+
+async function setup(): Promise<void> {
+    const options: Record<string, string> = CommandParser.parse(
+        process.argv.slice(3),
+    );
+    const manager: string = options.manager ?? "npm";
+    const compiler: string = options.compiler ?? "ttypescript";
+
+    if (
+        (compiler !== "ttypescript" && compiler !== "ts-patch") ||
+        (manager !== "npm" && manager !== "pnpm" && manager !== "yarn")
+    )
+        halt(USAGE);
+    else if (compiler === "ttypescript")
+        await CoreSetupWizard.ttypescript(manager);
+    else await CoreSetupWizard.tsPatch(manager);
+}
+
+async function main(): Promise<void> {
+    const type: string | undefined = process.argv[2];
+    if (type === "setup") await setup();
+    else halt(USAGE);
+}
+main().catch((exp) => {
+    console.error(exp);
+    process.exit(-1);
+});

package/src/executable/internal/CommandParser.ts

@@ -0,0 +1,15 @@
+export namespace CommandParser {
+    export function parse(argList: string[]): Record<string, string> {
+        const output: Record<string, string> = {};
+        argList.forEach((arg, i) => {
+            if (arg.startsWith("--") === false) return;
+
+            const key = arg.slice(2);
+            const value: string | undefined = argList[i + 1];
+            if (value === undefined || value.startsWith("--")) return;
+
+            output[key] = value;
+        });
+        return output;
+    }
+}

package/src/executable/internal/CoreSetupWizard.ts

@@ -0,0 +1,177 @@
+import cp from "child_process";
+import type Comment from "comment-json";
+import fs from "fs";
+
+export namespace CoreSetupWizard {
+    export async function ttypescript(manager: string): Promise<void> {
+        // INSTALL
+        const pack: any = await prepare(manager);
+        add(manager)(pack)("ttypescript", true);
+        add(manager)(pack)("ts-node", true);
+
+        // TSCONFIG.JSON
+        await configure(manager)(pack);
+    }
+
+    export async function tsPatch(manager: string): Promise<void> {
+        // INSTALL
+        add(manager)(await prepare(manager))("ts-patch", true);
+        execute("npx ts-patch install");
+
+        // PACKAGE.JSON
+        const pack: any = JSON.parse(
+            await fs.promises.readFile("package.json", "utf8"),
+        );
+        if (!pack.scripts || typeof pack.scripts !== "object")
+            pack.scripts = {};
+        if (typeof pack.scripts.prepare === "string") {
+            if (pack.scripts.prepare.indexOf("ts-patch install") === -1)
+                pack.scripts.prepare =
+                    "ts-patch install && " + pack.scripts.prepare;
+        } else pack.scripts.prepare = "ts-patch install";
+
+        await fs.promises.writeFile(
+            "package.json",
+            JSON.stringify(pack, null, 2),
+            "utf8",
+        );
+
+        // TSCONFIG.JSON
+        await configure(manager)(pack);
+    }
+
+    async function prepare(manager: string): Promise<any> {
+        if (fs.existsSync("package.json") === false)
+            halt(() => {})("make package.json file or move to it.");
+
+        const pack: any = JSON.parse(
+            await fs.promises.readFile("package.json", "utf8"),
+        );
+        add(manager)(pack)("typescript", true);
+        add(manager)(pack)("typia", false);
+        add(manager)(pack)("@nestia/core", false);
+        return pack;
+    }
+
+    const configure =
+        (manager: string) =>
+        async (pack: any): Promise<void> => {
+            // VALIDATE PRERATATION
+            if (fs.existsSync("tsconfig.json") === false) {
+                execute("npx tsc --init");
+                if (fs.existsSync("tsconfig.json") === false)
+                    halt(() => {})("tsconfig.json file does not exist.");
+            }
+
+            const temporary: boolean = !fs.existsSync(
+                "node_modules/comment-json",
+            );
+            if (temporary === true) add(manager)(pack)("comment-json", true);
+
+            const halter: (msg: string) => never = halt(() => {
+                if (temporary === true) remove(manager)("comment-json", true);
+            });
+
+            // READ TSCONFIG FILE
+            const Comment: typeof import("comment-json") = await import(
+                process.cwd() + "/node_modules/comment-json"
+            );
+            const config: Comment.CommentObject = Comment.parse(
+                await fs.promises.readFile("tsconfig.json", "utf8"),
+            ) as Comment.CommentObject;
+            const options = config.compilerOptions as
+                | Comment.CommentObject
+                | undefined;
+            if (options === undefined)
+                halter(
+                    `tsconfig.json file does not have "compilerOptions" property.`,
+                );
+
+            const plugins: Comment.CommentArray<Comment.CommentObject> =
+                (() => {
+                    const plugins = options.plugins as
+                        | Comment.CommentArray<Comment.CommentObject>
+                        | undefined;
+                    if (plugins === undefined)
+                        return (options.plugins = [] as any);
+                    else if (!Array.isArray(plugins))
+                        halter(
+                            `"plugins" property of tsconfig.json must be array type.`,
+                        );
+                    return plugins;
+                })();
+
+            // CHECK WHETHER CONFIGURED
+            const strict: boolean = options.strict === true;
+            const core: Comment.CommentObject | undefined = plugins.find(
+                (p) =>
+                    typeof p === "object" &&
+                    p !== null &&
+                    p.transform === "@nestia/core/lib/transform",
+            );
+            const typia: Comment.CommentObject | undefined = plugins.find(
+                (p) =>
+                    typeof p === "object" &&
+                    p !== null &&
+                    p.transform === "typia/lib/transform",
+            );
+
+            if (strict === true && core !== undefined && typia !== undefined) {
+                console.log(
+                    "you've been already configured the tsconfig.json file.",
+                );
+            } else {
+                // DO CONFIGURE
+                options.strict = true;
+                if (core === undefined)
+                    plugins.push({
+                        transform: "@nestia/core/lib/transform",
+                    } as any);
+                if (typia === undefined)
+                    await fs.promises.writeFile(
+                        "tsconfig.json",
+                        Comment.stringify(config, null, 2),
+                    );
+            }
+            if (temporary === true) remove(manager)("comment-json", false);
+        };
+}
+
+const add =
+    (manager: string) =>
+    (pack: any) =>
+    (modulo: string, devOnly: boolean): void => {
+        const exists: boolean =
+            (devOnly === false
+                ? !!pack.dependencies && !!pack.dependencies[modulo]
+                : !!pack.devDependencies && !!pack.devDependencies[modulo]) &&
+            fs.existsSync("node_modules/" + modulo);
+        const middle: string =
+            manager === "yarn"
+                ? `add${devOnly ? " -D" : ""}`
+                : `install ${devOnly ? "--save-dev" : "--save"}`;
+        if (exists === false) execute(`${manager} ${middle} ${modulo}`);
+    };
+
+const remove =
+    (manager: string) =>
+    (modulo: string, devOnly: boolean): void => {
+        const middle: string =
+            manager === "yarn"
+                ? `remove${devOnly ? " -D" : ""}`
+                : `uninstall ${devOnly ? "--save-dev" : "--save"}`;
+        execute(`${manager} ${middle} ${modulo}`);
+    };
+
+const halt =
+    (closer: () => any) =>
+    (desc: string): never => {
+        closer();
+        console.error(desc);
+        process.exit(-1);
+    };
+
+function execute(command: string): void {
+    console.log(command);
+    cp.execSync(command, { stdio: "inherit" });
+}

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,11 +1,11 @@
-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";
+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";
+}