@nestia/sdk 2.0.0-dev.20230991 → 2.0.1

package/src/executable/internal/NestiaConfigLoader.ts

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import { WorkerConnector } from "tgrid/protocols/workers/WorkerConnector";
+import { register } from "ts-node";
+import { parseNative } from "tsconfck";
+import ts from "typescript";
+
+import typia from "typia";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { NestiaProjectGetter } from "./NestiaProjectGetter";
+
+export namespace NestiaConfigLoader {
+    export const compilerOptions = async (
+        project: string,
+    ): Promise<ts.CompilerOptions> => {
+        const configFileName = ts.findConfigFile(
+            process.cwd(),
+            ts.sys.fileExists,
+            project,
+        );
+        if (!configFileName)
+            throw new Error(`unable to find "tsconfig.json" file.`);
+
+        const { tsconfig } = await parseNative(configFileName);
+        const configFileText = JSON.stringify(tsconfig);
+        const { config } = ts.parseConfigFileTextToJson(
+            configFileName,
+            configFileText,
+        );
+        const configParseResult = ts.parseJsonConfigFileContent(
+            config,
+            ts.sys,
+            path.dirname(configFileName),
+        );
+
+        const { moduleResolution, ...result } =
+            configParseResult.raw.compilerOptions;
+        return result;
+    };
+
+    export const config = async (
+        options: ts.CompilerOptions,
+    ): Promise<INestiaConfig> => {
+        if (fs.existsSync(path.resolve("nestia.config.ts")) === false)
+            throw new Error(`unable to find "nestia.config.ts" file.`);
+
+        register({
+            emit: false,
+            compilerOptions: options,
+            require: options.baseUrl ? ["tsconfig-paths/register"] : undefined,
+        });
+
+        const loaded: INestiaConfig & { default?: INestiaConfig } =
+            await import(path.resolve("nestia.config.ts"));
+        const config: INestiaConfig =
+            typeof loaded?.default === "object" && loaded.default !== null
+                ? loaded.default
+                : loaded;
+
+        try {
+            return typia.assert(config);
+        } catch (exp) {
+            if (typia.is<typia.TypeGuardError>(exp))
+                exp.message = `invalid "nestia.config.ts" data.`;
+            throw exp;
+        }
+    };
+
+    export const project = async (): Promise<string> => {
+        const connector = new WorkerConnector(null, null, "process");
+        await connector.connect(
+            `${__dirname}/nestia.project.getter.${__filename.substr(-2)}`,
+        );
+
+        const driver = await connector.getDriver<typeof NestiaProjectGetter>();
+        const project: string = await driver.get();
+        await connector.close();
+
+        return project;
+    };
+}

package/src/executable/internal/NestiaProjectGetter.ts

@@ -0,0 +1,11 @@
+import { NestiaConfigLoader } from "./NestiaConfigLoader";
+
+export namespace NestiaProjectGetter {
+    export async function get(): Promise<string> {
+        const config = await NestiaConfigLoader.config({
+            module: "CommonJS" as any,
+            noEmit: true,
+        });
+        return config.project ?? "tsconfig.json";
+    }
+}

package/src/executable/internal/NestiaSdkCommand.ts

@@ -1,157 +1,34 @@
-import cli from "cli";
-import path from "path";
-import { WorkerConnector } from "tgrid/protocols/workers/WorkerConnector";
-import { parseNative } from "tsconfck";
 import ts from "typescript";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { NestiaSdkApplication } from "../../NestiaSdkApplication";
