typia 3.5.2 → 3.6.0-dev.20230219

package/src/executable/setup/ArgumentParser.ts

@@ -0,0 +1,89 @@
+import type CommanderModule from "commander";
+import type * as InquirerModule from "inquirer";
+import path from "path";
+
+import { PackageManager } from "./PackageManager";
+
+export namespace ArgumentParser {
+    export type Inquiry<T> = (
+        pack: PackageManager,
+        command: CommanderModule.Command,
+        prompt: (
+            opt?: InquirerModule.StreamOptions,
+        ) => InquirerModule.PromptModule,
+        action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>;
+
+    export const parse =
+        (pack: PackageManager) =>
+        (erase: boolean) =>
+        async <T>(
+            inquiry: (
+                pack: PackageManager,
+                command: CommanderModule.Command,
+                prompt: (
+                    opt?: InquirerModule.StreamOptions,
+                ) => InquirerModule.PromptModule,
+                action: (
+                    closure: (options: Partial<T>) => Promise<T>,
+                ) => Promise<T>,
+            ) => Promise<T>,
+        ): Promise<T> => {
+            // 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,
+                }),
+            };
+
+            // LOAD INSTALLED MODULES
+            const { program: command }: typeof CommanderModule = await import(
+                path.join(pack.directory, "node_modules", "commander")
+            );
+            const { createPromptModule: prompt }: typeof InquirerModule =
+                await import(
+                    path.join(pack.directory, "node_modules", "inquirer")
+                );
+
+            // TAKE OPTIONS
+            const action = (closure: (options: Partial<T>) => Promise<T>) =>
+                new Promise<T>((resolve, reject) => {
+                    command.action(async (options) => {
+                        try {
+                            resolve(await closure(options));
+                        } catch (exp) {
+                            reject(exp);
+                        }
+                    });
+                    command.parseAsync().catch(reject);
+                });
+            const output: T | Error = await (async () => {
+                try {
+                    return await inquiry(pack, command, prompt, action);
+                } catch (error) {
+                    return error as Error;
+                }
+            })();
+
+            // REMOVE TEMPORARY PACKAGES
+            if (erase === true) {
+                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;
+        };
+}

package/src/executable/{internal → setup}/PluginConfigurator.ts

@@ -2,18 +2,19 @@ import type Comment from "comment-json";
 import fs from "fs";
 import path from "path";
 
