@nestia/sdk 1.3.2 → 1.3.3

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,144 +1,148 @@
-import fs from "fs";
-
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
-import { SdkRouteDirectory } from "./SdkRouteDirectory";
-
-export namespace SdkFileProgrammer {
-    /* ---------------------------------------------------------
-        CONSTRUCTOR
-    --------------------------------------------------------- */
-    export const generate =
-        (config: INestiaConfig) =>
-        async (routeList: IRoute[]): Promise<void> => {
-            // CONSTRUCT FOLDER TREE
-            const root: SdkRouteDirectory = new SdkRouteDirectory(
-                null,
-                "functional",
-            );
-            for (const route of routeList) emplace(root)(route);
-
-            // RELOCATE FOR ONLY ONE CONTROLLER METHOD IN AN URL CASE
-            relocate(root);
-
-            // ITERATE FILES
-            await iterate(config)(root)(config.output + "/functional");
-        };
-
-    const emplace =
-        (directory: SdkRouteDirectory) =>
-        (route: IRoute): void => {
-            // SEPARATE IDENTIFIERS
-            const identifiers: string[] = route.path
-                .split("/")
-                .filter((str) => str.length && str[0] !== ":")
-                .map((str) => str.split("-").join("_").split(".").join("_"));
-
-            // OPEN DIRECTORIES
-            for (const key of identifiers) {
-                directory = directory.directories.take(
-                    key,
-                    () => new SdkRouteDirectory(directory, key),
-                );
-            }
-
-            // ADD ROUTE
-            directory.routes.push(route);
-        };
-
-    const relocate = (directory: SdkRouteDirectory): void => {
-        if (
-            directory.parent !== null &&
-            directory.directories.empty() &&
-            directory.routes.length === 1 &&
-            directory.name === directory.routes[0].name
-        ) {
-            directory.parent.routes.push(directory.routes[0]);
-            directory.parent.directories.erase(directory.name);
-        } else if (directory.directories.empty() === false)
-            for (const it of directory.directories) relocate(it.second);
-    };
-
-    /* ---------------------------------------------------------
-        FILE ITERATOR
-    --------------------------------------------------------- */
-    const iterate =
-        (config: INestiaConfig) =>
-        (directory: SdkRouteDirectory) =>
-        async (outDir: string): Promise<void> => {
-            // CREATE A NEW DIRECTORY
-            try {
-                await fs.promises.mkdir(outDir);
-            } catch {}
-
-            // ITERATE CHILDREN
-            const content: string[] = [];
-            for (const it of directory.directories) {
-                await iterate(config)(it.second)(`${outDir}/${it.first}`);
-                content.push(`export * as ${it.first} from "./${it.first}";`);
-            }
-            if (content.length && directory.routes.length) content.push("");
-
-            // ITERATE ROUTES
-            const importDict: ImportDictionary = new ImportDictionary();
-            directory.routes.forEach((route, i) => {
-                for (const tuple of route.imports)
-                    for (const instance of tuple[1])
-                        importDict.emplace(tuple[0], false, instance);
-
-                content.push(SdkFunctionProgrammer.generate(config)(route));
-                if (i !== directory.routes.length - 1) content.push("");
-            });
-
-            // FINALIZE THE CONTENT
-            if (directory.routes.length !== 0) {
-                const primitived: boolean =
-                    config.primitive !== false &&
-                    directory.routes.some(
-                        (route) =>
-                            route.output.name !== "void" ||
-                            route.parameters.some(
-                                (param) => param.category !== "param",
-                            ),
-                    );
-                const asserted: boolean =
-                    config.assert === true &&
-                    directory.routes.some(
-                        (route) => route.parameters.length !== 0,
-                    );
-                const json: boolean =
-                    config.json === true &&
-                    directory.routes.some(
-                        (route) =>
-                            route.method === "POST" ||
-                            route.method === "PUT" ||
-                            route.method === "PATCH",
-                    );
-
-                const fetcher: string[] = ["Fetcher"];
-                if (primitived) fetcher.push("Primitive");
-
-                const head: string[] = [
-                    `import { ${fetcher.join(", ")} } from "@nestia/fetcher";`,
-                    `import type { IConnection } from "@nestia/fetcher";`,
-                ];
-                if (asserted || json) head.push(`import typia from "typia";`);
-                if (!importDict.empty())
-                    head.push("", importDict.toScript(outDir));
-
-                content.push(...head, "", ...content.splice(0, content.length));
-            }
-
-            const script: string =
-                "/**\n" +
-                " * @packageDocumentation\n" +
-                ` * @module ${directory.module}\n` +
-                " * @nestia Generated by Nestia - https://github.com/samchon/nestia \n" +
-                " */\n" +
-                "//================================================================\n" +
-                content.join("\n");
-            await fs.promises.writeFile(`${outDir}/index.ts`, script, "utf8");
-        };
-}
+import fs from "fs";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
+import { SdkRouteDirectory } from "./SdkRouteDirectory";
+
+export namespace SdkFileProgrammer {
+    /* ---------------------------------------------------------
+        CONSTRUCTOR
+    --------------------------------------------------------- */
+    export const generate =
+        (config: INestiaConfig) =>
+        async (routeList: IRoute[]): Promise<void> => {
+            // CONSTRUCT FOLDER TREE
+            const root: SdkRouteDirectory = new SdkRouteDirectory(
+                null,
+                "functional",
+            );
+            for (const route of routeList) emplace(root)(route);
+
+            // RELOCATE FOR ONLY ONE CONTROLLER METHOD IN AN URL CASE
+            relocate(root);
+
+            // ITERATE FILES
+            await iterate(config)(root)(config.output + "/functional");
+        };
+
+    const emplace =
+        (directory: SdkRouteDirectory) =>
+        (route: IRoute): void => {
+            // SEPARATE IDENTIFIERS
+            const identifiers: string[] = route.path
+                .split("/")
+                .filter((str) => str.length && str[0] !== ":")
+                .map((str) => str.split("-").join("_").split(".").join("_"));
+
+            // OPEN DIRECTORIES
+            for (const key of identifiers) {
+                directory = directory.directories.take(
+                    key,
+                    () => new SdkRouteDirectory(directory, key),
+                );
+            }
+
+            // ADD ROUTE
+            directory.routes.push(route);
+        };
+
+    const relocate = (directory: SdkRouteDirectory): void => {
+        if (
+            directory.parent !== null &&
+            directory.directories.empty() &&
+            directory.routes.length === 1 &&
+            directory.name === directory.routes[0].name
+        ) {
+            directory.parent.routes.push(directory.routes[0]);
+            directory.parent.directories.erase(directory.name);
+        } else if (directory.directories.empty() === false)
+            for (const it of directory.directories) relocate(it.second);
+    };
+
+    /* ---------------------------------------------------------
+        FILE ITERATOR
+    --------------------------------------------------------- */
+    const iterate =
+        (config: INestiaConfig) =>
+        (directory: SdkRouteDirectory) =>
+        async (outDir: string): Promise<void> => {
+            // CREATE A NEW DIRECTORY
+            try {
+                await fs.promises.mkdir(outDir);
+            } catch {}
+
+            // ITERATE CHILDREN
+            const content: string[] = [];
+            for (const it of directory.directories) {
+                await iterate(config)(it.second)(`${outDir}/${it.first}`);
+                content.push(`export * as ${it.first} from "./${it.first}";`);
+            }
+            if (content.length && directory.routes.length) content.push("");
+
+            // ITERATE ROUTES
+            const importDict: ImportDictionary = new ImportDictionary();
+            directory.routes.forEach((route, i) => {
+                for (const tuple of route.imports)
+                    for (const instance of tuple[1])
+                        importDict.emplace(tuple[0], false, instance);
+
+                content.push(SdkFunctionProgrammer.generate(config)(route));
+                if (i !== directory.routes.length - 1) content.push("");
+            });
+
+            // FINALIZE THE CONTENT
+            if (directory.routes.length !== 0) {
+                const primitived: boolean =
+                    config.primitive !== false &&
+                    directory.routes.some(
+                        (route) =>
+                            route.output.name !== "void" ||
+                            route.parameters.some(
+                                (param) => param.category !== "param",
+                            ),
+                    );
+                const asserted: boolean =
+                    config.assert === true &&
+                    directory.routes.some(
+                        (route) => route.parameters.length !== 0,
+                    );
+                const json: boolean =
+                    config.json === true &&
+                    directory.routes.some(
+                        (route) =>
+                            route.method === "POST" ||
+                            route.method === "PUT" ||
+                            route.method === "PATCH",
+                    );
+                const random: boolean =
+                    config.random === true &&
+                    directory.routes.some((s) => s.output.name !== "void");
+
+                const fetcher: string[] = ["Fetcher"];
+                if (primitived) fetcher.push("Primitive");
+
+                const head: string[] = [
+                    `import { ${fetcher.join(", ")} } from "@nestia/fetcher";`,
+                    `import type { IConnection } from "@nestia/fetcher";`,
+                ];
+                if (asserted || json || random)
+                    head.push(`import typia from "typia";`);
+                if (!importDict.empty())
+                    head.push("", importDict.toScript(outDir));
+
+                content.push(...head, "", ...content.splice(0, content.length));
+            }
+
+            const script: string =
+                "/**\n" +
+                " * @packageDocumentation\n" +
+                ` * @module ${directory.module}\n` +
+                " * @nestia Generated by Nestia - https://github.com/samchon/nestia \n" +
+                " */\n" +
+                "//================================================================\n" +
+                content.join("\n");
+            await fs.promises.writeFile(`${outDir}/index.ts`, script, "utf8");
+        };
+}

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -1,6 +1,4 @@
-import { Vector } from "tstl/container/Vector";
 import { Pair } from "tstl/utility/Pair";