-import { NestiaSdkConfig } from "./NestiaSdkConfig";
-
-interface ICommand {
-    exclude: string | null;
-    out: string | null;
-    e2e: string | null;
-}
-
-interface IProps {
-    assign: (config: INestiaConfig, output: string) => void;
-    validate: (config: INestiaConfig) => boolean;
-    location: (config: INestiaConfig) => string;
-}
+import { NestiaConfigLoader } from "./NestiaConfigLoader";
 
 export namespace NestiaSdkCommand {
-    export const sdk = (argv: string[]) =>
-        main({
-            assign: (config, output) => (config.output = output),
-            validate: (config) => !!config.output,
-            location: (config) => config.output!,
-        })(argv)((app) => app.sdk());
-
-    export const swagger = (argv: string[]) =>
-        main({
-            assign: (config, output) => {
-                if (!config.swagger) config.swagger = { output };
-                else config.swagger.output = output;
-            },
-            validate: (config) => !!config.swagger && !!config.swagger.output,
-            location: (config) => config.swagger!.output!,
-        })(argv)((app) => app.swagger());
-
-    export const e2e = (argv: string[]) =>
-        main({
-            assign: (config, output) => (config.output = output),
-            validate: (config) => !!config.output,
-            location: (config) => config.output!,
-        })(argv)((app) => app.e2e());
-
-    const main =
-        (props: IProps) =>
-        (argv: string[]) =>
-        async (task: (app: NestiaSdkApplication) => Promise<void>) => {
-            const command: ICommand = cli.parse({
-                exclude: ["e", "Something to exclude", "string", null],
-                out: ["o", "Output path of the SDK files", "string", null],
-                e2e: [
-                    "e",
-                    "Output path of e2e test function files",
-                    "string",
-                    null,
-                ],
-            });
-
-            const inputs: string[] = [];
-            for (const r of argv) {
-                if (r[0] === "-") break;
-                inputs.push(r);
-            }
-            await generate(props)(command)(inputs)(task);
-        };
-
-    const generate =
-        (props: IProps) =>
-        (command: ICommand) =>
-        (include: string[]) =>
-        async (task: (app: NestiaSdkApplication) => Promise<void>) => {
-            // CONFIGURATION
-            const config: INestiaConfig =
-                (await get_nestia_config(props.validate)) ??
-                parse_cli(props)(command)(include);
-
-            const options: ts.CompilerOptions | null =
-                await get_typescript_options();
-            config.compilerOptions = {
-                ...(options ?? {}),
-                ...(config.compilerOptions ?? {}),
-            };
-
-            // CALL THE APP.GENERATE()
-            const app: NestiaSdkApplication = new NestiaSdkApplication(config);
-            await task(app);
-        };
-
-    async function get_typescript_options(): Promise<ts.CompilerOptions | null> {
-        const configFileName = ts.findConfigFile(
-            process.cwd(),
-            ts.sys.fileExists,
-            "tsconfig.json",
+    export const sdk = () => main((app) => app.sdk());
+    export const swagger = () => main((app) => app.swagger());
+    export const e2e = () => main((app) => app.e2e());
+
+    const main = async (task: (app: NestiaSdkApplication) => Promise<void>) => {
+        await generate(task);
+    };
+
+    const generate = async (
+        task: (app: NestiaSdkApplication) => Promise<void>,
+    ) => {
+        // LOAD CONFIG INFO
+        const project: string = await NestiaConfigLoader.project();
+        const compilerOptions: ts.CompilerOptions =
+            await NestiaConfigLoader.compilerOptions(project);
+        const config: INestiaConfig = await NestiaConfigLoader.config(
+            compilerOptions,
         );
-        if (!configFileName) return null;
 
-        const { tsconfig } = await parseNative(configFileName);
-        const configFileText = JSON.stringify(tsconfig);
-        const { config } = ts.parseConfigFileTextToJson(
-            configFileName,
-            configFileText,
-        );
-        const configParseResult = ts.parseJsonConfigFileContent(
+        // GENERATE
+        const app: NestiaSdkApplication = new NestiaSdkApplication(
             config,
-            ts.sys,
-            path.dirname(configFileName),
-        );
-
-        const { moduleResolution, ...result } =
-            configParseResult.raw.compilerOptions;
-        return result;
-    }
-
-    async function get_nestia_config(
-        validate: (config: INestiaConfig) => boolean,
-    ): Promise<INestiaConfig | null> {
-        const connector = new WorkerConnector(null, null, "process");
-        await connector.connect(
-            `${__dirname}/nestia.config.getter.${__filename.substr(-2)}`,
+            compilerOptions,
         );
-
-        const driver = await connector.getDriver<typeof NestiaSdkConfig>();
-        const config: INestiaConfig | null = await driver.get();
-        await connector.close();
-
-        if (config !== null && validate(config) === false)
-            throw new Error(
-                `Error on NestiaCommand.main(): output path is not specified in the "nestia.config.ts".`,
-            );
-
-        return config;
-    }
-
-    const parse_cli =
-        (props: IProps) =>
-        (command: ICommand) =>
-        (include: string[]): INestiaConfig => {
-            if (command.out === null)
-                throw new Error(
-                    `Error on NestiaCommand.main(): output directory is not specified. Add the "--out <output_directory>" option.`,
-                );
-
-            const config: INestiaConfig = {
-                input: {
-                    include,
-                    exclude: command.exclude ? [command.exclude] : undefined,
-                },
-                e2e: command.e2e ?? undefined,
-            };
-            props.assign(config, command.out);
-            return config;
-        };
+        await task(app);
+    };
 }

package/src/executable/internal/{nestia.config.getter.ts → nestia.project.getter.ts}

@@ -1,10 +1,10 @@
 import { WorkerServer } from "tgrid/protocols/workers/WorkerServer";
 
-import { NestiaSdkConfig } from "./NestiaSdkConfig";
+import { NestiaProjectGetter } from "./NestiaProjectGetter";
 
 async function main(): Promise<void> {
     const worker = new WorkerServer();
-    await worker.open(NestiaSdkConfig);
+    await worker.open(NestiaProjectGetter);
 }
 main().catch((exp) => {
     console.log(exp);

package/src/executable/sdk.ts

@@ -59,9 +59,9 @@ async function main() {
 
     if (type === "dependencies") dependencies(argv);
     else if (type === "init") await initialize();
-    else if (type === "sdk") await execute((c) => c.sdk(argv));
-    else if (type === "swagger") await execute((c) => c.swagger(argv));
-    else if (type === "e2e") await execute((c) => c.e2e(argv));
+    else if (type === "sdk") await execute((c) => c.sdk());
+    else if (type === "swagger") await execute((c) => c.swagger());
+    else if (type === "e2e") await execute((c) => c.e2e());
     else halt(USAGE);
 }
 main().catch((exp) => {

package/src/generates/SdkGenerator.ts

@@ -1,14 +1,17 @@
 import fs from "fs";
 import NodePath from "path";
 import { IPointer } from "tstl";
+import ts from "typescript";
 
 import { INestiaConfig } from "../INestiaConfig";
 import { IRoute } from "../structures/IRoute";
-import { DistributionComposer } from "./internal/DistributionComposer";
+import { SdkDistributionComposer } from "./internal/SdkDistributionComposer";
+import { SdkDtoGenerator } from "./internal/SdkDtoGenerator";
 import { SdkFileProgrammer } from "./internal/SdkFileProgrammer";
 
 export namespace SdkGenerator {
     export const generate =
+        (checker: ts.TypeChecker) =>
         (config: INestiaConfig) =>
         async (routes: IRoute[]): Promise<void> => {
             console.log("Generating SDK Library");
@@ -55,12 +58,16 @@ export namespace SdkGenerator {
                 );
             }
 
+            // STRUCTURES
+            if (config.clone)
+                await SdkDtoGenerator.generate(checker)(config)(routes);
+
             // FUNCTIONAL
             await SdkFileProgrammer.generate(config)(routes);
 
             // DISTRIBUTION
             if (config.distribute !== undefined)
-                await DistributionComposer.compose(config);
+                await SdkDistributionComposer.compose(config);
         };
 
     export const BUNDLE_PATH = NodePath.join(

package/src/generates/SwaggerGenerator.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import NodePath from "path";
+import path from "path";
 import { Singleton } from "tstl/thread/Singleton";
 import ts from "typescript";
 
@@ -70,7 +71,8 @@ export namespace SwaggerGenerator {
             > = new Map();
 
             for (const route of routeList) {
-                if (route.tags.find((tag) => tag.name === "internal")) continue;
+                if (route.jsDocTags.find((tag) => tag.name === "internal"))
+                    continue;
 
                 const path: Record<string, ISwaggerRoute> = MapUtil.take(
                     pathDict,
@@ -106,6 +108,21 @@ export namespace SwaggerGenerator {
             // CONFIGURE SECURITY
             if (config.security) fill_security(config.security, swagger);
 
+            // REPORT ERRORS
+            if (errors.length) {
+                for (const e of errors)
+                    console.error(
+                        `${path.relative(e.route.location, process.cwd())}:${
+                            e.route.symbol.class
+                        }.${e.route.symbol.function}:${
+                            e.from
+                        } - error TS(@nestia/sdk): invalid type detected.\n\n` +
+                            e.messages.map((m) => `  - ${m}`).join("\n"),
+                        "\n\n",
+                    );
+                throw new TypeError("Invalid type detected");
+            }
+
             // DO GENERATE
             await fs.promises.writeFile(
                 location,
@@ -281,8 +298,8 @@ export namespace SwaggerGenerator {
             const body = route.parameters.find(
                 (param) => param.category === "body",
             );
-            const getTagTexts = (name: string) =>
-                route.tags
+            const getJsDocTexts = (name: string) =>
+                route.jsDocTags
                     .filter(
                         (tag) =>
                             tag.name === name &&
@@ -304,7 +321,7 @@ export namespace SwaggerGenerator {
             const summary: string | undefined = (() => {
                 if (description === undefined) return undefined;
 
-                const [explicit] = getTagTexts("summary");
+                const [explicit] = getJsDocTexts("summary");
                 if (explicit?.length) return explicit;
 
                 const index: number = description.indexOf(".");
@@ -313,19 +330,30 @@ export namespace SwaggerGenerator {
                 const content: string = description.substring(0, index).trim();
                 return content.length ? content : undefined;
             })();
-            const deprecated = route.tags.find(
+            const deprecated = route.jsDocTags.find(
                 (tag) => tag.name === "deprecated",
             );
 
             return {
                 deprecated: deprecated ? true : undefined,
-                tags: getTagTexts("tag"),
-                operationId: route.operationId,
+                tags: [
+                    ...route.swaggerTags,
+                    ...new Set([...getJsDocTexts("tag")]),
+                ],
+                operationId:
+                    route.operationId ??
+                    props.config.operationId?.({
+                        class: route.symbol.class,
+                        function: route.symbol.function,
+                        method: route.method as "GET",
+                        path: route.path,
+                    }),
                 parameters: route.parameters
                     .filter((param) => param.category !== "body")
                     .map((param) =>
                         SwaggerSchemaGenerator.parameter(props)(route)(param),
-                    ),
+                    )
+                    .flat(),
                 requestBody: body
                     ? SwaggerSchemaGenerator.body(props)(route)(body)
                     : undefined,
@@ -339,7 +367,7 @@ export namespace SwaggerGenerator {
                         .filter((str) => str.length && str[0] !== ":"),
                     route.name,
                 ].join("."),
-                "x-nestia-jsDocTags": route.tags,
+                "x-nestia-jsDocTags": route.jsDocTags,
                 "x-nestia-method": route.method,
             };
         };

package/src/generates/internal/E2eFileProgrammer.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkDtoGenerator } from "./SdkDtoGenerator";
 import { SdkImportWizard } from "./SdkImportWizard";
 
 export namespace E2eFileProgrammer {
@@ -11,20 +12,21 @@ export namespace E2eFileProgrammer {
         (props: { api: string; current: string }) =>
         async (route: IRoute): Promise<void> => {
             const importer: ImportDictionary = new ImportDictionary();
-            for (const tuple of route.imports)
-                for (const instance of tuple[1])
-                    importer.internal({
-                        file: tuple[0],
-                        type: true,
-                        instance,
-                    });
-
+            if (config.clone !== true)
+                for (const tuple of route.imports)
+                    for (const instance of tuple[1])
+                        importer.internal({
+                            file: tuple[0],
+                            type: true,
+                            instance,
+                        });
             importer.internal({
                 type: false,
                 file: props.api,
                 instance: null,
                 name: "api",
             });
+
             const body: string = arrow(config)(importer)(route);
             const content: string = [
                 importer.toScript(props.current),
@@ -43,7 +45,7 @@ export namespace E2eFileProgrammer {
         (config: INestiaConfig) =>
         (importer: ImportDictionary) =>
         (route: IRoute): string => {
-            const tab: number = route.output.typeName === "void" ? 2 : 3;
+            const tab: number = 2;
             const headers = route.parameters.find(
                 (p) => p.category === "headers" && p.field === undefined,
             );
@@ -57,7 +59,9 @@ export namespace E2eFileProgrammer {
                           "        ...(connection.headers ?? {}),",
                           `        ...${SdkImportWizard.typia(
                               importer,
-                          )}.random<${headers.typeName}>(),`,
+                          )}.random<${getTypeName(config)(importer)(
+                              headers,
+                          )}>(),`,
                           "    },",
                           "},",
                       ]
@@ -76,10 +80,7 @@ export namespace E2eFileProgrammer {
                 ...(route.output.typeName === "void"
                     ? [`    ${output}`]
                     : [
-                          `    const output: ${primitive(config)(importer)(
-                              route.output.typeName,
-                          )} = `,
-                          `        ${output}`,
+                          `    const output = ${output}`,
                           `    ${SdkImportWizard.typia(
                               importer,
                           )}.assert(output);`,
@@ -95,7 +96,10 @@ export namespace E2eFileProgrammer {
         (param: IRoute.IParameter): string => {
             const middle: string = `${SdkImportWizard.typia(
                 importer,
-            )}.random<${primitive(config)(importer)(param.typeName)}>()`;
+            )}.random<${wrap(config)(importer)(
+                getTypeName(config)(importer)(param),
+                param.category === "body",
+            )}>()`;
             return `${" ".repeat(4 * tab)}${middle},`;
         };
 
@@ -105,11 +109,20 @@ export namespace E2eFileProgrammer {
     const accessor = (route: IRoute): string =>
         ["api", "functional", ...route.accessors].join(".");
 
-    const primitive =
+    const wrap =
         (config: INestiaConfig) =>
         (importer: ImportDictionary) =>
-        (name: string): string =>
-            config.primitive !== false
-                ? `${SdkImportWizard.Primitive(importer)}<${name}>`
-                : name;
+        (name: string, body: boolean): string =>
+            config.primitive === false
+                ? name
+                : `${(body
+                      ? SdkImportWizard.Primitive
+                      : SdkImportWizard.Resolved)(importer)}<${name}>`;
 }
+const getTypeName =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput) =>
+        p.metadata
+            ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
+            : p.typeName;

package/src/generates/internal/{DistributionComposer.ts → SdkDistributionComposer.ts}

@@ -4,7 +4,7 @@ import path from "path";
 
 import { INestiaConfig } from "../../INestiaConfig";
 
-export namespace DistributionComposer {
+export namespace SdkDistributionComposer {
     export const compose = async (config: INestiaConfig): Promise<void> => {
         if (!fs.existsSync(config.distribute!))
             await fs.promises.mkdir(config.distribute!);
@@ -40,11 +40,8 @@ export namespace DistributionComposer {
         execute(
             `npm install --save @nestia/fetcher@${versions["@nestia/fetcher"]}`,
         );
-
-        if (typia) {
-            execute(`npm install --save typia@${versions["typia"]}`);
-            execute("npx typia setup --manager npm");
-        } else execute("npm install --save-dev typescript");
+        execute(`npm install --save typia@${versions["typia"]}`);
+        execute("npx typia setup --manager npm");
 
         exit();
     };