@nestia/sdk 2.4.7 → 2.5.0-dev.20240129

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,7 +1,10 @@
 import fs from "fs";
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
+import { FormatUtil } from "../../utils/FormatUtil";
 import { ImportDictionary } from "../../utils/ImportDictionary";
 import { SdkDtoGenerator } from "./SdkDtoGenerator";
 import { SdkImportWizard } from "./SdkImportWizard";
@@ -13,7 +16,7 @@ export namespace E2eFileProgrammer {
     (props: { api: string; current: string }) =>
     async (route: IRoute): Promise<void> => {
       const importer: ImportDictionary = new ImportDictionary(
-        `${props.current}/${name(route)}.ts`,
+        `${props.current}/${getFunctionName(route)}.ts`,
       );
       if (config.clone !== true)
         for (const tuple of route.imports)
@@ -30,90 +33,162 @@ export namespace E2eFileProgrammer {
         name: "api",
       });
 
-      const body: string = arrow(config)(importer)(route);
-      const content: string = [importer.toScript(props.current), "", body].join(
-        "\n",
-      );
+      const functor = generate_function(config)(importer)(route);
 
-      await fs.promises.writeFile(importer.file, content, "utf8");
+      await fs.promises.writeFile(
+        importer.file,
+        await FormatUtil.beautify(
+          ts
+            .createPrinter()
+            .printFile(
+              ts.factory.createSourceFile(
+                [
+                  ...importer.toStatements(props.current),
+                  FormatUtil.enter(),
+                  functor,
+                ],
+                ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+                ts.NodeFlags.None,
+              ),
+            ),
+        ),
+        "utf8",
+      );
     };
 
-  const arrow =
+  const generate_function =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
-    (route: IRoute): string => {
-      const tab: number = 2;
-      const headers = route.parameters.find(
-        (p) => p.category === "headers" && p.field === undefined,
+    (route: IRoute): ts.Statement =>
+      ts.factory.createVariableStatement(
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createVariableDeclarationList(
+          [
+            ts.factory.createVariableDeclaration(
+              ts.factory.createIdentifier(getFunctionName(route)),
+              undefined,
+              undefined,
+              generate_arrow(config)(importer)(route),
+            ),
+          ],
+          ts.NodeFlags.Const,
+        ),
       );
-      const output = [
-        `await ${accessor(route)}(`,
-        headers !== undefined
-          ? [
-              "{",
-              "    ...connection,",
-              "    headers: {",
-              "        ...(connection.headers ?? {}),",
-              `        ...${SdkImportWizard.typia(
-                importer,
-              )}.random<${getTypeName(config)(importer)(headers)}>(),`,
-              "    },",
-              "},",
-            ]
-              .map((line) => `${" ".repeat(tab * 4)}${line}`)
-              .join("\n")
-          : `${" ".repeat(tab * 4)}connection,`,
-        ...route.parameters
-          .filter((param) => param.category !== "headers")
-          .map(parameter(config)(importer)(tab)),
-        `${" ".repeat((tab - 1) * 4)});`,
-      ].join("\n");
-      return [
-        `export const ${name(route)} = async (`,
-        `    connection: api.IConnection`,
-        `): Promise<void> => {`,
-        ...(route.output.typeName === "void"
-          ? [`    ${output}`]
-          : [
-              `    const output: ${SdkTypeDefiner.output(config)(importer)(
-                route,
-              )} = ${output}`,
-              `    ${SdkImportWizard.typia(importer)}.assert(output);`,
-            ]),
-        `};`,
-      ].join("\n");
-    };
 
-  const parameter =
+  const generate_arrow =
     (config: INestiaConfig) =>
     (importer: ImportDictionary) =>
-    (tab: number) =>
-    (param: IRoute.IParameter): string => {
-      const middle: string = `${SdkImportWizard.typia(importer)}.random<${wrap(
-        config,
-      )(importer)(
-        getTypeName(config)(importer)(param),
-        param.category === "body",
-      )}>()`;
-      return `${" ".repeat(4 * tab)}${middle},`;
-    };
+    (route: IRoute) => {
+      const headers = route.parameters.find(
+        (p) => p.category === "headers" && p.field === undefined,
+      );
+      const connection = headers
+        ? ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createSpreadAssignment(
+                ts.factory.createIdentifier("connection"),
+              ),
+              ts.factory.createPropertyAssignment(
+                "headers",
+                ts.factory.createObjectLiteralExpression(
+                  [
+                    ts.factory.createSpreadAssignment(
+                      IdentifierFactory.access(
+                        ts.factory.createIdentifier("connection"),
+                      )("headers"),
+                    ),
+                    ts.factory.createSpreadAssignment(
+                      ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                          ts.factory.createIdentifier(
+                            SdkImportWizard.typia(importer),
+                          ),
+                        )("random"),
+                        [
+                          ts.factory.createTypeReferenceNode(
+                            getTypeName(config)(importer)(headers),
+                          ),
+                        ],
+                        undefined,
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ],
+            true,
+          )
+        : ts.factory.createIdentifier("connection");
+      const caller = ts.factory.createCallExpression(
+        ts.factory.createIdentifier(
+          ["api", "functional", ...route.accessors].join("."),
+        ),
+        undefined,
+        [
+          connection,
+          ...route.parameters
+            .filter((p) => p.category !== "headers")
+            .map((p) =>
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(
+                  ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+                )("random"),
+                [
+                  ts.factory.createTypeReferenceNode(
+                    getTypeName(config)(importer)(p),
+                  ),
+                ],
+                undefined,
+              ),
+            ),
+        ],
+      );
+      const assert = ts.factory.createCallExpression(
+        IdentifierFactory.access(
+          ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+        )("assert"),
+        undefined,
+        [ts.factory.createIdentifier("output")],
+      );
 
-  const name = (route: IRoute): string =>
-    ["test", "api", ...route.accessors].join("_");
+      return ts.factory.createArrowFunction(
+        [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "connection",
+            ts.factory.createTypeReferenceNode("api.IConnection"),
+          ),
+        ],
+        undefined,
+        undefined,
+        ts.factory.createBlock([
+          ts.factory.createVariableStatement(
+            [],
+            ts.factory.createVariableDeclarationList(
+              [
+                ts.factory.createVariableDeclaration(
+                  "output",
+                  undefined,
+                  ts.factory.createTypeReferenceNode(
+                    SdkTypeDefiner.output(config)(importer)(route),
+                  ),
+                  ts.factory.createAwaitExpression(caller),
+                ),
+              ],
+              ts.NodeFlags.Const,
+            ),
+          ),
+          ts.factory.createExpressionStatement(assert),
+        ]),
+      );
+    };
+}
 
