typia 3.7.5-dev.20230413 → 3.7.6

package/src/TypeGuardError.ts

@@ -1,36 +1,36 @@
-export class TypeGuardError extends Error {
-    public readonly method: string;
-    public readonly path: string | undefined;
-    public readonly expected: string;
-    public readonly value: any;
-
-    public constructor(props: TypeGuardError.IProps) {
-        // MESSAGE CONSTRUCTION
-        super(
-            props.message ||
-                `Error on ${props.method}(): invalid type${
-                    props.path ? ` on ${props.path}` : ""
-                }, expect to be ${props.expected}`,
-        );
-
-        // INHERITANCE POLYFILL
-        const proto = new.target.prototype;
-        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
-        else (this as any).__proto__ = proto;
-
-        // ASSIGN MEMBERS
-        this.method = props.method;
-        this.path = props.path;
-        this.expected = props.expected;
-        this.value = props.value;
-    }
-}
-export namespace TypeGuardError {
-    export interface IProps {
-        method: string;
-        path?: string;
-        expected: string;
-        value: any;
-        message?: string;
-    }
-}
+export class TypeGuardError extends Error {
+    public readonly method: string;
+    public readonly path: string | undefined;
+    public readonly expected: string;
+    public readonly value: any;
+
+    public constructor(props: TypeGuardError.IProps) {
+        // MESSAGE CONSTRUCTION
+        super(
+            props.message ||
+                `Error on ${props.method}(): invalid type${
+                    props.path ? ` on ${props.path}` : ""
+                }, expect to be ${props.expected}`,
+        );
+
+        // INHERITANCE POLYFILL
+        const proto = new.target.prototype;
+        if (Object.setPrototypeOf) Object.setPrototypeOf(this, proto);
+        else (this as any).__proto__ = proto;
+
+        // ASSIGN MEMBERS
+        this.method = props.method;
+        this.path = props.path;
+        this.expected = props.expected;
+        this.value = props.value;
+    }
+}
+export namespace TypeGuardError {
+    export interface IProps {
+        method: string;
+        path?: string;
+        expected: string;
+        value: any;
+        message?: string;
+    }
+}

package/src/executable/TypiaGenerateWizard.ts

