@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/generates/internal/SdkHttpFunctionProgrammer.ts

@@ -1,5 +1,5 @@
-import { IdentifierFactory, TypeFactory } from "@typia/core";
-import ts from "typescript";
+import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory, TypeFactory } from "@nestia/factory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
@@ -8,16 +8,17 @@ import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { sizeOf } from "../../internal/legacy";
 
 export namespace SdkHttpFunctionProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.FunctionDeclaration => {
-      return ts.factory.createFunctionDeclaration(
+    (route: ITypedHttpRoute): Node => {
+      return TypeScriptFactory.createFunctionDeclaration(
         [
-          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-          ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+          TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword),
+          TypeScriptFactory.createModifier(SyntaxKind.AsyncKeyword),
         ],
         undefined,
         route.name,
@@ -25,10 +26,14 @@ export namespace SdkHttpFunctionProgrammer {
         [
           IdentifierFactory.parameter(
             "connection",
-            ts.factory.createTypeReferenceNode(
+            TypeScriptFactory.createTypeReferenceNode(
               SdkImportWizard.IConnection(importer),
               route.headerObject !== null
-                ? [ts.factory.createTypeReferenceNode(`${route.name}.Headers`)]
+                ? [
+                    TypeScriptFactory.createTypeReferenceNode(
+                      `${route.name}.Headers`,
+                    ),
+                  ]
                 : undefined,
             ),
           ),
@@ -40,28 +45,34 @@ export namespace SdkHttpFunctionProgrammer {
             prefix: true,
           }),
         ],
-        ts.factory.createTypeReferenceNode("Promise", [
+        TypeScriptFactory.createTypeReferenceNode("Promise", [
           project.config.propagate === true ||
-          route.success.metadata.size() !== 0
-            ? ts.factory.createTypeReferenceNode(`${route.name}.Output`)
-            : ts.factory.createTypeReferenceNode("void"),
+          sizeOf(route.success.metadata) !== 0
+            ? TypeScriptFactory.createTypeReferenceNode(`${route.name}.Output`)
+            : TypeScriptFactory.createTypeReferenceNode("void"),
         ]),
-        ts.factory.createBlock(writeBody(project)(importer)(route), true),
+        TypeScriptFactory.createBlock(
+          writeBody(project)(importer)(route),
+          true,
+        ),
       );
     };
 
   const writeBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement[] => {
-      const access = (name: string): ts.Expression =>
+    (route: ITypedHttpRoute): Node[] => {
+      const access = (name: string): Node =>
         project.config.keyword === true
-          ? IdentifierFactory.access(ts.factory.createIdentifier("props"), name)
-          : ts.factory.createIdentifier(name);
+          ? TypeScriptFactory.createPropertyAccessExpression(
+              TypeScriptFactory.createIdentifier("props"),
+              name,
+            )
+          : TypeScriptFactory.createIdentifier(name);
       const fetch = () =>
-        ts.factory.createCallExpression(
+        TypeScriptFactory.createCallExpression(
           IdentifierFactory.access(
-            ts.factory.createIdentifier(
+            TypeScriptFactory.createIdentifier(
               SdkImportWizard.Fetcher(
                 !!route.body?.encrypted || route.success.encrypted,
               )(importer),
@@ -76,24 +87,26 @@ export namespace SdkHttpFunctionProgrammer {
             : undefined,
           [
             route.body && route.body.contentType !== "multipart/form-data"
-              ? ts.factory.createObjectLiteralExpression(
+              ? TypeScriptFactory.createObjectLiteralExpression(
                   [
-                    ts.factory.createSpreadAssignment(
-                      ts.factory.createIdentifier("connection"),
+                    TypeScriptFactory.createSpreadAssignment(
+                      TypeScriptFactory.createIdentifier("connection"),
                     ),
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "headers",
-                      ts.factory.createObjectLiteralExpression(
+                      TypeScriptFactory.createObjectLiteralExpression(
                         [
-                          ts.factory.createSpreadAssignment(
+                          TypeScriptFactory.createSpreadAssignment(
                             IdentifierFactory.access(
-                              ts.factory.createIdentifier("connection"),
+                              TypeScriptFactory.createIdentifier("connection"),
                               "headers",
                             ),
                           ),
-                          ts.factory.createPropertyAssignment(
-                            ts.factory.createStringLiteral("Content-Type"),
-                            ts.factory.createStringLiteral(
+                          TypeScriptFactory.createPropertyAssignment(
+                            TypeScriptFactory.createStringLiteral(
+                              "Content-Type",
+                            ),
+                            TypeScriptFactory.createStringLiteral(
                               route.body?.contentType ?? "application/json",
                             ),
                           ),
@@ -104,30 +117,30 @@ export namespace SdkHttpFunctionProgrammer {
                   ],
                   true,
                 )
-              : ts.factory.createIdentifier("connection"),
-            ts.factory.createObjectLiteralExpression(
+              : TypeScriptFactory.createIdentifier("connection"),
+            TypeScriptFactory.createObjectLiteralExpression(
               [
-                ts.factory.createSpreadAssignment(
+                TypeScriptFactory.createSpreadAssignment(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(route.name),
+                    TypeScriptFactory.createIdentifier(route.name),
                     "METADATA",
                   ),
                 ),
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "template",
                   IdentifierFactory.access(
                     IdentifierFactory.access(
-                      ts.factory.createIdentifier(route.name),
+                      TypeScriptFactory.createIdentifier(route.name),
                       "METADATA",
                     ),
                     "path",
                   ),
                 ),
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "path",
-                  ts.factory.createCallExpression(
+                  TypeScriptFactory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createIdentifier(route.name),
+                      TypeScriptFactory.createIdentifier(route.name),
                       "path",
                     ),
                     undefined,
@@ -146,23 +159,23 @@ export namespace SdkHttpFunctionProgrammer {
             route.body !== null &&
             (route.body.contentType === "application/json" ||
               route.body.encrypted === true)
-              ? [ts.factory.createIdentifier(`${route.name}.stringify`)]
+              ? [TypeScriptFactory.createIdentifier(`${route.name}.stringify`)]
               : []),
           ],
         );
       const output = (awaiter: boolean) =>
         project.config.simulate
-          ? ts.factory.createConditionalExpression(
-              ts.factory.createStrictEquality(
-                ts.factory.createTrue(),
-                ts.factory.createIdentifier("connection.simulate"),
+          ? TypeScriptFactory.createConditionalExpression(
+              TypeScriptFactory.createStrictEquality(
+                TypeScriptFactory.createTrue(),
+                TypeScriptFactory.createIdentifier("connection.simulate"),
               ),
               undefined,
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`${route.name}.simulate`),
+              TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier(`${route.name}.simulate`),
                 [],
                 [
-                  ts.factory.createIdentifier("connection"),
+                  TypeScriptFactory.createIdentifier("connection"),
                   ...SdkHttpParameterProgrammer.getArguments({
                     project,
                     route,
@@ -171,34 +184,36 @@ export namespace SdkHttpFunctionProgrammer {
                 ],
               ),
               undefined,
-              awaiter ? ts.factory.createAwaitExpression(fetch()) : fetch(),
+              awaiter
+                ? TypeScriptFactory.createAwaitExpression(fetch())
+                : fetch(),
             )
           : awaiter
-            ? ts.factory.createAwaitExpression(fetch())
+            ? TypeScriptFactory.createAwaitExpression(fetch())
             : fetch();
       return [
         ...(project.config.assert
           ? SdkHttpParameterProgrammer.getSignificant(route, true).map((p) =>
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
+              TypeScriptFactory.createExpressionStatement(
+                TypeScriptFactory.createCallExpression(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(
+                    TypeScriptFactory.createIdentifier(
                       SdkImportWizard.typia(importer),
                     ),
                     "assert",
                   ),
                   [
-                    ts.factory.createTypeQueryNode(
-                      ts.factory.createIdentifier(p.name),
+                    TypeScriptFactory.createTypeQueryNode(
+                      TypeScriptFactory.createIdentifier(p.name),
                     ),
                   ],
-                  [ts.factory.createIdentifier(p.name)],
+                  [TypeScriptFactory.createIdentifier(p.name)],
                 ),
               ),
             )
           : []),
         ...(route.success.setHeaders.length === 0
-          ? [ts.factory.createReturnStatement(output(false))]
+          ? [TypeScriptFactory.createReturnStatement(output(false))]
           : writeSetHeaders(project)(importer)(route)(output(true))),
       ];
     };
@@ -207,7 +222,7 @@ export namespace SdkHttpFunctionProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) =>
-    (condition: ts.Expression): ts.Statement[] => {
+    (condition: Node): Node[] => {
       const accessor = (x: string) => (y: string) =>
         x[0] === "[" ? `${x}${y}` : `${x}.${y}`;
       const output: string = StringUtil.escapeDuplicate([
@@ -221,58 +236,66 @@ export namespace SdkHttpFunctionProgrammer {
         ? accessor(output)("data")
         : output;
 
-      const assigners: ts.ExpressionStatement[] = [
-        ts.factory.createBinaryExpression(
-          ts.factory.createIdentifier(headers),
-          ts.factory.createToken(ts.SyntaxKind.QuestionQuestionEqualsToken),
-          ts.factory.createObjectLiteralExpression([]),
+      const assigners: Node[] = [
+        TypeScriptFactory.createBinaryExpression(
+          TypeScriptFactory.createIdentifier(headers),
+          TypeScriptFactory.createToken(
+            SyntaxKind.QuestionQuestionEqualsToken,
+          ),
+          TypeScriptFactory.createObjectLiteralExpression([]),
         ),
         ...route.success.setHeaders.map((tuple) =>
           tuple.type === "assigner"
-            ? ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.assign"),
+            ? TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier("Object.assign"),
                 [],
                 [
-                  ts.factory.createIdentifier(headers),
-                  ts.factory.createIdentifier(accessor(data)(tuple.source)),
+                  TypeScriptFactory.createIdentifier(headers),
+                  TypeScriptFactory.createIdentifier(
+                    accessor(data)(tuple.source),
+                  ),
                 ],
               )
-            : ts.factory.createBinaryExpression(
-                ts.factory.createIdentifier(
+            : TypeScriptFactory.createBinaryExpression(
+                TypeScriptFactory.createIdentifier(
                   accessor(headers)(tuple.target ?? tuple.source),
                 ),
-                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                ts.factory.createIdentifier(accessor(data)(tuple.source)),
+                TypeScriptFactory.createToken(SyntaxKind.EqualsToken),
+                TypeScriptFactory.createIdentifier(
+                  accessor(data)(tuple.source),
+                ),
               ),
         ),
-      ].map(ts.factory.createExpressionStatement);
+      ].map(TypeScriptFactory.createExpressionStatement);
       return [
-        ts.factory.createVariableStatement(
+        TypeScriptFactory.createVariableStatement(
           [],
-          ts.factory.createVariableDeclarationList(
+          TypeScriptFactory.createVariableDeclarationList(
             [
-              ts.factory.createVariableDeclaration(
+              TypeScriptFactory.createVariableDeclaration(
                 output,
                 undefined,
                 SdkAliasCollection.response(project)(importer)(route),
                 condition,
               ),
             ],
-            ts.NodeFlags.Const,
+            NodeFlags.Const,
           ),
         ),
         ...(project.config.propagate
           ? [
-              ts.factory.createIfStatement(
-                ts.factory.createIdentifier(accessor(output)("success")),
+              TypeScriptFactory.createIfStatement(
+                TypeScriptFactory.createIdentifier(accessor(output)("success")),
                 assigners.length === 1
                   ? assigners[0]!
-                  : ts.factory.createBlock(assigners, true),
+                  : TypeScriptFactory.createBlock(assigners, true),
                 undefined,
               ),
             ]
           : assigners),
-        ts.factory.createReturnStatement(ts.factory.createIdentifier(output)),
+        TypeScriptFactory.createReturnStatement(
+          TypeScriptFactory.createIdentifier(output),
+        ),
       ];
     };
 }