-  const accessor = (route: IRoute): string =>
-    ["api", "functional", ...route.accessors].join(".");
+const getFunctionName = (route: IRoute): string =>
+  ["test", "api", ...route.accessors].join("_");
 
-  const wrap =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (name: string, body: boolean): string =>
-      config.primitive === false
-        ? name
-        : `${(body ? SdkImportWizard.Primitive : SdkImportWizard.Resolved)(
-            importer,
-          )}<${name}>`;
-}
 const getTypeName =
   (config: INestiaConfig) =>
   (importer: ImportDictionary) =>

package/src/generates/internal/SdkDtoGenerator.ts

@@ -17,6 +17,7 @@ import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
+import { FormatUtil } from "../../utils/FormatUtil";
 import { ImportDictionary } from "../../utils/ImportDictionary";
 import { MapUtil } from "../../utils/MapUtil";
 
@@ -101,7 +102,11 @@ export namespace SdkDtoGenerator {
         content.push(importer.toScript(`${config.output}/structures`), "");
       content.push(body);
 
-      await fs.promises.writeFile(importer.file, content.join("\n"), "utf8");
+      await fs.promises.writeFile(
+        importer.file,
+        await FormatUtil.beautify(content.join("\n")),
+        "utf8",
+      );
     };
 
   const writeModule =

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,11 +1,13 @@
 import fs from "fs";
+import ts from "typescript";
 
 import { INestiaConfig } from "../../INestiaConfig";
 import { IRoute } from "../../structures/IRoute";
+import { FormatUtil } from "../../utils/FormatUtil";
 import { ImportDictionary } from "../../utils/ImportDictionary";
 import { MapUtil } from "../../utils/MapUtil";
-import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
 import { SdkRouteDirectory } from "./SdkRouteDirectory";
+import { SdkRouteProgrammer } from "./SdkRouteProgrammer";
 
 export namespace SdkFileProgrammer {
   /* ---------------------------------------------------------
@@ -51,12 +53,21 @@ export namespace SdkFileProgrammer {
       } catch {}
 
       // ITERATE CHILDREN
-      const content: string[] = [];
+      const statements: ts.Statement[] = [];
       for (const [key, value] of directory.children) {
         await iterate(config)(value)(`${outDir}/${key}`);
-        content.push(`export * as ${key} from "./${key}";`);
+        statements.push(
+          ts.factory.createExportDeclaration(
+            undefined,
+            false,
+            ts.factory.createNamespaceExport(ts.factory.createIdentifier(key)),
+            ts.factory.createStringLiteral(`./${key}`),
+            undefined,
+          ),
+        );
       }
-      if (content.length && directory.routes.length) content.push("");
+      if (statements.length && directory.routes.length)
+        statements.push(FormatUtil.enter());
 
       // ITERATE ROUTES
       const importer: ImportDictionary = new ImportDictionary(
@@ -80,17 +91,21 @@ export namespace SdkFileProgrammer {
                 instance,
                 type: true,
               });
-
-        content.push(SdkFunctionProgrammer.generate(config)(importer)(route));
-        if (i !== directory.routes.length - 1) content.push("");
+        statements.push(
+          ...SdkRouteProgrammer.generate(config)(importer)(route),
+        );
+        if (i !== directory.routes.length - 1)
+          statements.push(FormatUtil.enter());
       });
 
       // FINALIZE THE CONTENT
       if (directory.routes.length !== 0)
-        content.push(
-          importer.toScript(outDir),
-          "",
-          ...content.splice(0, content.length),
+        statements.push(
+          ...importer.toStatements(outDir),
+          ...(!importer.empty() && statements.length
+            ? [FormatUtil.enter()]
+            : []),
+          ...statements.splice(0, statements.length),
         );
 
       const script: string =
@@ -100,7 +115,19 @@ export namespace SdkFileProgrammer {
         " * @nestia Generated by Nestia - https://github.com/samchon/nestia \n" +
         " */\n" +
         "//================================================================\n" +
-        content.join("\n");
-      await fs.promises.writeFile(importer.file, script, "utf8");
+        ts
+          .createPrinter()
+          .printFile(
+            ts.factory.createSourceFile(
+              statements,
+              ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
+              ts.NodeFlags.None,
+            ),
+          );
+      await fs.promises.writeFile(
+        importer.file,
+        await FormatUtil.beautify(script),
+        "utf8",
+      );
     };
 }