@@ -1,85 +1,85 @@
-import fs from "fs";
-
-import { TypiaFileFactory } from "../factories/TypiaFileFactory";
-
-import { ArgumentParser } from "./setup/ArgumentParser";
-import { PackageManager } from "./setup/PackageManager";
-
-export namespace TypiaGenerateWizard {
-    export async function generate(): Promise<void> {
-        console.log("----------------------------------------");
-        console.log(" Typia Generate Wizard");
-        console.log("----------------------------------------");
-
-        // LOAD PACKAGE.JSON INFO
-        const pack: PackageManager = await PackageManager.mount();
-        const options: IArguments = await ArgumentParser.parse(pack)(inquiry);
-        await TypiaFileFactory.generate(options);
-    }
-
-    const inquiry: ArgumentParser.Inquiry<IArguments> = async (
-        _pack,
-        command,
-        prompt,
-        action,
-    ) => {
-        // PREPARE ASSETS
-        command.option("--input [path]", "input directory");
-        command.option("--output [directory]", "output directory");
-        command.option("--project [project]", "tsconfig.json file location");
-
-        const questioned = { value: false };
-
-        const input = (name: string) => async (message: string) => {
-            const result = await prompt()({
-                type: "input",
-                name,
-                message,
-                default: "",
-            });
-            return result[name] as string;
-        };
-        const select =
-            (name: string) =>
-            (message: string) =>
-            async <Choice extends string>(
-                choices: Choice[],
-            ): Promise<Choice> => {
-                questioned.value = true;
-                return (
-                    await prompt()({
-                        type: "list",
-                        name: name,
-                        message: message,
-                        choices: choices,
-                    })
-                )[name];
-            };
-        const configure = async () => {
-            const files: string[] = await (
-                await fs.promises.readdir(process.cwd())
-            ).filter(
-                (str) =>
-                    str.substring(0, 8) === "tsconfig" &&
-                    str.substring(str.length - 5) === ".json",
-            );
-            if (files.length === 0)
-                throw new Error(`Unable to find "tsconfig.json" file.`);
-            else if (files.length === 1) return files[0];
-            return select("tsconfig")("TS Config File")(files);
-        };
-
-        return action(async (options) => {
-            options.input ??= await input("input")("input directory");
-            options.output ??= await input("output")("output directory");
-            options.project ??= await configure();
-            return options as IArguments;
-        });
-    };
-
-    export interface IArguments {
-        input: string;
-        output: string;
-        project: string;
-    }
-}
+import fs from "fs";
+
+import { TypiaFileFactory } from "../factories/TypiaFileFactory";
+
+import { ArgumentParser } from "./setup/ArgumentParser";
+import { PackageManager } from "./setup/PackageManager";
+
+export namespace TypiaGenerateWizard {
+    export async function generate(): Promise<void> {
+        console.log("----------------------------------------");
+        console.log(" Typia Generate Wizard");
+        console.log("----------------------------------------");
+
+        // LOAD PACKAGE.JSON INFO
+        const pack: PackageManager = await PackageManager.mount();
+        const options: IArguments = await ArgumentParser.parse(pack)(inquiry);
+        await TypiaFileFactory.generate(options);
+    }
+
+    const inquiry: ArgumentParser.Inquiry<IArguments> = async (
+        _pack,
+        command,
+        prompt,
+        action,
+    ) => {
+        // PREPARE ASSETS
+        command.option("--input [path]", "input directory");
+        command.option("--output [directory]", "output directory");
+        command.option("--project [project]", "tsconfig.json file location");
+
+        const questioned = { value: false };
+
+        const input = (name: string) => async (message: string) => {
+            const result = await prompt()({
+                type: "input",
+                name,
+                message,
+                default: "",
+            });
+            return result[name] as string;
+        };
+        const select =
+            (name: string) =>
+            (message: string) =>
+            async <Choice extends string>(
+                choices: Choice[],
+            ): Promise<Choice> => {
+                questioned.value = true;
+                return (
+                    await prompt()({
+                        type: "list",
+                        name: name,
+                        message: message,
+                        choices: choices,
+                    })
+                )[name];
+            };
+        const configure = async () => {
+            const files: string[] = await (
+                await fs.promises.readdir(process.cwd())
+            ).filter(
+                (str) =>
+                    str.substring(0, 8) === "tsconfig" &&
+                    str.substring(str.length - 5) === ".json",
+            );
+            if (files.length === 0)
+                throw new Error(`Unable to find "tsconfig.json" file.`);
+            else if (files.length === 1) return files[0];
+            return select("tsconfig")("TS Config File")(files);
+        };
+
+        return action(async (options) => {
+            options.input ??= await input("input")("input directory");
+            options.output ??= await input("output")("output directory");
+            options.project ??= await configure();
+            return options as IArguments;
+        });
+    };
+
+    export interface IArguments {
+        input: string;
+        output: string;
+        project: string;
+    }
+}

package/src/executable/TypiaSetupWizard.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import path from "path";
 
 import { ArgumentParser } from "./setup/ArgumentParser";
 import { CommandExecutor } from "./setup/CommandExecutor";