-import { ArgumentParser } from "./ArgumentParser";
+import { TypiaSetupWizard } from "../TypiaSetupWizard";
 import { PackageManager } from "./PackageManager";
 
 export namespace PluginConfigurator {
     export async function configure(
         pack: PackageManager,
-        args: ArgumentParser.IArguments,
+        args: TypiaSetupWizard.IArguments,
     ): Promise<void> {
         // INSTALL COMMENT-JSON
         const installed: boolean = pack.install({
             dev: true,
             modulo: "comment-json",
+            version: "4.2.3",
             silent: true,
         });
 
@@ -38,7 +39,7 @@ export namespace PluginConfigurator {
 
     async function _Configure(
         pack: PackageManager,
-        args: ArgumentParser.IArguments,
+        args: TypiaSetupWizard.IArguments,
     ): Promise<void> {
         // GET COMPILER-OPTIONS
         const Comment: typeof import("comment-json") = await import(

package/src/executable/typia.ts

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
-import { ArgumentParser } from "./internal/ArgumentParser";
-import { CommandExecutor } from "./internal/CommandExecutor";
-import { PackageManager } from "./internal/PackageManager";
-import { PluginConfigurator } from "./internal/PluginConfigurator";
+import { TypiaGenerateWizard } from "./TypiaGenerateWizard";
+import { TypiaSetupWizard } from "./TypiaSetupWizard";
 
 const USAGE = `Wrong command has been detected. Use like below:
 
@@ -11,56 +9,27 @@ const USAGE = `Wrong command has been detected. Use like below:
     --manager (npm|pnpm|yarn) \\
     --project {tsconfig.json file path}
 
-  - npx typia setup
-  - npx typia setup --compiler ts-patch
-  - npx typia setup --manager pnpm
-  - npx typia setup --project tsconfig.test.json`;
+    - npx typia setup
+    - npx typia setup --compiler ts-patch
+    - npx typia setup --manager pnpm
+    - npx typia setup --project tsconfig.test.json
+
+  npx typia generate 
+    --input {directory} \\
+    --output {directory}
+
+    --npx typia setup --input src/templates --output src/functinoal
+`;
 
 function halt(desc: string): never {
     console.error(desc);
     process.exit(-1);
 }
 
-async function setup(): Promise<void> {
-    console.log("----------------------------------------");
-    console.log(" Typia 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" });
-    await PluginConfigurator.configure(pack, args);
-}
-
 async function main(): Promise<void> {
     const type: string | undefined = process.argv[2];
-    if (type === "setup") await setup();
+    if (type === "setup") await TypiaSetupWizard.setup();
+    else if (type === "generate") await TypiaGenerateWizard.generate();
     else halt(USAGE);
 }
 main().catch((exp) => {

package/src/factories/IdentifierFactory.ts

@@ -24,6 +24,7 @@ export namespace IdentifierFactory {
 
     export function parameter(
         name: string | ts.BindingName,
+        type?: ts.TypeNode,
         init?: ts.Expression,
     ) {
         if (ts.version >= "4.8")
@@ -32,7 +33,7 @@ export namespace IdentifierFactory {
                 undefined,
                 name,
                 undefined,
-                undefined,
+                type,
                 init,
             );
         // eslint-disable-next-line
@@ -42,7 +43,7 @@ export namespace IdentifierFactory {
             undefined,
             name,
             undefined,
-            undefined,
+            type,
             init,
         );
     }

package/src/factories/TypeFactory.ts

@@ -11,6 +11,7 @@ export namespace TypeFactory {
     export function isFunction(type: ts.Type): boolean {
         return getFunction(type) !== null;
     }
+
     function getFunction(type: ts.Type) {
         const node = type.symbol?.declarations?.[0];
         if (node === undefined) return null;
@@ -98,4 +99,31 @@ export namespace TypeFactory {
             ? explore_name(symbol.escapedName.toString(), parent)
             : "__type";
     }
+
+    export const keyword = (
+        type:
+            | "void"
+            | "any"
+            | "unknown"
+            | "boolean"
+            | "number"
+            | "bigint"
+            | "string",
+    ) => {
+        return ts.factory.createKeywordTypeNode(
+            type === "void"
+                ? ts.SyntaxKind.VoidKeyword
+                : type === "any"
+                ? ts.SyntaxKind.AnyKeyword
+                : type === "unknown"
+                ? ts.SyntaxKind.UnknownKeyword
+                : type === "boolean"
+                ? ts.SyntaxKind.BooleanKeyword
+                : type === "number"
+                ? ts.SyntaxKind.NumberKeyword
+                : type === "bigint"
+                ? ts.SyntaxKind.BigIntKeyword
+                : ts.SyntaxKind.StringKeyword,
+        );
+    };
 }

package/src/generate/TypiaGenerator.ts

@@ -0,0 +1,126 @@
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+import transform from "../transform";
+
+export namespace TypiaGenerator {
+    export interface IProps {
+        input: string;
+        output: string;
+        project: string;
+    }
+
+    export async function generate(
+        props: TypiaGenerator.IProps,
+    ): Promise<void> {
+        props.input = path.resolve(props.input);
+        props.output = path.resolve(props.output);
+
+        if ((await is_directory(props.input)) === false)
+            throw new Error(
+                "Error on TypiaGenerator.generate(): input path is not a directory.",
+            );
+        else if ((await is_directory(props.output)) === false) {
+            const parent: string = path.join(props.output, "..");
+            if ((await is_directory(parent)) === false)
+                throw new Error(
+                    "Error on TypiaGenerator.generate(): output path is not a directory.",
+                );
+            await fs.promises.mkdir(props.output);
+        }
+
+        // CREATE PROGRAM
+        const { config } = ts.readConfigFile(props.project, ts.sys.readFile);
+
+        const program: ts.Program = ts.createProgram(
+            await gather(
+                await (async () => {
+                    const container: string[] = [];
+                    await gather(container)(props.input);
+                    return container;
+                })(),
+            )(props.input),
+            config,
+        );
+
+        // DO TRANSFORM
+        // const others = await get_other_transformers(config);
+        const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
+            program
+                .getSourceFiles()
+                .filter(
+                    (file) =>
+                        !file.isDeclarationFile &&
+                        path.resolve(file.fileName).indexOf(props.input) !== -1,
+                ),
+            [
+                // ...others.map((o) => o(program)),
+                transform(program),
+            ],
+            program.getCompilerOptions(),
+        );
+
+        // ARCHIVE TRANSFORMED FILES
+        const printer: ts.Printer = ts.createPrinter();
+        for (const file of result.transformed) {
+            const to: string = path
+                .resolve(file.fileName)
+                .replace(props.input, props.output);
+            const content: string = printer.printFile(file);
+
+            await fs.promises.writeFile(to, content, "utf8");
+        }
+    }
+
+    // const get_other_transformers = async (
+    //     config: any,
+    // ): Promise<
+    //     Array<(program: ts.Program) => ts.TransformerFactory<ts.SourceFile>>
+    // > => {
+    //     if (
+    //         typeof config.compilerOptions !== "object" ||
+    //         !Array.isArray(config.compilerOptions?.plugins)
+    //     )
+    //         return [];
+
+    //     const plugins: string[] = config.compilerOptions.plugins
+    //         .filter(
+    //             (p: any) =>
+    //                 typeof p === "object" && typeof p?.transform === "string",
+    //         )
+    //         .map((p: any) => p.transform)
+    //         .filter(
+    //             (str: string) =>
+    //                 str.indexOf("typia/lib/transform") === -1 &&
+    //                 str.indexOf("./src/transform.ts") === -1,
+    //         );
+
+    //     return Promise.all(
+    //         plugins.map(async (path: string) => {
+    //             const module: any = await import(path);
+    //             return module.default;
+    //         }),
+    //     );
+    // };
+
+    const is_directory = async (current: string): Promise<boolean> => {
+        const stat: fs.Stats = await fs.promises.stat(current);
+        return stat.isDirectory();
+    };
+
+    const gather = (container: string[]) => async (current: string) => {
+        const directory: string[] = await fs.promises.readdir(current);
+        for (const file of directory) {
+            const next: string = path.join(current, file);
+            const stat: fs.Stats = await fs.promises.stat(next);
+
+            if (stat.isDirectory()) {
+                await gather(container)(next);
+                continue;
+            } else if (file.substring(file.length - 3) === ".ts")
+                container.push(next);
+        }
+        return container;
+    };
+}

package/src/module.ts

@@ -3,6 +3,7 @@ import { Namespace } from "./functional/Namespace";
 import { IMetadataApplication } from "./metadata/IMetadataApplication";
 import { IJsonApplication } from "./schemas/IJsonApplication";
 
+import { IRandomGenerator } from "./IRandomGenerator";
 import { IValidation } from "./IValidation";
 import { Primitive } from "./Primitive";
 import { TypeGuardError } from "./TypeGuardError";
@@ -10,9 +11,10 @@ import { TypeGuardError } from "./TypeGuardError";
 export * from "./schemas/IJsonApplication";
 export * from "./schemas/IJsonComponents";
 export * from "./schemas/IJsonSchema";
+export * from "./IRandomGenerator";
+export * from "./IValidation";
 export * from "./Primitive";
 export * from "./TypeGuardError";
-export * from "./IValidation";
 
 /* ===========================================================
     SINGLE FUNCTIONS
@@ -853,11 +855,12 @@ export function metadata(): never {
  * would be generated instead.
  *
  * @template T Type of data to generate
+ * @param generator Random data generator
  * @return Randomly generated data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random(): never;
+export function random(generator?: IRandomGenerator): never;
 
 /**
  * Generate random data.
@@ -870,11 +873,12 @@ export function random(): never;
  * would be generated instead.
  *
  * @template T Type of data to generate
+ * generator Random data generator
  * @return Randomly generated data
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function random<T>(): Primitive<T>;
+export function random<T>(generator?: IRandomGenerator): Primitive<T>;
 
 /**
  * @internal
@@ -1466,12 +1470,12 @@ export function createIsParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createIsParse<T>(): (input: string) => T | null;
+export function createIsParse<T>(): (input: string) => Primitive<T> | null;
 
 /**
  * @internal
  */
-export function createIsParse<T>(): (input: string) => T | null {
+export function createIsParse<T>(): (input: string) => Primitive<T> | null {
     halt("createIsParse");
 }
 Object.assign(createIsParse, isParse);
@@ -1495,12 +1499,12 @@ export function createAssertParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createAssertParse<T>(): (input: string) => T;
+export function createAssertParse<T>(): (input: string) => Primitive<T>;
 
 /**
  * @internal
  */
-export function createAssertParse<T>(): (input: string) => T {
+export function createAssertParse<T>(): (input: string) => Primitive<T> {
     halt("createAssertParse");
 }
 Object.assign(createAssertParse, assertParse);
@@ -1524,12 +1528,16 @@ export function createValidateParse(): never;
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createValidateParse<T>(): (input: string) => IValidation<T>;
+export function createValidateParse<T>(): (
+    input: string,
+) => IValidation<Primitive<T>>;
 
 /**
  * @internal
  */
-export function createValidateParse<T>(): (input: string) => IValidation<T> {
+export function createValidateParse<T>(): (
+    input: string,
+) => IValidation<Primitive<T>> {
     halt("createValidateParse");
 }
 Object.assign(createValidateParse, validateParse);
@@ -1661,22 +1669,26 @@ Object.assign(createValidateStringify, validateStringify);
  * Creates a reusable {@link random} function.
  *
  * @danger You have to specify the generic argument `T`
+ * generator Random data generator
  * @return Nothing until specifying the generic argument `T`
  * @throws compile error
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom(): never;
+export function createRandom(generator?: IRandomGenerator): never;
 
 /**
  * Creates a resuable {@link random} function.
  *
  * @template T Type of the input value
+ * generator Random data generator
  * @returns A reusable `random` function
  *
  * @author Jeongho Nam - https://github.com/samchon
  */
-export function createRandom<T>(): () => Primitive<T>;
+export function createRandom<T>(
+    generator?: IRandomGenerator,
+): () => Primitive<T>;
 
 /**
  * @internal

package/src/programmers/AssertCloneProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -15,8 +16,19 @@ export namespace AssertCloneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.Primitive", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
@@ -53,7 +65,14 @@ export namespace AssertCloneProgrammer {
                         ),
                     ),
                     ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
+                        ts.factory.createAsExpression(
+                            ts.factory.createIdentifier("output"),
+                            project.checker.typeToTypeNode(
+                                type,
+                                undefined,
+                                undefined,
+                            ) ?? TypeFactory.keyword("any"),
+                        ),
                     ),
                 ]),
             );

package/src/programmers/AssertParseProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -14,8 +15,19 @@ export namespace AssertParseProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("string"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.Primitive", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(