@nestia/sdk 0.1.0

package/src/generates/FileGenerator.ts

@@ -0,0 +1,156 @@
+import fs from "fs";
+import { HashMap } from "tstl/container/HashMap";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { IRoute } from "../structures/IRoute";
+import { ImportDictionary } from "../utils/ImportDictionary";
+import { FunctionGenerator } from "./FunctionGenerator";
+
+export namespace FileGenerator {
+    /* ---------------------------------------------------------
+        CONSTRUCTOR
+    --------------------------------------------------------- */
+    export async function generate(
+        config: INestiaConfig,
+        routeList: IRoute[],
+    ): Promise<void> {
+        // CONSTRUCT FOLDER TREE
+        const root: Directory = new Directory(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, config.output + "/functional", root);
+    }
+
+    function emplace(directory: Directory, route: IRoute): void {
+        // SEPARATE IDENTIFIERS
+        const identifiers: string[] = route.path
+            .split("/")
+            .filter((str) => str[0] !== ":" && str.length !== 0)
+            .map((str) => str.split("-").join("_").split(".").join("_"));
+
+        // OPEN DIRECTORIES
+        for (const key of identifiers) {
+            directory = directory.directories.take(
+                key,
+                () => new Directory(directory, key),
+            );
+        }
+
+        // ADD ROUTE
+        directory.routes.push(route);
+    }
+
+    function relocate(directory: Directory): 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
+    --------------------------------------------------------- */
+    async function iterate(
+        config: INestiaConfig,
+        outDir: string,
+        directory: Directory,
+    ): 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, `${outDir}/${it.first}`, it.second);
+            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(FunctionGenerator.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");
+    }
+}
+
+class Directory {
+    public readonly module: string;
+    public readonly directories: HashMap<string, Directory>;
+    public readonly routes: IRoute[];
+
+    public constructor(
+        readonly parent: Directory | null,
+        readonly name: string,
+    ) {
+        this.directories = new HashMap();
+        this.routes = [];
+        this.module =
+            this.parent !== null
+                ? `${this.parent.module}.${name}`
+                : `api.${name}`;
+    }
+}

package/src/generates/FunctionGenerator.ts