-import ts from "typescript";
 
 import { Escaper } from "typia/lib/utils/Escaper";
 
@@ -19,10 +17,10 @@ export namespace SdkFunctionProgrammer {
                 (param) => param.category === "body",
             );
 
-            return [head, body, tail]
-                .map((closure) => closure(config)(route)({ query, input }))
-                .filter((str) => !!str)
-                .join("\n");
+            const [x, y, z] = [head, body, tail].map((closure) =>
+                closure(config)(route)({ query, input }),
+            );
+            return `${x} ${y}\n${z}`;
         };
 
     /* ---------------------------------------------------------
@@ -62,20 +60,34 @@ export namespace SdkFunctionProgrammer {
                     : "";
 
             // FUNCTION CALL STATEMENT
-            const caller: string =
-                "Fetcher.fetch\n" +
-                "    (\n" +
-                fetchArguments.map((param) => `        ${param}`).join(",\n") +
-                "\n" +
-                "    )";
+            const caller = (awa: boolean) => {
+                const random = () =>
+                    route.output.name === "void"
+                        ? "undefined"
+                        : `typia.random<${route.name}.Output>()`;
+                const fetch = (tab: string) =>
+                    [
+                        `${awa ? "await " : ""} Fetcher.fetch(`,
+                        fetchArguments
+                            .map((param) => `${tab}    ${param}`)
+                            .join(",\n"),
+                        `${tab})`,
+                    ].join("\n");
+                if (!config.random) return fetch(" ".repeat(8));
+                return (
+                    `connection.random\n` +
+                    `        ? ${random()}\n` +
+                    `        : ${fetch(" ".repeat(10))}`
+                );
+            };
             if (route.setHeaders.length === 0)
-                return `{\n${assertions}    return ${caller};\n}`;
+                return `{\n${assertions}    return ${caller(false)};\n}`;
 
             // SET HEADERS
             const content: string[] = [
                 `{\n`,
                 assertions,
-                `    const output: ${route.name}.Output = await ${caller};\n`,
+                `    const output: ${route.name}.Output = ${caller(true)};\n`,
                 "\n",
                 `    // configure header(s)\n`,
                 `    connection.headers ??= {};\n`,
@@ -136,35 +148,6 @@ export namespace SdkFunctionProgrammer {
                 ? route.description.split("\n")
                 : [];
 
-            // FILTER TAGS (VULNERABLE PARAMETERS WOULD BE REMOVED)
-            const tagList: ts.JSDocTagInfo[] = route.tags.slice();
-            if (tagList.length !== 0) {
-                const index: number = tagList.findIndex(
-                    (t) => t.name === "param",
-                );
-                if (index !== -1) {
-                    const capsule: Vector<ts.JSDocTagInfo> =
-                        Vector.wrap(tagList);
-                    capsule.insert(capsule.nth(index), {
-                        name: "param",
-                        text: [
-                            {
-                                kind: "parameterName",
-                                text: "connection",
-                            },
-                            {
-                                kind: "space",
-                                text: " ",
-                            },
-                            {
-                                kind: "text",
-                                text: "connection Information of the remote HTTP(s) server with headers (+encryption password)",
-                            },
-                        ],
-                    });
-                }
-            }
-
             // COMPLETE THE COMMENT
             if (!!comments.length) comments.push("");
             comments.push(
@@ -202,10 +185,7 @@ export namespace SdkFunctionProgrammer {
                 comments.map((str) => ` * ${str}`).join("\n") +
                 "\n" +
                 " */\n" +
