@nestia/sdk 2.5.0-dev.20240128 → 2.5.0-dev.20240129-2

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,19 +1,23 @@
 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 { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
-import { SdkTypeDefiner } from "./SdkTypeDefiner";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace E2eFileProgrammer {
   export const generate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (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,94 +34,158 @@ 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(checker)(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 =
+    (checker: ts.TypeChecker) =>
     (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(checker)(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 =
+    (checker: ts.TypeChecker) =>
     (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"),
+                        [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"),
+                [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,
+                  SdkAliasCollection.output(checker)(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) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-      : p.typeName;
+      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);

package/src/generates/internal/SdkAliasCollection.ts

@@ -0,0 +1,145 @@
+import ts from "typescript";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "../../utils/ImportDictionary";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkAliasCollection {
+  export const name =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (p: IRoute.IParameter | IRoute.IOutput): ts.TypeNode =>
+      p.metadata
+        ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+        : ts.factory.createTypeReferenceNode(p.typeName);
+
+  export const headers =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const query =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Resolved",
+        }),
+        [type],
+      );
+    };
+
+  export const input =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (param: IRoute.IParameter): ts.TypeNode => {
+      const type: ts.TypeNode = name(config)(importer)(param);
+      if (config.primitive === false) return type;
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "Primitive",
+        }),
+        [type],
+      );
+    };
+
+  export const output =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode => {
+      if (config.propagate !== true) {
+        const node: ts.TypeNode = name(config)(importer)(route.output);
+        const type = checker.getTypeAtLocation(node);
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+
+        if (
+          filter(ts.TypeFlags.Undefined) ||
+          filter(ts.TypeFlags.Never) ||
+          filter(ts.TypeFlags.Void) ||
+          filter(ts.TypeFlags.VoidLike) ||
+          config.primitive === false
+        )
+          return node;
+        return ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: true,
+            library: "@nestia/fetcher",
+            instance:
+              route.output.contentType === "application/x-www-form-urlencoded"
+                ? "Resolved"
+                : "Primitive",
+          }),
+          [node],
+        );
+      }
+
+      const branches: IBranch[] = [
+        {
+          status: String(route.status ?? (route.method === "POST" ? 201 : 200)),
+          type: name(config)(importer)(route.output),
+        },
+        ...Object.entries(route.exceptions).map(([status, value]) => ({
+          status,
+          type: name(config)(importer)(value),
+        })),
+      ];
+      return ts.factory.createTypeReferenceNode(
+        importer.external({
+          type: true,
+          library: "@nestia/fetcher",
+          instance: "IPropagation",
+        }),
+        [
+          ts.factory.createTypeLiteralNode(
+            branches.map((b) =>
+              ts.factory.createPropertySignature(
+                undefined,
+                ts.factory.createNumericLiteral(b.status),
+                undefined,
+                b.type,
+              ),
+            ),
+          ),
+          ...(route.status
+            ? [
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createNumericLiteral(route.status),
+                ),
+              ]
+            : []),
+        ],
+      );
+    };
+
+  export const responseBody =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.TypeNode =>
+      output(checker)({ ...config, propagate: false })(importer)(route);
+}
+
+interface IBranch {
+  status: string;
+  type: ts.TypeNode;
+}

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,12 +1,11 @@
 import fs from "fs";
-import { format } from "prettier";
 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 { NodeUtil } from "../../utils/NodeUtil";
 import { SdkRouteDirectory } from "./SdkRouteDirectory";
 import { SdkRouteProgrammer } from "./SdkRouteProgrammer";
 