@@ -0,0 +1,287 @@
+import { Vector } from "tstl/container/Vector";
+import { Pair } from "tstl/utility/Pair";
+import ts from "typescript";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { IRoute } from "../structures/IRoute";
+
+export namespace FunctionGenerator {
+    export function generate(config: INestiaConfig, route: IRoute): string {
+        const query: IRoute.IParameter | undefined = route.parameters.find(
+            (param) => param.category === "query" && param.field === undefined,
+        );
+        const input: IRoute.IParameter | undefined = route.parameters.find(
+            (param) => param.category === "body",
+        );
+
+        return [head, body, tail]
+            .map((closure) => closure(route, query, input, config))
+            .filter((str) => !!str)
+            .join("\n");
+    }
+
+    /* ---------------------------------------------------------
+        BODY
+    --------------------------------------------------------- */
+    function body(
+        route: IRoute,
+        query: IRoute.IParameter | undefined,
+        input: IRoute.IParameter | undefined,
+        config: INestiaConfig,
+    ): string {
+        // FETCH ARGUMENTS WITH REQUST BODY
+        const parameters = filter_parameters(route, query);
+        const fetchArguments: string[] = [
+            "connection",
+            `${route.name}.ENCRYPTED`,
+            `${route.name}.METHOD`,
+            `${route.name}.path(${parameters.map((p) => p.name).join(", ")})`,
+        ];
+        if (input !== undefined) {
+            fetchArguments.push(input.name);
+            if (config.json === true)
+                fetchArguments.push(`${route.name}.stringify`);
+        }
+
+        const assertions: string =
+            config.assert === true && route.parameters.length !== 0
+                ? route.parameters
+                      .map(
+                          (param) =>
+                              `    typia.assert<typeof ${param.name}>(${param.name});`,
+                      )
+                      .join("\n") + "\n\n"
+                : "";
+
+        // RETURNS WITH FINALIZATION
+        return (
+            "{\n" +
+            assertions +
+            "    return Fetcher.fetch\n" +
+            "    (\n" +
+            fetchArguments.map((param) => `        ${param}`).join(",\n") +
+            "\n" +
+            "    );\n" +
+            "}"
+        );
+    }
+
+    function filter_parameters(
+        route: IRoute,
+        query: IRoute.IParameter | undefined,
+    ): IRoute.IParameter[] {
+        const parameters: IRoute.IParameter[] = route.parameters.filter(
+            (param) =>
+                param.category === "param" ||
+                (param.category === "query" && param.field !== undefined),
+        );
+        if (query) parameters.push(query);
+        return parameters;
+    }
+
+    /* ---------------------------------------------------------
+        HEAD & TAIL
+    --------------------------------------------------------- */
+    function head(
+        route: IRoute,
+        query: IRoute.IParameter | undefined,
+        input: IRoute.IParameter | undefined,
+        config: INestiaConfig,
+    ): string {
+        //----
+        // CONSTRUCT COMMENT
+        //----
+        // MAIN DESCRIPTION
+        const comments: string[] = route.comments
+            .map((part) => `${part.kind === "linkText" ? " " : ""}${part.text}`)
+            .map((str) => str.split("\r\n").join("\n"))
+            .join("")
+            .split("\n")
+            .filter((str, i, array) => str !== "" || i !== array.length - 1);
+        if (comments.length) comments.push("");
+
+        // FILTER TAGS (VULNERABLE PARAMETERS WOULD BE REMOVED)
+        const tagList: ts.JSDocTagInfo[] = route.tags.filter(
+            (tag) => tag.text !== undefined,
+        );
+        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)",
+                        },
+                    ],
+                });
+            }
+            comments.push(
+                ...tagList.map(
+                    (tag) =>
+                        `@${tag.name} ${tag
+                            .text!.map((elem) => elem.text)
+                            .join("")}`,
+                ),
+                "",
+            );
+        }
+
+        // COMPLETE THE COMMENT
+        comments.push(
+            `@controller ${route.symbol}`,
+            `@path ${route.method} ${route.path}`,
+            `@nestia Generated by Nestia - https://github.com/samchon/nestia`,
+        );
+
+        //----
+        // FINALIZATION
+        //----
+        // REFORM PARAMETERS TEXT
+        const parameters: string[] = [
+            "connection: IConnection",
+            ...route.parameters.map((param) => {
+                const type: string =
+                    config.primitive !== false &&
+                    (param === query || param === input)
+                        ? `Primitive<${route.name}.${
+                              param === query ? "Query" : "Input"
+                          }>`
+                        : param.type.name;
+                return `${param.name}: ${type}`;
+            }),
+        ];
+
+        // OUTPUT TYPE
+        const output: string =
+            route.output.name === "void" ? "void" : `${route.name}.Output`;
+
+        // RETURNS WITH CONSTRUCTION
+        return (
+            "" +
+            "/**\n" +
+            comments.map((str) => ` * ${str}`).join("\n") +
+            "\n" +
+            " */\n" +
+            `export function ${route.name}\n` +
+            `    (\n` +
+            `${parameters.map((str) => `        ${str}`).join(",\n")}\n` +
+            `    ): Promise<${output}>`
+        );
+    }
+
+    function tail(
+        route: IRoute,
+        query: IRoute.IParameter | undefined,
+        input: IRoute.IParameter | undefined,
+        config: INestiaConfig,
+    ): string | null {
+        // LIST UP TYPES
+        const types: Pair<string, string>[] = [];
+        if (query !== undefined) types.push(new Pair("Query", query.type.name));
+        if (input !== undefined) types.push(new Pair("Input", input.type.name));
+        if (route.output.name !== "void")
+            types.push(new Pair("Output", route.output.name));
+
+        // PATH WITH PARAMETERS
+        const parameters: IRoute.IParameter[] = filter_parameters(route, query);
+        const path: string = compute_path(query, parameters, route.path);
+
+        return (
+            `export namespace ${route.name}\n` +
+            "{\n" +
+            (types.length !== 0
+                ? types
+                      .map(
+                          (tuple) =>
+                              `    export type ${tuple.first} = ${
+                                  config.primitive !== false
+                                      ? `Primitive<${tuple.second}>`
+                                      : tuple.second
+                              };`,
+                      )
+                      .join("\n") + "\n"
+                : "") +
+            "\n" +
+            `    export const METHOD = "${route.method}" as const;\n` +
+            `    export const PATH: string = "${route.path}";\n` +
+            `    export const ENCRYPTED: Fetcher.IEncrypted = {\n` +
+            `        request: ${input !== undefined && input.encrypted},\n` +
+            `        response: ${route.encrypted},\n` +
+            `    };\n` +
+            "\n" +
+            `    export function path(${parameters
+                .map((param) => `${param.name}: ${param.type.name}`)
+                .join(", ")}): string\n` +
+            `    {\n` +
+            `        return ${path};\n` +
+            `    }\n` +
+            (config.json === true &&
+            (route.method === "POST" ||
+                route.method === "PUT" ||
+                route.method === "PATCH")
+                ? `    export const stringify = (input: Input) => typia.stringify(input);\n`
+                : "") +
+            "}"
+        );
+    }
+
+    function compute_path(
+        query: IRoute.IParameter | undefined,
+        parameters: IRoute.IParameter[],
+        path: string,
+    ): string {
+        for (const param of parameters)
+            if (param.category === "param")
+                path = path.replace(
+                    `:${param.field}`,
+                    `\${encodeURIComponent(${param.name})}`,
+                );
+        const queryParams: IRoute.IParameter[] = parameters.filter(
+            (param) => param.category === "query" && param.field !== undefined,
+        );
+        if (query === undefined && queryParams.length === 0)
+            return `\`${path}\``;
+
+        const wrapper = (str: string) =>
+            `\`${path}?\${new URLSearchParams(${str}).toString()}\``;
+        if (query !== undefined && queryParams.length === 0)
+            return wrapper(`${query.name} as any`);
+        else if (query === undefined)
+            return wrapper(`
+        {
+            ${rest_query_parameters(queryParams)}
+        } as any`);
+
+        return wrapper(`
+        {
+            ...${query.name},
+            ${rest_query_parameters(queryParams)},
+        } as any`);
+    }
+
+    function rest_query_parameters(parameters: IRoute.IParameter[]): string {
+        return parameters
+            .map((param) =>
+                param.name === param.field
+                    ? param.name
+                    : `${
+                          Escaper.variable(param.field!)
+                              ? param.field
+                              : JSON.stringify(param.field)
+                      }: ${param.name}`,
+            )
+            .join(`,\n${" ".repeat(12)}`);
+    }
+}

package/src/generates/SdkGenerator.ts

@@ -0,0 +1,50 @@
+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";
+
+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 {}
+
+        // 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",
+                );
+            }
+        }
+
+        // FUNCTIONAL
+        await FileGenerator.generate(config, routeList);
+    }
+
+    export const BUNDLE_PATH = NodePath.join(
+        __dirname,
+        "..",
+        "..",
+        "assets",
+        "bundle",
+    );
+}