@@ -7,6 +8,7 @@ import { PluginConfigurator } from "./setup/PluginConfigurator";
 
 export namespace TypiaSetupWizard {
     export interface IArguments {
+        compiler: "ts-patch" | "ttypescript";
         manager: "npm" | "pnpm" | "yarn";
         project: string | null;
     }
@@ -21,26 +23,29 @@ export namespace TypiaSetupWizard {
         const args: IArguments = await ArgumentParser.parse(pack)(inquiry);
 
         // INSTALL TYPESCRIPT
-        pack.install({ dev: true, modulo: "typescript" });
+        pack.install({ dev: true, modulo: "typescript", version: "4.9.5" });
         args.project ??= (() => {
             CommandExecutor.run("npx tsc --init");
             return (args.project = "tsconfig.json");
         })();
-        pack.install({ dev: true, modulo: "ts-node" });
+        pack.install({ dev: true, modulo: "ts-node", version: "latest" });
 
         // INSTALL COMPILER
-        pack.install({ dev: true, modulo: "ts-patch" });
-        await pack.save((data) => {
-            data.scripts ??= {};
-            if (
-                typeof data.scripts.prepare === "string" &&
-                data.scripts.prepare.indexOf("ts-patch install") === -1
-            )
-                data.scripts.prepare =
-                    "ts-patch install && " + data.scripts.prepare;
-            else data.scripts.prepare = "ts-patch install";
-        });
-        CommandExecutor.run("npm run prepare");
+        pack.install({ dev: true, modulo: args.compiler, version: "latest" });
+        if (args.compiler === "ts-patch") {
+            await pack.save((data) => {
+                data.scripts ??= {};
+                if (
+                    typeof data.scripts.prepare === "string" &&
+                    data.scripts.prepare.length
+                ) {
+                    if (data.scripts.prepare.indexOf("ts-patch install") === -1)
+                        data.scripts.prepare =
+                            "ts-patch install && " + data.scripts.prepare;
+                } else data.scripts.prepare = "ts-patch install";
+            });
+            CommandExecutor.run("npm run prepare");
+        }
 
         // CONFIGURE TYPIA
         await PluginConfigurator.configure(args);
@@ -53,6 +58,7 @@ export namespace TypiaSetupWizard {
         action,
     ) => {
         // PREPARE ASSETS
+        command.option("--compiler [compiler]", "compiler type");
         command.option("--manager [manager", "package manager");
         command.option("--project [project]", "tsconfig.json file location");
 
@@ -102,6 +108,14 @@ export namespace TypiaSetupWizard {
 
         // DO CONSTRUCT
         return action(async (options) => {
+            if (options.compiler === undefined) {
+                console.log(COMPILER_DESCRIPTION);
+                options.compiler = await select("compiler")(`Compiler`)(
+                    is_nest_cli(pack)
+                        ? ["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,
@@ -114,4 +128,23 @@ export namespace TypiaSetupWizard {
             return options as IArguments;
         });
     };
+
+    function is_nest_cli(pack: PackageManager): boolean {
+        return (
+            (typeof pack.data.scripts?.build === "string" &&
+                pack.data.scripts.build.indexOf("nest build") !== -1) ||
+            fs.existsSync(path.join(pack.directory, "nest-cli.json"))
+        );
+    }
 }
+
+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/setup/ArgumentParser.ts

@@ -1,45 +1,45 @@
-import commander from "commander";
-import inquirer from "inquirer";
-
-import { PackageManager } from "./PackageManager";
-
-export namespace ArgumentParser {
-    export type Inquiry<T> = (
-        pack: PackageManager,
-        command: commander.Command,
-        prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
-        action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
-    ) => Promise<T>;
-
-    export const parse =
-        (pack: PackageManager) =>
-        async <T>(
-            inquiry: (
-                pack: PackageManager,
-                command: commander.Command,
-                prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
-                action: (
-                    closure: (options: Partial<T>) => Promise<T>,
-                ) => Promise<T>,
-            ) => Promise<T>,
-        ): Promise<T> => {
-            // TAKE OPTIONS
-            const action = (closure: (options: Partial<T>) => Promise<T>) =>
-                new Promise<T>((resolve, reject) => {
-                    commander.program.action(async (options) => {
-                        try {
-                            resolve(await closure(options));
-                        } catch (exp) {
-                            reject(exp);
-                        }
-                    });
-                    commander.program.parseAsync().catch(reject);
-                });
-            return inquiry(
-                pack,
-                commander.program,
-                inquirer.createPromptModule,
-                action,
-            );
-        };
-}
+import commander from "commander";
+import inquirer from "inquirer";
+
+import { PackageManager } from "./PackageManager";
+
+export namespace ArgumentParser {
+    export type Inquiry<T> = (
+        pack: PackageManager,
+        command: commander.Command,
+        prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
+        action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>;
+
+    export const parse =
+        (pack: PackageManager) =>
+        async <T>(
+            inquiry: (
+                pack: PackageManager,
+                command: commander.Command,
+                prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
+                action: (
+                    closure: (options: Partial<T>) => Promise<T>,
+                ) => Promise<T>,
+            ) => Promise<T>,
+        ): Promise<T> => {
+            // TAKE OPTIONS
+            const action = (closure: (options: Partial<T>) => Promise<T>) =>
+                new Promise<T>((resolve, reject) => {
+                    commander.program.action(async (options) => {
+                        try {
+                            resolve(await closure(options));
+                        } catch (exp) {
+                            reject(exp);
+                        }
+                    });
+                    commander.program.parseAsync().catch(reject);
+                });
+            return inquiry(
+                pack,
+                commander.program,
+                inquirer.createPromptModule,
+                action,
+            );
+        };
+}

package/src/executable/setup/CommandExecutor.ts

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

package/src/executable/setup/FileRetriever.ts

@@ -1,22 +1,22 @@
-import fs from "fs";
-import path from "path";
-
-export namespace FileRetriever {
-    export const directory =
-        (name: string) =>
-        (dir: string, depth: number = 0): string | null => {
-            const location: string = path.join(dir, name);
-            if (fs.existsSync(location)) return dir;
-            else if (depth > 2) return null;
-            return directory(name)(path.join(dir, ".."), depth + 1);
-        };
-
-    export const file =
-        (name: string) =>
-        (directory: string, depth: number = 0): string | null => {
-            const location: string = path.join(directory, name);
-            if (fs.existsSync(location)) return location;
-            else if (depth > 2) return null;
-            return file(name)(path.join(directory, ".."), depth + 1);
-        };
-}
+import fs from "fs";
+import path from "path";
+
+export namespace FileRetriever {
+    export const directory =
+        (name: string) =>
+        (dir: string, depth: number = 0): string | null => {
+            const location: string = path.join(dir, name);
+            if (fs.existsSync(location)) return dir;
+            else if (depth > 2) return null;
+            return directory(name)(path.join(dir, ".."), depth + 1);
+        };
+
+    export const file =
+        (name: string) =>
+        (directory: string, depth: number = 0): string | null => {
+            const location: string = path.join(directory, name);
+            if (fs.existsSync(location)) return location;
+            else if (depth > 2) return null;
+            return file(name)(path.join(directory, ".."), depth + 1);
+        };
+}

package/src/executable/setup/PackageManager.ts

@@ -38,7 +38,7 @@ export class PackageManager {
     public install(props: {
         dev: boolean;
         modulo: string;
-        version?: string;
+        version: `latest` | `${number}.${number}.${number}`;
     }): boolean {
         const middle: string =
             this.manager === "yarn"

package/src/executable/setup/PluginConfigurator.ts

@@ -1,59 +1,59 @@
-import comments from "comment-json";
-import fs from "fs";
-
-import { TypiaSetupWizard } from "../TypiaSetupWizard";
-
-export namespace PluginConfigurator {
-    export async function configure(
-        args: TypiaSetupWizard.IArguments,
-    ): Promise<void> {
-        // GET COMPILER-OPTIONS
-        const config: comments.CommentObject = comments.parse(
-            await fs.promises.readFile(args.project!, "utf8"),
-        ) as comments.CommentObject;
-        const compilerOptions = config.compilerOptions as
-            | comments.CommentObject
-            | undefined;
-        if (compilerOptions === undefined)
-            throw new Error(
-                `${args.project} file does not have "compilerOptions" property.`,
-            );
-
-        // PREPARE PLUGINS
-        const plugins: comments.CommentArray<comments.CommentObject> = (() => {
-            const plugins = compilerOptions.plugins as
-                | comments.CommentArray<comments.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;
-        })();
-
-        const strict: boolean = compilerOptions.strict === true;
-        const oldbie: comments.CommentObject | undefined = plugins.find(
-            (p) =>
-                typeof p === "object" &&
-                p !== null &&
-                p.transform === "typia/lib/transform",
-        );
-        if (strict === true && oldbie !== undefined) return;
-
-        // DO CONFIGURE
-        compilerOptions.strict = true;
-        if (oldbie === undefined)
-            plugins.push(
-                comments.parse(`
-                        {
-                            "transform": "typia/lib/transform"
-                        }`) as comments.CommentObject,
-            );
-        await fs.promises.writeFile(
-            args.project!,
-            comments.stringify(config, null, 2),
-        );
-    }
-}
+import comments from "comment-json";
+import fs from "fs";
+
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
+
+export namespace PluginConfigurator {
+    export async function configure(
+        args: TypiaSetupWizard.IArguments,
+    ): Promise<void> {
+        // GET COMPILER-OPTIONS
+        const config: comments.CommentObject = comments.parse(
+            await fs.promises.readFile(args.project!, "utf8"),
+        ) as comments.CommentObject;
+        const compilerOptions = config.compilerOptions as
+            | comments.CommentObject
+            | undefined;
+        if (compilerOptions === undefined)
+            throw new Error(
+                `${args.project} file does not have "compilerOptions" property.`,
+            );
+
+        // PREPARE PLUGINS
+        const plugins: comments.CommentArray<comments.CommentObject> = (() => {
+            const plugins = compilerOptions.plugins as
+                | comments.CommentArray<comments.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;
+        })();
+
+        const strict: boolean = compilerOptions.strict === true;
+        const oldbie: comments.CommentObject | undefined = plugins.find(
+            (p) =>
+                typeof p === "object" &&
+                p !== null &&
+                p.transform === "typia/lib/transform",
+        );
+        if (strict === true && oldbie !== undefined) return;
+
+        // DO CONFIGURE
+        compilerOptions.strict = true;
+        if (oldbie === undefined)
+            plugins.push(
+                comments.parse(`
+                        {
+                            "transform": "typia/lib/transform"
+                        }`) as comments.CommentObject,
+            );
+        await fs.promises.writeFile(
+            args.project!,
+            comments.stringify(config, null, 2),
+        );
+    }
+}