@nestia/sdk 1.1.0 → 1.2.0-dev.20230504

package/src/generates/SdkGenerator.ts

@@ -1,44 +1,42 @@
 import fs from "fs";
 import NodePath from "path";
-import ts from "typescript";
 
 import { INestiaConfig } from "../INestiaConfig";
 import { IRoute } from "../structures/IRoute";
-import { FileGenerator } from "./FileGenerator";
+import { SdkFileProgrammer } from "./internal/SdkFileProgrammer";
 
 export namespace SdkGenerator {
-    export async function generate(
-        _checker: ts.TypeChecker,
-        config: INestiaConfig,
-        routeList: IRoute[],
-    ): Promise<void> {
-        // PREPARE NEW DIRECTORIES
-        try {
-            await fs.promises.mkdir(config.output!);
-        } catch {}
+    export const generate =
+        (config: INestiaConfig) =>
+        async (routes: IRoute[]): Promise<void> => {
+            // PREPARE NEW DIRECTORIES
+            try {
+                await fs.promises.mkdir(config.output!);
+            } catch {}
 
-        // BUNDLING
-        const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
-        for (const file of bundle) {
-            const current: string = `${BUNDLE_PATH}/${file}`;
-            const stats: fs.Stats = await fs.promises.stat(current);
+            // BUNDLING
+            const bundle: string[] = await fs.promises.readdir(BUNDLE_PATH);
+            for (const file of bundle) {
+                const current: string = `${BUNDLE_PATH}/${file}`;
+                const stats: fs.Stats = await fs.promises.stat(current);
 
-            if (stats.isFile() === true) {
-                const content: string = await fs.promises.readFile(
-                    current,
-                    "utf8",
-                );
-                await fs.promises.writeFile(
-                    `${config.output}/${file}`,
-                    content,
-                    "utf8",
-                );
+                if (stats.isFile() === true) {
+                    const content: string = await fs.promises.readFile(
+                        current,
+                        "utf8",
+                    );
+                    if (fs.existsSync(`${config.output}/${file}`) === false)
+                        await fs.promises.writeFile(
+                            `${config.output}/${file}`,
+                            content,
+                            "utf8",
+                        );
+                }
             }
-        }
 
-        // FUNCTIONAL
-        await FileGenerator.generate(config, routeList);
-    }
+            // FUNCTIONAL
+            await SdkFileProgrammer.generate(config)(routes);
+        };
 
     export const BUNDLE_PATH = NodePath.join(
         __dirname,
@@ -46,5 +44,6 @@ export namespace SdkGenerator {
         "..",
         "assets",
         "bundle",
+        "api",
     );
 }

package/src/generates/SwaggerGenerator.ts

@@ -17,72 +17,74 @@ import { ISwaggerDocument } from "../structures/ISwaggerDocument";
 import { MapUtil } from "../utils/MapUtil";
 
 export namespace SwaggerGenerator {
-    export async function generate(
-        checker: ts.TypeChecker,
-        config: INestiaConfig.ISwaggerConfig,
-        routeList: IRoute[],
-    ): Promise<void> {
-        // PREPARE ASSETS
-        const parsed: NodePath.ParsedPath = NodePath.parse(config.output);
-        const location: string = !!parsed.ext
-            ? NodePath.resolve(config.output)
-            : NodePath.join(NodePath.resolve(config.output), "swagger.json");
-
-        const collection: MetadataCollection = new MetadataCollection({
-            replace: MetadataCollection.replace,
-        });
-
-        // CONSTRUCT SWAGGER DOCUMENTS
-        const tupleList: Array<ISchemaTuple> = [];
-        const swagger: ISwaggerDocument = await initialize(location);
-        const pathDict: Map<string, ISwaggerDocument.IPath> = new Map();
-
-        for (const route of routeList) {
-            if (route.tags.find((tag) => tag.name === "internal")) continue;
-
-            const path: ISwaggerDocument.IPath = MapUtil.take(
-                pathDict,
-                get_path(route.path, route.parameters),
-                () => ({}),
-            );
-            path[route.method.toLowerCase()] = generate_route(
-                checker,
-                collection,
-                tupleList,
-                route,
+    export const generate =
+        (checker: ts.TypeChecker) =>
+        (config: INestiaConfig.ISwaggerConfig) =>
+        async (routeList: IRoute[]): Promise<void> => {
+            // PREPARE ASSETS
+            const parsed: NodePath.ParsedPath = NodePath.parse(config.output);
+            const location: string = !!parsed.ext
+                ? NodePath.resolve(config.output)
+                : NodePath.join(
+                      NodePath.resolve(config.output),
+                      "swagger.json",
+                  );
+
+            const collection: MetadataCollection = new MetadataCollection({
+                replace: MetadataCollection.replace,
+            });
+
+            // CONSTRUCT SWAGGER DOCUMENTS
+            const tupleList: Array<ISchemaTuple> = [];
+            const swagger: ISwaggerDocument = await initialize(location);
+            const pathDict: Map<string, ISwaggerDocument.IPath> = new Map();
+
+            for (const route of routeList) {
+                if (route.tags.find((tag) => tag.name === "internal")) continue;
+
+                const path: ISwaggerDocument.IPath = MapUtil.take(
+                    pathDict,
+                    get_path(route.path, route.parameters),
+                    () => ({}),
+                );
+                path[route.method.toLowerCase()] = generate_route(
+                    checker,
+                    collection,
+                    tupleList,
+                    route,
+                );
+            }
+            swagger.paths = {};
+            for (const [path, routes] of pathDict) {
+                swagger.paths[path] = routes;
+            }
+
+            // FILL JSON-SCHEMAS
+            const application: IJsonApplication = ApplicationProgrammer.write({
+                purpose: "swagger",
+            })(tupleList.map(({ metadata }) => metadata));
+            swagger.components = {
+                ...(swagger.components ?? {}),
+                schemas: application.components.schemas,
+            };
+            tupleList.forEach(({ schema }, index) => {
+                Object.assign(schema, application.schemas[index]!);
+            });
+
+            // CONFIGURE SECURITY
+            if (config.security) fill_security(config.security, swagger);
+
+            // ERASE IJsonComponents.IObject.$id
+            for (const obj of Object.values(swagger.components.schemas))
+                if (obj.$id) delete obj.$id;
+
+            // DO GENERATE
+            await fs.promises.writeFile(
+                location,
+                JSON.stringify(swagger, null, 2),
+                "utf8",
             );
-        }
-        swagger.paths = {};
-        for (const [path, routes] of pathDict) {
-            swagger.paths[path] = routes;
-        }
-
-        // FILL JSON-SCHEMAS
-        const application: IJsonApplication = ApplicationProgrammer.write({
-            purpose: "swagger",
-        })(tupleList.map(({ metadata }) => metadata));
-        swagger.components = {
-            ...(swagger.components ?? {}),
-            schemas: application.components.schemas,
         };
-        tupleList.forEach(({ schema }, index) => {
-            Object.assign(schema, application.schemas[index]!);
-        });
-
-        // CONFIGURE SECURITY
-        if (config.security) fill_security(config.security, swagger);
-
-        // ERASE IJsonComponents.IObject.$id
-        for (const obj of Object.values(swagger.components.schemas))
-            if (obj.$id) delete obj.$id;
-
-        // DO GENERATE
-        await fs.promises.writeFile(
-            location,
-            JSON.stringify(swagger, null, 2),
-            "utf8",
-        );
-    }
 
     /* ---------------------------------------------------------
         INITIALIZERS

package/src/generates/internal/E2eFileProgrammer.ts

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+
+export namespace E2eFileProgrammer {
+    export const generate =
+        (config: INestiaConfig) =>
+        (props: { api: string; current: string }) =>
+        async (route: IRoute): Promise<void> => {
+            const importDict: ImportDictionary = new ImportDictionary();
+            for (const tuple of route.imports)
+                for (const instance of tuple[1])
+                    importDict.emplace(tuple[0], false, instance);
+
+            const uuid: boolean = route.parameters.some(
+                (p) => p.category === "param" && p.meta?.type === "uuid",
+            );
+            const content: string = [
+                config.primitive === false
+                    ? `import typia from "typia";`
+                    : `import typia, { Primitive } from "typia";`,
+                "",
+                `import api from "./${path
+                    .relative(props.current, props.api)
+                    .split("\\")
+                    .join("/")}";`,
+                ...(importDict.empty()
+                    ? []
+                    : [importDict.toScript(props.current)]),
+                "",
+                arrow(config)(route),
+                ...(uuid ? ["", UUID] : []),
+            ].join("\n");
+
+            await fs.promises.writeFile(
+                `${props.current}/${name(route)}.ts`,
+                content,
+                "utf8",
+            );
+        };
+
+    const arrow =
+        (config: INestiaConfig) =>
+        (route: IRoute): string => {
+            const tab: number = route.output.name === "void" ? 2 : 3;
+            const output = [
+                `await ${accessor(route)}(`,
+                `${" ".repeat(tab * 4)}connection,`,
+                ...route.parameters.map(parameter(config)(tab)),
+                `${" ".repeat((tab - 1) * 4)});`,
+            ].join("\n");
+            return [
+                `export const ${name(route)} = async (`,
+                `    connection: api.IConnection`,
+                `): Promise<void> => {`,
+                ...(route.output.name === "void"
+                    ? [`    ${output}`]
+                    : [
+                          `    const output: ${primitive(config)(
+                              route.output.name,
+                          )} = `,
+                          `        ${output}`,
+                          `    typia.assert(output);`,
+                      ]),
+                `};`,
+            ].join("\n");
+        };
+
+    const parameter =
+        (config: INestiaConfig) =>
+        (tab: number) =>
+        (param: IRoute.IParameter): string => {
+            const middle: string =
+                param.category === "param" && param.meta?.type === "uuid"
+                    ? param.meta.nullable
+                        ? `Math.random() < .2 ? null : uuid()`
+                        : `uuid()`
+                    : `typia.random<${primitive(config)(param.type.name)}>()`;
+            return `${" ".repeat(4 * tab)}${middle},`;
+        };
+
+    const name = (route: IRoute): string =>
+        [
+            "test_api",
+            ...route.path
+                .split("/")
+                .filter((str) => str.length && str[0] !== ":")
+                .map(normalize),
+            route.name,
+        ].join("_");
+
+    const accessor = (route: IRoute): string =>
+        [
+            "api.functional",
+            ...route.path
+                .split("/")
+                .filter((str) => str.length && str[0] !== ":")
+                .map(normalize),
+            route.name,
+        ].join(".");
+
+    const normalize = (str: string) =>
+        str.split("-").join("_").split(".").join("_");
+
+    const primitive =
+        (config: INestiaConfig) =>
+        (name: string): string =>
+            config.primitive !== false ? `Primitive<${name}>` : name;
+}
+
+const UUID = `const uuid = (): string =>
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });`;

package/src/generates/internal/SdkFileProgrammer.ts

@@ -0,0 +1,144 @@
+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");
+        };
+}