@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/generates/internal/SdkHttpNamespaceProgrammer.ts

@@ -1,11 +1,6 @@
-import {
-  ExpressionFactory,
-  IdentifierFactory,
-  LiteralFactory,
-  TypeFactory,
-} from "@typia/core";
+import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { ExpressionFactory, IdentifierFactory, LiteralFactory, TypeFactory } from "@nestia/factory";
 import { NamingConvention } from "@typia/utils";
-import ts from "typescript";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
@@ -15,18 +10,19 @@ import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkHttpSimulationProgrammer } from "./SdkHttpSimulationProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { sizeOf } from "../../internal/legacy";
 
 export namespace SdkHttpNamespaceProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.ModuleDeclaration => {
-      const types: ts.TypeAliasDeclaration[] =
+    (route: ITypedHttpRoute): Node => {
+      const types: Node[] =
         writeTypes(project)(importer)(route);
-      return ts.factory.createModuleDeclaration(
-        [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-        ts.factory.createIdentifier(route.name),
-        ts.factory.createModuleBlock([
+      return TypeScriptFactory.createModuleDeclaration(
+        [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createIdentifier(route.name),
+        TypeScriptFactory.createModuleBlock([
           ...types,
           ...(types.length ? [FilePrinter.enter()] : []),
           writeMetadata(project)(importer)(route),
@@ -45,19 +41,19 @@ export namespace SdkHttpNamespaceProgrammer {
             ? [writeStringify(project)(importer)]
             : []),
         ]),
-        ts.NodeFlags.Namespace,
+        NodeFlags.Namespace,
       );
     };
 
   const writeTypes =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.TypeAliasDeclaration[] => {
-      const array: ts.TypeAliasDeclaration[] = [];
-      const declare = (name: string, type: ts.TypeNode) =>
+    (route: ITypedHttpRoute): Node[] => {
+      const array: Node[] = [];
+      const declare = (name: string, type: Node) =>
         array.push(
-          ts.factory.createTypeAliasDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          TypeScriptFactory.createTypeAliasDeclaration(
+            [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
             name,
             undefined,
             type,
@@ -85,7 +81,7 @@ export namespace SdkHttpNamespaceProgrammer {
         declare("Body", SdkAliasCollection.body(project)(importer)(route.body));
       if (
         project.config.propagate === true ||
-        route.success.metadata.size() !== 0
+        sizeOf(route.success.metadata) !== 0
       )
         declare(
           "Output",
@@ -97,20 +93,20 @@ export namespace SdkHttpNamespaceProgrammer {
   const writeMetadata =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.VariableStatement =>
+    (route: ITypedHttpRoute): Node =>
       constant("METADATA")(
-        ts.factory.createAsExpression(
-          ts.factory.createObjectLiteralExpression(
+        TypeScriptFactory.createAsExpression(
+          TypeScriptFactory.createObjectLiteralExpression(
             [
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "method",
-                ts.factory.createStringLiteral(route.method),
+                TypeScriptFactory.createStringLiteral(route.method),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "path",
-                ts.factory.createStringLiteral(route.path),
+                TypeScriptFactory.createStringLiteral(route.path),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "request",
                 route.body
                   ? LiteralFactory.write(
@@ -124,30 +120,30 @@ export namespace SdkHttpNamespaceProgrammer {
                             encrypted: false,
                           },
                     )
-                  : ts.factory.createNull(),
+                  : TypeScriptFactory.createNull(),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "response",
                 route.method !== "HEAD"
                   ? LiteralFactory.write({
                       type: route.success.contentType,
                       encrypted: !!route.success.encrypted,
                     })
-                  : ts.factory.createNull(),
+                  : TypeScriptFactory.createNull(),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "status",
                 route.success.status !== null
                   ? ExpressionFactory.number(route.success.status)
-                  : ts.factory.createNull(),
+                  : TypeScriptFactory.createNull(),
               ),
               ...(route.success.contentType ===
               "application/x-www-form-urlencoded"
                 ? [
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "parseQuery",
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(
+                      TypeScriptFactory.createCallExpression(
+                        TypeScriptFactory.createIdentifier(
                           `${SdkImportWizard.typia(importer)}.http.createAssertQuery`,
                         ),
                         [
@@ -165,8 +161,8 @@ export namespace SdkHttpNamespaceProgrammer {
             ],
             true,
           ),
-          ts.factory.createTypeReferenceNode(
-            ts.factory.createIdentifier("const"),
+          TypeScriptFactory.createTypeReferenceNode(
+            TypeScriptFactory.createIdentifier("const"),
           ),
         ),
       );
@@ -174,10 +170,10 @@ export namespace SdkHttpNamespaceProgrammer {
   const writePath =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.VariableStatement => {
-      const out = (body: ts.ConciseBody) =>
+    (route: ITypedHttpRoute): Node => {
+      const out = (body: Node) =>
         constant("path")(
-          ts.factory.createArrowFunction(
+          TypeScriptFactory.createArrowFunction(
             [],
             [],
             SdkHttpParameterProgrammer.getParameterDeclarations({
@@ -197,47 +193,53 @@ export namespace SdkHttpNamespaceProgrammer {
         false,
       );
       if (parameters.length === 0)
-        return out(ts.factory.createStringLiteral(route.path));
+        return out(TypeScriptFactory.createStringLiteral(route.path));
 
       const access = (name: string) =>
         project.config.keyword === true ? `props.${name}` : name;
       const template = () => {
         const split: string[] = route.path.split(":");
         if (split.length === 1)
-          return ts.factory.createStringLiteral(route.path);
-        return ts.factory.createTemplateExpression(
-          ts.factory.createTemplateHead(split[0]!),
+          return TypeScriptFactory.createStringLiteral(route.path);
+        return TypeScriptFactory.createTemplateExpression(
+          TypeScriptFactory.createTemplateHead(split[0]!),
           split.slice(1).map((s, i, arr) => {
             const name: string = s.split("/")[0]!;
-            return ts.factory.createTemplateSpan(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("encodeURIComponent"),
+            return TypeScriptFactory.createTemplateSpan(
+              TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier("encodeURIComponent"),
                 undefined,
                 [
-                  ts.factory.createBinaryExpression(
-                    ts.factory.createCallChain(
-                      ts.factory.createPropertyAccessChain(
-                        ts.factory.createIdentifier(
+                  TypeScriptFactory.createBinaryExpression(
+                    TypeScriptFactory.createCallChain(
+                      TypeScriptFactory.createPropertyAccessChain(
+                        TypeScriptFactory.createIdentifier(
                           access(
                             route.pathParameters.find((p) => p.field === name)!
                               .name,
                           ),
                         ),
-                        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                        TypeScriptFactory.createToken(
+                          SyntaxKind.QuestionDotToken,
+                        ),
                         "toString",
                       ),
                       undefined,
                       undefined,
                       [],
                     ),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                    ts.factory.createStringLiteral("null"),
+                    TypeScriptFactory.createToken(
+                      SyntaxKind.QuestionQuestionToken,
+                    ),
+                    TypeScriptFactory.createStringLiteral("null"),
                   ),
                 ],
               ),
               (i !== arr.length - 1
-                ? ts.factory.createTemplateMiddle
-                : ts.factory.createTemplateTail)(s.substring(name.length)),
+                ? TypeScriptFactory.createTemplateMiddle
+                : TypeScriptFactory.createTemplateTail)(
+                s.substring(name.length),
+              ),
             );
           }),
         );
@@ -245,37 +247,37 @@ export namespace SdkHttpNamespaceProgrammer {
       if (route.queryObject === null && route.queryParameters.length === 0)
         return out(template());
 
-      const block = (expr: ts.Expression) => {
+      const block = (expr: Node) => {
         const computeName = (str: string): string =>
           parameters.find((p) => p.name === str) !== undefined
             ? computeName("_" + str)
             : str;
         const variables: string = computeName("variables");
-        return ts.factory.createBlock(
+        return TypeScriptFactory.createBlock(
           [
             local(variables)("URLSearchParams")(
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
+              TypeScriptFactory.createNewExpression(
+                TypeScriptFactory.createIdentifier("URLSearchParams"),
                 [],
                 [],
               ),
             ),
-            ts.factory.createForOfStatement(
+            TypeScriptFactory.createForOfStatement(
               undefined,
-              ts.factory.createVariableDeclarationList(
+              TypeScriptFactory.createVariableDeclarationList(
                 [
-                  ts.factory.createVariableDeclaration(
-                    ts.factory.createArrayBindingPattern([
-                      ts.factory.createBindingElement(
+                  TypeScriptFactory.createVariableDeclaration(
+                    TypeScriptFactory.createArrayBindingPattern([
+                      TypeScriptFactory.createBindingElement(
                         undefined,
                         undefined,
-                        ts.factory.createIdentifier("key"),
+                        TypeScriptFactory.createIdentifier("key"),
                         undefined,
                       ),
-                      ts.factory.createBindingElement(
+                      TypeScriptFactory.createBindingElement(
                         undefined,
                         undefined,
-                        ts.factory.createIdentifier("value"),
+                        TypeScriptFactory.createIdentifier("value"),
                         undefined,
                       ),
                     ]),
@@ -284,56 +286,56 @@ export namespace SdkHttpNamespaceProgrammer {
                     undefined,
                   ),
                 ],
-                ts.NodeFlags.Const,
+                NodeFlags.Const,
               ),
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.entries"),
+              TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier("Object.entries"),
                 undefined,
                 [
-                  ts.factory.createAsExpression(
+                  TypeScriptFactory.createAsExpression(
                     expr,
                     TypeFactory.keyword("any"),
                   ),
                 ],
               ),
-              ts.factory.createIfStatement(
-                ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  ts.factory.createIdentifier("value"),
+              TypeScriptFactory.createIfStatement(
+                TypeScriptFactory.createStrictEquality(
+                  TypeScriptFactory.createIdentifier("undefined"),
+                  TypeScriptFactory.createIdentifier("value"),
                 ),
-                ts.factory.createContinueStatement(),
-                ts.factory.createIfStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Array.isArray"),
+                TypeScriptFactory.createContinueStatement(),
+                TypeScriptFactory.createIfStatement(
+                  TypeScriptFactory.createCallExpression(
+                    TypeScriptFactory.createIdentifier("Array.isArray"),
                     undefined,
-                    [ts.factory.createIdentifier("value")],
+                    [TypeScriptFactory.createIdentifier("value")],
                   ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("value"),
-                        ts.factory.createIdentifier("forEach"),
+                  TypeScriptFactory.createExpressionStatement(
+                    TypeScriptFactory.createCallExpression(
+                      TypeScriptFactory.createPropertyAccessExpression(
+                        TypeScriptFactory.createIdentifier("value"),
+                        TypeScriptFactory.createIdentifier("forEach"),
                       ),
                       undefined,
                       [
-                        ts.factory.createArrowFunction(
+                        TypeScriptFactory.createArrowFunction(
                           undefined,
                           undefined,
                           [IdentifierFactory.parameter("elem")],
                           undefined,
                           undefined,
-                          ts.factory.createCallExpression(
+                          TypeScriptFactory.createCallExpression(
                             IdentifierFactory.access(
-                              ts.factory.createIdentifier(variables),
+                              TypeScriptFactory.createIdentifier(variables),
                               "append",
                             ),
                             undefined,
                             [
-                              ts.factory.createIdentifier("key"),
-                              ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("String"),
+                              TypeScriptFactory.createIdentifier("key"),
+                              TypeScriptFactory.createCallExpression(
+                                TypeScriptFactory.createIdentifier("String"),
                                 undefined,
-                                [ts.factory.createIdentifier("elem")],
+                                [TypeScriptFactory.createIdentifier("elem")],
                               ),
                             ],
                           ),
@@ -341,19 +343,19 @@ export namespace SdkHttpNamespaceProgrammer {
                       ],
                     ),
                   ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
+                  TypeScriptFactory.createExpressionStatement(
+                    TypeScriptFactory.createCallExpression(
                       IdentifierFactory.access(
-                        ts.factory.createIdentifier(variables),
+                        TypeScriptFactory.createIdentifier(variables),
                         "set",
                       ),
                       undefined,
                       [
-                        ts.factory.createIdentifier("key"),
-                        ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("String"),
+                        TypeScriptFactory.createIdentifier("key"),
+                        TypeScriptFactory.createCallExpression(
+                          TypeScriptFactory.createIdentifier("String"),
                           undefined,
-                          [ts.factory.createIdentifier("value")],
+                          [TypeScriptFactory.createIdentifier("value")],
                         ),
                       ],
                     ),
@@ -362,35 +364,35 @@ export namespace SdkHttpNamespaceProgrammer {
               ),
             ),
             local("location")("string")(template()),
-            ts.factory.createReturnStatement(
-              ts.factory.createConditionalExpression(
-                ts.factory.createStrictEquality(
+            TypeScriptFactory.createReturnStatement(
+              TypeScriptFactory.createConditionalExpression(
+                TypeScriptFactory.createStrictEquality(
                   ExpressionFactory.number(0),
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(variables),
+                    TypeScriptFactory.createIdentifier(variables),
                     "size",
                   ),
                 ),
                 undefined,
-                ts.factory.createIdentifier("location"),
+                TypeScriptFactory.createIdentifier("location"),
                 undefined,
-                ts.factory.createTemplateExpression(
-                  ts.factory.createTemplateHead(""),
+                TypeScriptFactory.createTemplateExpression(
+                  TypeScriptFactory.createTemplateHead(""),
                   [
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createIdentifier("location"),
-                      ts.factory.createTemplateMiddle("?"),
+                    TypeScriptFactory.createTemplateSpan(
+                      TypeScriptFactory.createIdentifier("location"),
+                      TypeScriptFactory.createTemplateMiddle("?"),
                     ),
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createCallExpression(
+                    TypeScriptFactory.createTemplateSpan(
+                      TypeScriptFactory.createCallExpression(
                         IdentifierFactory.access(
-                          ts.factory.createIdentifier(variables),
+                          TypeScriptFactory.createIdentifier(variables),
                           "toString",
                         ),
                         undefined,
                         undefined,
                       ),
-                      ts.factory.createTemplateTail(""),
+                      TypeScriptFactory.createTemplateTail(""),
                     ),
                   ],
                 ),
@@ -403,34 +405,38 @@ export namespace SdkHttpNamespaceProgrammer {
       if (route.queryObject !== null && route.queryParameters.length === 0)
         return out(
           block(
-            route.queryObject.metadata.isRequired() === false
-              ? ts.factory.createBinaryExpression(
-                  ts.factory.createIdentifier(route.queryObject.name),
-                  ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                  ts.factory.createObjectLiteralExpression([], false),
+            route.queryObject.metadata.required === false
+              ? TypeScriptFactory.createBinaryExpression(
+                  TypeScriptFactory.createIdentifier(route.queryObject.name),
+                  TypeScriptFactory.createToken(
+                    SyntaxKind.QuestionQuestionToken,
+                  ),
+                  TypeScriptFactory.createObjectLiteralExpression([], false),
                 )
-              : ts.factory.createIdentifier(access(route.queryObject.name)),
+              : TypeScriptFactory.createIdentifier(
+                  access(route.queryObject.name),
+                ),
           ),
         );
       return out(
         block(
-          ts.factory.createObjectLiteralExpression(
+          TypeScriptFactory.createObjectLiteralExpression(
             [
               ...(route.queryObject
                 ? [
-                    ts.factory.createSpreadAssignment(
-                      ts.factory.createIdentifier(
+                    TypeScriptFactory.createSpreadAssignment(
+                      TypeScriptFactory.createIdentifier(
                         access(route.queryObject.name),
                       ),
                     ),
                   ]
                 : []),
               ...route.queryParameters.map((q) =>
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   NamingConvention.variable(q.field!)
                     ? q.field!
-                    : ts.factory.createStringLiteral(q.field!),
-                  ts.factory.createIdentifier(access(q.name)),
+                    : TypeScriptFactory.createStringLiteral(q.field!),
+                  TypeScriptFactory.createIdentifier(access(q.name)),
                 ),
               ),
             ],
@@ -442,61 +448,63 @@ export namespace SdkHttpNamespaceProgrammer {
 
   const writeStringify =
     (project: INestiaProject) =>
-    (importer: ImportDictionary): ts.VariableStatement =>
+    (importer: ImportDictionary): Node =>
       constant("stringify")(
-        ts.factory.createArrowFunction(
+        TypeScriptFactory.createArrowFunction(
           [],
           undefined,
           [
             IdentifierFactory.parameter(
               "input",
-              ts.factory.createTypeReferenceNode("Body"),
+              TypeScriptFactory.createTypeReferenceNode("Body"),
             ),
           ],
           undefined,
           undefined,
-          ts.factory.createCallExpression(
+          TypeScriptFactory.createCallExpression(
             IdentifierFactory.access(
               IdentifierFactory.access(
-                ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+                TypeScriptFactory.createIdentifier(
+                  SdkImportWizard.typia(importer),
+                ),
                 "json",
               ),
               project.config.assert ? "stringify" : "assertStringify",
             ),
             undefined,
-            [ts.factory.createIdentifier("input")],
+            [TypeScriptFactory.createIdentifier("input")],
           ),
         ),
       );
 }
 
-const local = (name: string) => (type: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
+const local = (name: string) => (type: string) => (expression: Node) =>
+  TypeScriptFactory.createVariableStatement(
     [],
-    ts.factory.createVariableDeclarationList(
+    TypeScriptFactory.createVariableDeclarationList(
       [
-        ts.factory.createVariableDeclaration(
+        TypeScriptFactory.createVariableDeclaration(
           name,
           undefined,
-          ts.factory.createTypeReferenceNode(type),
+          TypeScriptFactory.createTypeReferenceNode(type),
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );
-const constant = (name: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    ts.factory.createVariableDeclarationList(
+const constant = (name: string) => (expression: Node) =>
+  TypeScriptFactory.createVariableStatement(
+    [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
+    TypeScriptFactory.createVariableDeclarationList(
       [
-        ts.factory.createVariableDeclaration(
+        TypeScriptFactory.createVariableDeclaration(
           name,
           undefined,
           undefined,
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );