@nestia/core 1.0.9 → 1.0.11

package/src/decorators/TypedQuery.ts

@@ -3,9 +3,25 @@ import express from "express";
 
 import { assert } from "typia";
 
-export function TypedQuery(decoder?: (params: URLSearchParams) => any) {
-    if (decoder === undefined)
-        throw new Error("Error on TypedQuery(): no decoder function provided.");
+import { TransformError } from "./internal/TransformError";
+
+/**
+ * Type safe URL query decorator.
+ *
+ * `TypedQuery` is a decorator function that can parse URL query string. It is almost
+ * same with {@link nest.Query}, but it can automatically cast property type following
+ * its DTO definition. Also, `TypedQuery` performs type validation.
+ *
+ * For referecen, when URL query parameters are different with their promised
+ * type `T`, `BadRequestException` error (status code: 400) would be thrown.
+ *
+ * @returns Parameter decorator
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export function TypedQuery<T>(
+    decoder?: (params: URLSearchParams) => T,
+): ParameterDecorator {
+    if (decoder === undefined) throw TransformError("TypedQuery");
 
     return createParamDecorator(async function TypedQuery(
         _unknown: any,
@@ -36,6 +52,9 @@ export namespace TypedQuery {
 }
 Object.assign(TypedQuery, assert);
 
+/**
+ * @internal
+ */
 function tail(url: string): string {
     const index: number = url.indexOf("?");
     return index === -1 ? "" : url.substring(index + 1);

package/src/decorators/TypedRoute.ts

@@ -13,6 +13,7 @@ import {
 import { HttpArgumentsHost } from "@nestjs/common/interfaces";
 import express from "express";
 import { Observable, catchError, map } from "rxjs";
+
 import {
     assertStringify,
     isStringify,
@@ -25,14 +26,15 @@ import { get_path_and_stringify } from "./internal/get_path_and_stringify";
 import { route_error } from "./internal/route_error";
 
 /**
- * Safe router decorator functions.
+ * Type 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).
+ * JSON string conversion speed about 50x times faster than `class-transformer`.
+ * Furthermore, such JSON string conversion is even type safe through
+ * [typia](https://github.com/samchon/typia).
  *
- * Also, router functions in `TypedRoute` can convert custom error classes to the
- * regular {@link nest.HttpException} class automatically, through
+ * For reference, router functions of `TypedRoute` can convert custom error classes to
+ * the regular {@link nest.HttpException} class automatically, through
  * {@link ExceptionManager}.
  *
  * @author Jeongho Nam - https://github.com/samchon

package/src/decorators/internal/TransformError.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export function TransformError(method: string): Error {
+    return new Error(
+        `Error on nestia.core.${method}(): no transform has been configured. Configure "tsconfig.json" file following [Guide Documents](https://github.com/samchon/nestia/wiki/Setup#tsconfigjson).`,
+    );
+}

package/src/decorators/internal/get_path_and_stringify.ts

@@ -1,7 +1,9 @@
 import { InternalServerErrorException } from "@nestjs/common";
+
 import { IValidation, TypeGuardError } from "typia";
 
 import { IResponseBodyStringifier } from "../../options/IResponseBodyStringifier";
+import { TransformError } from "./TransformError";
 
 export const get_path_and_stringify =
     (method: string) =>
@@ -22,10 +24,7 @@ export const get_path_and_stringify =
 const take =
     (method: string) =>
     <T>(functor?: IResponseBodyStringifier<T> | null) => {
-        if (functor === undefined)
-            throw new Error(
-                `Error on nestia.core.${method}(): no stringify function provided.`,
-            );
+        if (functor === undefined) throw TransformError(method);
         else if (functor === null) return JSON.stringify;
         else if (functor.type === "stringify") return functor.stringify;
         else if (functor.type === "assert") return assert(functor.assert);

package/src/decorators/internal/validate_request_body.ts

@@ -1,15 +1,14 @@
 import { BadRequestException } from "@nestjs/common";
+
 import { IValidation, TypeGuardError } from "typia";
 
 import { IRequestBodyValidator } from "../../options/IRequestBodyValidator";
+import { TransformError } from "./TransformError";
 
 export const validate_request_body =
     (method: string) =>
     <T>(validator?: IRequestBodyValidator<T>) => {
-        if (!validator)
-            throw new Error(
-                `Error on nestia.core.${method}(): no transformer.`,
-            );
+        if (!validator) throw TransformError(method);
         else if (validator.type === "assert") return assert(validator.assert);
         else if (validator.type === "is") return is(validator.is);
         else if (validator.type === "validate")

package/src/executable/core.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-import { CommandParser } from "./internal/CommandParser";
-import { CoreSetupWizard } from "./internal/CoreSetupWizard";
+import { ArgumentParser } from "./internal/ArgumentParser";
+import { CommandExecutor } from "./internal/CommandExecutor";
+import { PackageManager } from "./internal/PackageManager";
+import { PluginConfigurator } from "./internal/PluginConfigurator";
 
 const USAGE = `Wrong command has been detected. Use like below:
 
@@ -20,22 +22,41 @@ function halt(desc: string): never {
 }
 
 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";
-    const project: string = options.project ?? "tsconfig.json";
-    console.log(options);
-
-    if (
-        (compiler !== "ttypescript" && compiler !== "ts-patch") ||
-        (manager !== "npm" && manager !== "pnpm" && manager !== "yarn")
-    )
-        halt(USAGE);
-    else if (compiler === "ttypescript")
-        await CoreSetupWizard.ttypescript({ manager, project });
-    else await CoreSetupWizard.tsPatch({ manager, project });
+    console.log("----------------------------------------");
+    console.log(" Nestia Setup Wizard");
+    console.log("----------------------------------------");
+
+    // LOAD PACKAGE.JSON INFO
+    const pack: PackageManager = await PackageManager.mount();
+
+    // TAKE ARGUMENTS
+    const args: ArgumentParser.IArguments = await ArgumentParser.parse(pack);
+
+    // INSTALL TYPESCRIPT
+    pack.install({ dev: true, modulo: "typescript" });
+    args.project ??= (() => {
+        CommandExecutor.run("npx tsc --init", false);
+        return (args.project = "tsconfig.json");
+    })();
+    pack.install({ dev: true, modulo: "ts-node" });
+
+    // INSTALL COMPILER
+    pack.install({ dev: true, modulo: args.compiler });
+    if (args.compiler === "ts-patch") {
+        await pack.save((data) => {
+            data.scripts ??= {};
+            if (typeof data.scripts.prepare === "string")
+                data.scripts.prepare =
+                    "ts-patch install && " + data.scripts.prepare;
+            else data.scripts.prepare = "ts-patch install";
+        });
+        CommandExecutor.run("npm run prepare", false);
+    }
+
+    // INSTALL AND CONFIGURE TYPIA
+    pack.install({ dev: false, modulo: "typia" });
+    pack.install({ dev: false, modulo: "@nestia/core" });
+    await PluginConfigurator.configure(pack, args);
 }
 
 async function main(): Promise<void> {

package/src/executable/internal/ArgumentParser.ts

@@ -0,0 +1,144 @@
+import type CommanderModule from "commander";
+import fs from "fs";
+import type * as InquirerModule from "inquirer";
+import path from "path";
+
+import { PackageManager } from "./PackageManager";
+
+export namespace ArgumentParser {
+    export interface IArguments {
+        compiler: "ts-patch" | "ttypescript";
+        manager: "npm" | "pnpm" | "yarn";
+        project: string | null;
+    }
+
+    export async function parse(pack: PackageManager): Promise<IArguments> {
+        // INSTALL TEMPORARY PACKAGES
+        const newbie = {
+            commander: pack.install({
+                dev: true,
+                modulo: "commander",
+                version: "10.0.0",
+                silent: true,
+            }),
+            inquirer: pack.install({
+                dev: true,
+                modulo: "inquirer",
+                version: "8.2.5",
+                silent: true,
+            }),
+        };
+
+        // TAKE OPTIONS
+        const output: IArguments | Error = await (async () => {
+            try {
+                return await _Parse(pack);
+            } catch (error) {
+                return error as Error;
+            }
+        })();
+
+        // REMOVE TEMPORARY PACKAGES
+        if (newbie.commander) pack.erase({ modulo: "commander", silent: true });
+        if (newbie.inquirer) pack.erase({ modulo: "inquirer", silent: true });
+
+        // RETURNS
+        if (output instanceof Error) throw output;
+        return output;
+    }
+
+    async function _Parse(pack: PackageManager): Promise<IArguments> {
+        // PREPARE ASSETS
+        const { createPromptModule }: typeof InquirerModule = await import(
+            path.join(pack.directory, "node_modules", "inquirer")
+        );
+        const { program }: typeof CommanderModule = await import(
+            path.join(pack.directory, "node_modules", "commander")
+        );
+
+        program.option("--compiler [compiler]", "compiler type");
+        program.option("--manager [manager", "package manager");
+        program.option("--project [project]", "tsconfig.json file location");
+
+        // INTERNAL PROCEDURES
+        const questioned = { value: false };
+        const action = (
+            closure: (options: Partial<IArguments>) => Promise<IArguments>,
+        ) => {
+            return new Promise<IArguments>((resolve, reject) => {
+                program.action(async (options) => {
+                    try {
+                        resolve(await closure(options));
+                    } catch (exp) {
+                        reject(exp);
+                    }
+                });
+                program.parseAsync().catch(reject);
+            });
+        };
+        const select =
+            (name: string) =>
+            (message: string) =>
+            async <Choice extends string>(
+                choices: Choice[],
+            ): Promise<Choice> => {
+                questioned.value = true;
+                return (
+                    await createPromptModule()({
+                        type: "list",
+                        name: name,
+                        message: message,
+                        choices: choices,
+                    })
+                )[name];
+            };
+        const configure = async () => {
+            const fileList: string[] = await (
+                await fs.promises.readdir(process.cwd())
+            ).filter(
+                (str) =>
+                    str.substring(0, 8) === "tsconfig" &&
+                    str.substring(str.length - 5) === ".json",
+            );
+            if (fileList.length === 0) {
+                if (process.cwd() !== pack.directory)
+                    throw new Error(`Unable to find "tsconfig.json" file.`);
+                return null;
+            } else if (fileList.length === 1) return fileList[0];
+            return select("tsconfig")("TS Config File")(fileList);
+        };
+
+        // DO CONSTRUCT
+        return action(async (options) => {
+            if (options.compiler === undefined) {
+                console.log(COMPILER_DESCRIPTION);
+                options.compiler = await select("compiler")(`Compiler`)(
+                    pack.data.scripts?.build === "nest build"
+                        ? ["ts-patch" as const, "ttypescript" as const]
+                        : ["ttypescript" as const, "ts-patch" as const],
+                );
+            }
+            options.manager ??= await select("manager")("Package Manager")([
+                "npm" as const,
+                "pnpm" as const,
+                "yarn" as const,
+            ]);
+            pack.manager = options.manager;
+            options.project ??= await configure();
+
+            if (questioned.value) console.log("");
+            return options as IArguments;
+        });
+    }
+}
+
+const COMPILER_DESCRIPTION = [
+    `About compiler, if you adapt "ttypescript", you should use "ttsc" instead.`,
+    ``,
+    `Otherwise, you choose "ts-patch", you can use the original "tsc" command.`,
+    `However, the "ts-patch" hacks "node_modules/typescript" source code.`,
+    `Also, whenever update "typescript", you've to run "npm run prepare" command.`,
+    ``,
+    `By the way, when using "@nest/cli", you must just choose "ts-patch".`,
+    ``,
+].join("\n");

package/src/executable/internal/CommandExecutor.ts

@@ -0,0 +1,8 @@
+import cp from "child_process";
+
+export namespace CommandExecutor {
+    export function run(str: string, silent: boolean): void {
+        if (silent === false) console.log(str);
+        cp.execSync(str, { stdio: "ignore" });
+    }
+}

package/src/executable/internal/PackageManager.ts

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+
+import { CommandExecutor } from "./CommandExecutor";
+
+export class PackageManager {
+    public manager: string = "npm";
+    public get file(): string {
+        return path.join(this.directory, "package.json");
+    }
+
+    public static async mount(): Promise<PackageManager> {
+        const location: string | null = await find(process.cwd());
+        if (location === null)
+            throw new Error(`Unable to find "package.json" file`);
+
+        return new PackageManager(
+            location,
+            await this.load(path.join(location, "package.json")),
+        );
+    }
+
+    public async save(modifier: (data: Package.Data) => void): Promise<void> {
+        const content: string = await fs.promises.readFile(this.file, "utf8");
+        this.data = JSON.parse(content);
+        modifier(this.data);
+
+        return fs.promises.writeFile(
+            this.file,
+            JSON.stringify(this.data, null, 2),
+            "utf8",
+        );
+    }
+
+    public install(props: {
+        dev: boolean;
+        silent?: boolean;
+        modulo: string;
+        version?: string;
+    }): boolean {
+        const container = props.dev
+            ? this.data.devDependencies
+            : this.data.dependencies;
+        if (
+            !!container?.[props.modulo] &&
+            fs.existsSync(
+                path.join(this.directory, "node_modules", props.modulo),
+            )
+        )
+            return false;
+
+        const middle: string =
+            this.manager === "yarn"
+                ? `add${props.dev ? " -D" : ""}`
+                : `install ${props.dev ? "--save-dev" : "--save"}`;
+        CommandExecutor.run(
+            `${this.manager} ${middle} ${props.modulo}${
+                props.version ? `@${props.version}` : ""
+            }`,
+            !!props.silent,
+        );
+        return true;
+    }
+
+    public erase(props: { modulo: string; silent?: boolean }): void {
+        const middle: string = this.manager === "yarn" ? "remove" : "uninstall";
+        CommandExecutor.run(
+            `${this.manager} ${middle} ${props.modulo}`,
+            !!props.silent,
+        );
+    }
+
+    private constructor(
+        public readonly directory: string,
+        public data: Package.Data,
+    ) {}
+
+    private static async load(file: string): Promise<Package.Data> {
+        const content: string = await fs.promises.readFile(file, "utf8");
+        return JSON.parse(content);
+    }
+}
+export namespace Package {
+    export interface Data {
+        scripts?: Record<string, string>;
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    }
+}
+
+async function find(
+    directory: string = process.cwd(),
+    depth: number = 0,
+): Promise<string | null> {
+    const location: string = path.join(directory, "package.json");
+    if (fs.existsSync(location)) return directory;
+    else if (depth > 1) return null;
+    return find(path.join(directory, ".."), depth + 1);
+}

package/src/executable/internal/PluginConfigurator.ts

@@ -0,0 +1,128 @@
+import type Comment from "comment-json";
+import fs from "fs";
+import path from "path";
+
+import { ArgumentParser } from "./ArgumentParser";
+import { PackageManager } from "./PackageManager";
+
+export namespace PluginConfigurator {
+    export async function configure(
+        pack: PackageManager,
+        args: ArgumentParser.IArguments,
+    ): Promise<void> {
+        // INSTALL COMMENT-JSON
+        const installed: boolean = pack.install({
+            dev: true,
+            modulo: "comment-json",
+            version: "4.2.3",
+            silent: true,
+        });
+
+        // DO CONFIGURE
+        const error: Error | null = await (async () => {
+            try {
+                await _Configure(pack, args);
+                return null;
+            } catch (exp) {
+                return exp as Error;
+            }
+        })();
+
+        // REMOVE IT
+        if (installed)
+            pack.erase({
+                modulo: "comment-json",
+                silent: true,
+            });
+        if (error !== null) throw error;
+    }
+
+    async function _Configure(
+        pack: PackageManager,
+        args: ArgumentParser.IArguments,
+    ): Promise<void> {
+        // GET COMPILER-OPTIONS
+        const Comment: typeof import("comment-json") = await import(
+            path.join(pack.directory, "node_modules", "comment-json")
+        );
+
+        const config: Comment.CommentObject = Comment.parse(
+            await fs.promises.readFile(args.project!, "utf8"),
+        ) as Comment.CommentObject;
+        const compilerOptions = config.compilerOptions as
+            | Comment.CommentObject
+            | undefined;
+        if (compilerOptions === undefined)
+            throw new Error(
+                `${args.project} file does not have "compilerOptions" property.`,
+            );
+
+        // PREPARE PLUGINS
+        const plugins: Comment.CommentArray<Comment.CommentObject> = (() => {
+            const plugins = compilerOptions.plugins as
+                | Comment.CommentArray<Comment.CommentObject>
+                | undefined;
+            if (plugins === undefined)
+                return (compilerOptions.plugins = [] as any);
+            else if (!Array.isArray(plugins))
+                throw new Error(
+                    `"plugins" property of ${args.project} must be array type.`,
+                );
+            return plugins;
+        })();
+
+        // CHECK WHETHER CONFIGURED
+        const strict: boolean = compilerOptions.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 && !!core && !!typia) return;
+
+        // DO CONFIGURE
+        compilerOptions.strict = true;
+        if (core === undefined)
+            plugins.push(
+                Comment.parse(`{
+                    "transform": "@nestia/core/lib/transform",
+        /**
+         * Validate request body.
+         * 
+         *   - "assert": Use typia.assert() function
+         *   - "is": Use typia.is() function
+         *   - "validate": Use typia.validate() function
+         */
+                            "validate": "assert",
+
+        /**
+         * Validate JSON typed response body.
+         * 
+         *   - null: Just use JSON.stringify() function, without boosting
+         *   - "stringify": Use typia.stringify() function, but dangerous
+         *   - "assert": Use typia.assertStringify() function
+         *   - "is": Use typia.isStringify() function
+         *   - "validate": Use typia.validateStringify() function
+         */
+                    "stringify": "is"
+                }`) as Comment.CommentObject,
+            );
+        if (typia === undefined)
+            plugins.push(
+                Comment.parse(
+                    `{ "transform": "typia/lib/transform" }`,
+                ) as Comment.CommentObject,
+            );
+        await fs.promises.writeFile(
+            args.project!,
+            Comment.stringify(config, null, 2),
+        );
+    }
+}

package/lib/executable/internal/CommandParser.d.ts

@@ -1,3 +0,0 @@
-export declare namespace CommandParser {
-    function parse(argList: string[]): Record<string, string>;
-}

package/lib/executable/internal/CommandParser.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandParser = void 0;
-var CommandParser;
-(function (CommandParser) {
-    function parse(argList) {
-        var output = {};
-        argList.forEach(function (arg, i) {
-            if (arg.startsWith("--") === false)
-                return;
-            var key = arg.slice(2);
-            var value = argList[i + 1];
-            if (value === undefined || value.startsWith("--"))
-                return;
-            output[key] = value;
-        });
-        return output;
-    }
-    CommandParser.parse = parse;
-})(CommandParser = exports.CommandParser || (exports.CommandParser = {}));
-//# sourceMappingURL=CommandParser.js.map

package/lib/executable/internal/CommandParser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CommandParser.js","sourceRoot":"","sources":["../../../src/executable/internal/CommandParser.ts"],"names":[],"mappings":";;;AAAA,IAAiB,aAAa,CAc7B;AAdD,WAAiB,aAAa;IAC1B,SAAgB,KAAK,CAAC,OAAiB;QACnC,IAAM,MAAM,GAA2B,EAAE,CAAC;QAC1C,OAAO,CAAC,OAAO,CAAC,UAAC,GAAG,EAAE,CAAC;YACnB,IAAI,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,KAAK;gBAAE,OAAO;YAE3C,IAAM,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACzB,IAAM,KAAK,GAAuB,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACjD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;gBAAE,OAAO;YAE1D,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACxB,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC;IAClB,CAAC;IAZe,mBAAK,QAYpB,CAAA;AACL,CAAC,EAdgB,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAc7B"}

package/lib/executable/internal/CoreSetupWizard.d.ts

@@ -1,8 +0,0 @@
-export declare namespace CoreSetupWizard {
-    interface IArguments {
-        manager: "npm" | "pnpm" | "yarn";
-        project: string;
-    }
-    function ttypescript(args: string | IArguments): Promise<void>;
-    function tsPatch(args: string | IArguments): Promise<void>;
-}