@@ -15,6 +14,7 @@ export namespace SdkFileProgrammer {
         CONSTRUCTOR
     --------------------------------------------------------- */
   export const generate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     async (routeList: IRoute[]): Promise<void> => {
       // CONSTRUCT FOLDER TREE
@@ -22,7 +22,7 @@ export namespace SdkFileProgrammer {
       for (const route of routeList) emplace(root)(route);
 
       // ITERATE FILES
-      await iterate(config)(root)(config.output + "/functional");
+      await iterate(checker)(config)(root)(config.output + "/functional");
     };
 
   const emplace =
@@ -45,6 +45,7 @@ export namespace SdkFileProgrammer {
         FILE ITERATOR
     --------------------------------------------------------- */
   const iterate =
+    (checker: ts.TypeChecker) =>
     (config: INestiaConfig) =>
     (directory: SdkRouteDirectory) =>
     async (outDir: string): Promise<void> => {
@@ -56,7 +57,7 @@ export namespace SdkFileProgrammer {
       // ITERATE CHILDREN
       const statements: ts.Statement[] = [];
       for (const [key, value] of directory.children) {
-        await iterate(config)(value)(`${outDir}/${key}`);
+        await iterate(checker)(config)(value)(`${outDir}/${key}`);
         statements.push(
           ts.factory.createExportDeclaration(
             undefined,
@@ -68,7 +69,7 @@ export namespace SdkFileProgrammer {
         );
       }
       if (statements.length && directory.routes.length)
-        statements.push(NodeUtil.enter());
+        statements.push(FormatUtil.enter());
 
       // ITERATE ROUTES
       const importer: ImportDictionary = new ImportDictionary(
@@ -93,17 +94,19 @@ export namespace SdkFileProgrammer {
                 type: true,
               });
         statements.push(
-          ...SdkRouteProgrammer.generate(config)(importer)(route),
+          ...SdkRouteProgrammer.generate(checker)(config)(importer)(route),
         );
         if (i !== directory.routes.length - 1)
-          statements.push(NodeUtil.enter());
+          statements.push(FormatUtil.enter());
       });
 
       // FINALIZE THE CONTENT
       if (directory.routes.length !== 0)
         statements.push(
           ...importer.toStatements(outDir),
-          ...(!importer.empty() && statements.length ? [NodeUtil.enter()] : []),
+          ...(!importer.empty() && statements.length
+            ? [FormatUtil.enter()]
+            : []),
           ...statements.splice(0, statements.length),
         );
 
@@ -123,13 +126,10 @@ export namespace SdkFileProgrammer {
               ts.NodeFlags.None,
             ),
           );
-      const beautify = async () => {
-        try {
-          return await format(script, { parser: "typescript" });
-        } catch {
-          return script;
-        }
-      };
-      await fs.promises.writeFile(importer.file, await beautify(), "utf8");
+      await fs.promises.writeFile(
+        importer.file,
+        await FormatUtil.beautify(script),
+        "utf8",
+      );
     };
 }

package/src/generates/internal/SdkFunctionProgrammer.ts

@@ -6,8 +6,8 @@ import { INestiaConfig } from "../../INestiaConfig";
 import { IController } from "../../structures/IController";
 import { IRoute } from "../../structures/IRoute";
 import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkDtoGenerator } from "./SdkDtoGenerator";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkFunctionProgrammer {
   export const generate =
@@ -49,12 +49,12 @@ export namespace SdkFunctionProgrammer {
                 p.optional
                   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
                   : undefined,
-                ts.factory.createTypeReferenceNode(
-                  config.primitive !== false &&
-                    (p === props.query || p === props.input)
-                    ? `${route.name}.${p === props.query ? "Query" : "Input"}`
-                    : getTypeName(config)(importer)(p),
-                ),
+                config.primitive !== false &&
+                  (p === props.query || p === props.input)
+                  ? ts.factory.createTypeReferenceNode(
+                      `${route.name}.${p === props.query ? "Query" : "Input"}`,
+                    )
+                  : getTypeName(config)(importer)(p),
               ),
             ),
         ],
@@ -215,5 +215,5 @@ const getTypeName =
   (importer: ImportDictionary) =>
   (p: IRoute.IParameter | IRoute.IOutput) =>
     p.metadata
-      ? SdkDtoGenerator.decode(config)(importer)(p.metadata)
-      : p.typeName;
+      ? SdkTypeProgrammer.decode(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);