-                `export${route.setHeaders.length ? " async" : ""} function ${
-                    route.name
-                }\n` +
-                `    (\n` +
+                `export async function ${route.name} (\n` +
                 `${parameters.map((str) => `        ${str}`).join(",\n")}\n` +
                 `    ): Promise<${output}>`
             );
@@ -217,7 +197,7 @@ export namespace SdkFunctionProgrammer {
         (props: {
             query: IRoute.IParameter | undefined;
             input: IRoute.IParameter | undefined;
-        }): string | null => {
+        }): string => {
             // LIST UP TYPES
             const types: Pair<string, string>[] = [];
             if (props.query !== undefined)
@@ -238,8 +218,7 @@ export namespace SdkFunctionProgrammer {
             });
 
             return (
-                `export namespace ${route.name}\n` +
-                "{\n" +
+                `export namespace ${route.name} {\n` +
                 (types.length !== 0
                     ? types
                           .map(
@@ -267,8 +246,7 @@ export namespace SdkFunctionProgrammer {
                 "\n" +
                 `    export function path(${parameters
                     .map((param) => `${param.name}: ${param.type.name}`)
-                    .join(", ")}): string\n` +
-                `    {\n` +
+                    .join(", ")}): string {\n` +
                 `${path};\n` +
                 `    }\n` +
                 (config.json === true &&

package/src/generates/internal/SdkRouteDirectory.ts

@@ -1,21 +1,21 @@
-import { HashMap } from "tstl";
-
-import { IRoute } from "../../structures/IRoute";
-
-export class SdkRouteDirectory {
-    public readonly module: string;
-    public readonly directories: HashMap<string, SdkRouteDirectory>;
-    public readonly routes: IRoute[];
-
-    public constructor(
-        readonly parent: SdkRouteDirectory | null,
-        readonly name: string,
-    ) {
-        this.directories = new HashMap();
-        this.routes = [];
-        this.module =
-            this.parent !== null
-                ? `${this.parent.module}.${name}`
-                : `api.${name}`;
-    }
-}
+import { HashMap } from "tstl";
+
+import { IRoute } from "../../structures/IRoute";
+
+export class SdkRouteDirectory {
+    public readonly module: string;
+    public readonly directories: HashMap<string, SdkRouteDirectory>;
+    public readonly routes: IRoute[];
+
+    public constructor(
+        readonly parent: SdkRouteDirectory | null,
+        readonly name: string,
+    ) {
+        this.directories = new HashMap();
+        this.routes = [];
+        this.module =
+            this.parent !== null
+                ? `${this.parent.module}.${name}`
+                : `api.${name}`;
+    }
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as nestia from "./module";
-
-export * from "./module";
-export default nestia;
+import * as nestia from "./module";
+
+export * from "./module";
+export default nestia;

package/src/module.ts

@@ -1,2 +1,2 @@
-export * from "./INestiaConfig";
-export * from "./NestiaSdkApplication";
+export * from "./INestiaConfig";
+export * from "./NestiaSdkApplication";

package/src/structures/IController.ts

@@ -1,31 +1,31 @@
-import { ParamCategory } from "./ParamCategory";
-
-export interface IController {
-    file: string;
-    name: string;
-    paths: string[];
-    functions: IController.IFunction[];
-}
-
-export namespace IController {
-    export interface IFunction {
-        name: string;
-        method: string;
-        paths: string[];
-        encrypted: boolean;
-        parameters: IParameter[];
-        status?: number;
-    }
-
-    export interface IParameter {
-        name: string;
-        index: number;
-        field: string | undefined;
-        category: ParamCategory;
-        encrypted: boolean;
-        meta?: {
-            type: string;
-            nullable: boolean;
-        };
-    }
-}
+import { ParamCategory } from "./ParamCategory";
+
+export interface IController {
+    file: string;
+    name: string;
+    paths: string[];
+    functions: IController.IFunction[];
+}
+
+export namespace IController {
+    export interface IFunction {
+        name: string;
+        method: string;
+        paths: string[];
+        encrypted: boolean;
+        parameters: IParameter[];
+        status?: number;
+    }
+
+    export interface IParameter {
+        name: string;
+        index: number;
+        field: string | undefined;
+        category: ParamCategory;
+        encrypted: boolean;
+        meta?: {
+            type: string;
+            nullable: boolean;
+        };
+    }
+}

package/src/structures/IRoute.ts

@@ -1,39 +1,39 @@
-import ts from "typescript";
-
-import { ITypeTuple } from "./ITypeTuple";
-import { ParamCategory } from "./ParamCategory";
-
-export interface IRoute {
-    name: string;
-    method: string;
-    path: string;
-    encrypted: boolean;
-    status?: number;
-
-    parameters: IRoute.IParameter[];
-    imports: [string, string[]][];
-    output: ITypeTuple;
-
-    symbol: string;
-    description?: string;
-    tags: ts.JSDocTagInfo[];
-    setHeaders: Array<
-        | { type: "setter"; source: string; target?: string }
-        | { type: "assigner"; source: string }
-    >;
-}
-
-export namespace IRoute {
-    export interface IParameter {
-        name: string;
-        field: string | undefined;
-        category: ParamCategory;
-        encrypted: boolean;
-        type: ITypeTuple;
-        optional: boolean;
-        meta?: {
-            type: string;
-            nullable: boolean;
-        };
-    }
-}
+import ts from "typescript";
+
+import { ITypeTuple } from "./ITypeTuple";
+import { ParamCategory } from "./ParamCategory";
+
+export interface IRoute {
+    name: string;
+    method: string;
+    path: string;
+    encrypted: boolean;
+    status?: number;
+
+    parameters: IRoute.IParameter[];
+    imports: [string, string[]][];
+    output: ITypeTuple;
+
+    symbol: string;
+    description?: string;
+    tags: ts.JSDocTagInfo[];
+    setHeaders: Array<
+        | { type: "setter"; source: string; target?: string }
+        | { type: "assigner"; source: string }
+    >;
+}
+
+export namespace IRoute {
+    export interface IParameter {
+        name: string;
+        field: string | undefined;
+        category: ParamCategory;
+        encrypted: boolean;
+        type: ITypeTuple;
+        optional: boolean;
+        meta?: {
+            type: string;
+            nullable: boolean;
+        };
+    }
+}