@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/generates/internal/SdkHttpParameterProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
@@ -10,7 +10,7 @@ export namespace SdkHttpParameterProgrammer {
   export interface IEntry {
     key: string;
     required: boolean;
-    type: ts.TypeNode;
+    type: Node;
     parameter: ITypedHttpRouteParameter;
   }
 
@@ -57,7 +57,7 @@ export namespace SdkHttpParameterProgrammer {
       ...[...props.route.pathParameters, ...props.route.queryParameters].map(
         (p) => ({
           key: p.name,
-          required: p.metadata.isRequired(),
+          required: p.metadata.required,
           type:
             props.project.config.clone === true
               ? SdkAliasCollection.from(props.project)(props.importer)(
@@ -71,7 +71,7 @@ export namespace SdkHttpParameterProgrammer {
         ? [
             {
               key: props.route.queryObject.name,
-              required: props.route.queryObject.metadata.isRequired(),
+              required: props.route.queryObject.metadata.required,
               type:
                 props.e2e === true
                   ? props.project.config.clone === true
@@ -79,7 +79,7 @@ export namespace SdkHttpParameterProgrammer {
                         props.route.queryObject.metadata,
                       )
                     : SdkAliasCollection.name(props.route.queryObject)
-                  : ts.factory.createTypeReferenceNode(`${prefix}Query`),
+                  : TypeScriptFactory.createTypeReferenceNode(`${prefix}Query`),
               parameter: props.route.queryObject,
             },
           ]
@@ -88,7 +88,7 @@ export namespace SdkHttpParameterProgrammer {
         ? [
             {
               key: props.route.body.name,
-              required: props.route.body.metadata.isRequired(),
+              required: props.route.body.metadata.required,
               type:
                 props.e2e === true
                   ? props.project.config.clone === true
@@ -96,7 +96,7 @@ export namespace SdkHttpParameterProgrammer {
                         props.route.body.metadata,
                       )
                     : SdkAliasCollection.name(props.route.body)
-                  : ts.factory.createTypeReferenceNode(`${prefix}Body`),
+                  : TypeScriptFactory.createTypeReferenceNode(`${prefix}Body`),
               parameter: props.route.body,
             },
           ]
@@ -110,24 +110,24 @@ export namespace SdkHttpParameterProgrammer {
     route: ITypedHttpRoute;
     body: boolean;
     prefix: boolean;
-  }): ts.ParameterDeclaration[] => {
+  }): Node[] => {
     const entries: IEntry[] = getEntries(props);
     if (entries.length === 0) return [];
     else if (props.project.config.keyword === true) {
       const typeName: string = props.prefix
         ? `${props.route.name}.Props`
         : "Props";
-      const node: ts.TypeReferenceNode =
+      const node: Node =
         props.body === false && props.route.body !== null
-          ? ts.factory.createTypeReferenceNode("Omit", [
-              ts.factory.createTypeReferenceNode(typeName),
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral(props.route.body.name),
+          ? TypeScriptFactory.createTypeReferenceNode("Omit", [
+              TypeScriptFactory.createTypeReferenceNode(typeName),
+              TypeScriptFactory.createLiteralTypeNode(
+                TypeScriptFactory.createStringLiteral(props.route.body.name),
               ),
             ])
-          : ts.factory.createTypeReferenceNode(typeName);
+          : TypeScriptFactory.createTypeReferenceNode(typeName);
       return [
-        ts.factory.createParameterDeclaration(
+        TypeScriptFactory.createParameterDeclaration(
           undefined,
           undefined,
           "props",
@@ -138,13 +138,13 @@ export namespace SdkHttpParameterProgrammer {
       ];
     }
     return entries.map((e) =>
-      ts.factory.createParameterDeclaration(
+      TypeScriptFactory.createParameterDeclaration(
         undefined,
         undefined,
         e.key,
         e.required
           ? undefined
-          : ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+          : TypeScriptFactory.createToken(SyntaxKind.QuestionToken),
         e.type,
         undefined,
       ),
@@ -155,24 +155,11 @@ export namespace SdkHttpParameterProgrammer {
     project: INestiaProject;
     route: ITypedHttpRoute;
     body: boolean;
-  }): ts.Expression[] => {
+  }): Node[] => {
     const parameters = getSignificant(props.route, props.body);
     if (parameters.length === 0) return [];
     else if (props.project.config.keyword === true)
-      return [ts.factory.createIdentifier("props")];
-    return parameters.map((p) => ts.factory.createIdentifier(p.name));
-  };
-
-  export const getAccessors = (props: {
-    project: INestiaProject;
-    importer: ImportDictionary;
-    route: ITypedHttpRoute;
-    body: boolean;
-  }): ts.Expression[] => {
-    const prefix: string =
-      props.project.config.keyword === true ? "props." : "";
-    return getSignificant(props.route, props.body).map((p) =>
-      ts.factory.createIdentifier(`${prefix}${p.name}`),
-    );
+      return [TypeScriptFactory.createIdentifier("props")];
+    return parameters.map((p) => TypeScriptFactory.createIdentifier(p.name));
   };
 }

package/src/generates/internal/SdkHttpRouteProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import { Node } from "@nestia/factory";
 import { IJsDocTagInfo } from "typia";
 
 import { INestiaConfig } from "../../INestiaConfig";
@@ -14,7 +14,7 @@ export namespace SdkHttpRouteProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement[] => [
+    (route: ITypedHttpRoute): Node[] => [
       FilePrinter.description(
         SdkHttpFunctionProgrammer.write(project)(importer)(route),
         describe(project.config, route),

package/src/generates/internal/SdkHttpSimulationProgrammer.ts

@@ -1,11 +1,5 @@
-import {
-  ExpressionFactory,
-  IdentifierFactory,
-  LiteralFactory,
-  StatementFactory,
-  TypeFactory,
-} from "@typia/core";
-import ts from "typescript";
+import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { ExpressionFactory, IdentifierFactory, LiteralFactory, StatementFactory, TypeFactory } from "@nestia/factory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
@@ -13,28 +7,31 @@ import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
+import { sizeOf } from "../../internal/legacy";
 
 export namespace SdkHttpSimulationProgrammer {
   export const random =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.VariableStatement => {
+    (route: ITypedHttpRoute): Node => {
       const output = SdkAliasCollection.responseBody(project)(importer)(route);
       return constant("random")(
-        ts.factory.createArrowFunction(
+        TypeScriptFactory.createArrowFunction(
           undefined,
           undefined,
           [],
           project.config.primitive === false
             ? output
-            : ts.factory.createTypeReferenceNode(
+            : TypeScriptFactory.createTypeReferenceNode(
                 SdkImportWizard.Resolved(importer),
                 [output],
               ),
           undefined,
-          ts.factory.createCallExpression(
+          TypeScriptFactory.createCallExpression(
             IdentifierFactory.access(
-              ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+              TypeScriptFactory.createIdentifier(
+                SdkImportWizard.typia(importer),
+              ),
               "random",
             ),
             [output],
@@ -47,18 +44,18 @@ export namespace SdkHttpSimulationProgrammer {
   export const simulate =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.VariableStatement => {
+    (route: ITypedHttpRoute): Node => {
       const output: boolean =
         project.config.propagate === true ||
-        route.success.metadata.size() !== 0;
+        sizeOf(route.success.metadata) !== 0;
       const caller = () =>
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("random"),
+        TypeScriptFactory.createCallExpression(
+          TypeScriptFactory.createIdentifier("random"),
           undefined,
           undefined,
         );
       return constant("simulate")(
-        ts.factory.createArrowFunction(
+        TypeScriptFactory.createArrowFunction(
           undefined,
           undefined,
           [
@@ -67,11 +64,11 @@ export namespace SdkHttpSimulationProgrammer {
                 0
                 ? "connection"
                 : "_connection",
-              ts.factory.createTypeReferenceNode(
+              TypeScriptFactory.createTypeReferenceNode(
                 SdkImportWizard.IConnection(importer),
                 route.headerObject
                   ? [
-                      ts.factory.createTypeReferenceNode(
+                      TypeScriptFactory.createTypeReferenceNode(
                         `${route.name}.Headers`,
                       ),
                     ]
@@ -86,38 +83,41 @@ export namespace SdkHttpSimulationProgrammer {
               prefix: false,
             }),
           ],
-          ts.factory.createTypeReferenceNode(output ? "Output" : "void"),
+          TypeScriptFactory.createTypeReferenceNode(output ? "Output" : "void"),
           undefined,
-          ts.factory.createBlock(
+          TypeScriptFactory.createBlock(
             [
               ...assert(project)(importer)(route),
-              ts.factory.createReturnStatement(
+              TypeScriptFactory.createReturnStatement(
                 project.config.propagate
-                  ? ts.factory.createAsExpression(
-                      ts.factory.createObjectLiteralExpression(
+                  ? TypeScriptFactory.createAsExpression(
+                      TypeScriptFactory.createObjectLiteralExpression(
                         [
-                          ts.factory.createPropertyAssignment(
+                          TypeScriptFactory.createPropertyAssignment(
                             "success",
-                            ts.factory.createTrue(),
+                            TypeScriptFactory.createTrue(),
                           ),
-                          ts.factory.createPropertyAssignment(
+                          TypeScriptFactory.createPropertyAssignment(
                             "status",
                             ExpressionFactory.number(
                               route.success.status ??
                                 (route.method === "POST" ? 201 : 200),
                             ),
                           ),
-                          ts.factory.createPropertyAssignment(
+                          TypeScriptFactory.createPropertyAssignment(
                             "headers",
                             LiteralFactory.write({
                               "Content-Type": route.success.contentType,
                             }),
                           ),
-                          ts.factory.createPropertyAssignment("data", caller()),
+                          TypeScriptFactory.createPropertyAssignment(
+                            "data",
+                            caller(),
+                          ),
                         ],
                         true,
                       ),
-                      ts.factory.createTypeReferenceNode("Output"),
+                      TypeScriptFactory.createTypeReferenceNode("Output"),
                     )
                   : caller(),
               ),
@@ -131,16 +131,16 @@ export namespace SdkHttpSimulationProgrammer {
   const assert =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement[] => {
+    (route: ITypedHttpRoute): Node[] => {
       const parameters = SdkHttpParameterProgrammer.getSignificant(route, true);
       if (parameters.length === 0) return [];
 
       const typia = SdkImportWizard.typia(importer);
       const validator = StatementFactory.constant({
         name: "assert",
-        value: ts.factory.createCallExpression(
+        value: TypeScriptFactory.createCallExpression(
           IdentifierFactory.access(
-            ts.factory.createIdentifier(
+            TypeScriptFactory.createIdentifier(
               importer.external({
                 file: `@nestia/fetcher`,
                 declaration: false,
@@ -152,20 +152,20 @@ export namespace SdkHttpSimulationProgrammer {
           ),
           undefined,
           [
-            ts.factory.createObjectLiteralExpression(
+            TypeScriptFactory.createObjectLiteralExpression(
               [
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "method",
-                  ts.factory.createIdentifier("METADATA.method"),
+                  TypeScriptFactory.createIdentifier("METADATA.method"),
                 ),
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "host",
-                  ts.factory.createIdentifier("connection.host"),
+                  TypeScriptFactory.createIdentifier("connection.host"),
                 ),
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "path",
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("path"),
+                  TypeScriptFactory.createCallExpression(
+                    TypeScriptFactory.createIdentifier("path"),
                     undefined,
                     SdkHttpParameterProgrammer.getArguments({
                       project,
@@ -174,9 +174,9 @@ export namespace SdkHttpSimulationProgrammer {
                     }),
                   ),
                 ),
-                ts.factory.createPropertyAssignment(
+                TypeScriptFactory.createPropertyAssignment(
                   "contentType",
-                  ts.factory.createIdentifier(
+                  TypeScriptFactory.createIdentifier(
                     JSON.stringify(route.success.contentType),
                   ),
                 ),
@@ -186,44 +186,44 @@ export namespace SdkHttpSimulationProgrammer {
           ],
         ),
       });
-      const individual = parameters
+      const individual: Node[] = parameters
         .map((p) =>
-          ts.factory.createCallExpression(
+          TypeScriptFactory.createCallExpression(
             (() => {
               const base = IdentifierFactory.access(
-                ts.factory.createIdentifier("assert"),
+                TypeScriptFactory.createIdentifier("assert"),
                 p.category,
               );
               if (p.category !== "param") return base;
-              return ts.factory.createCallExpression(base, undefined, [
-                ts.factory.createStringLiteral(p.name),
+              return TypeScriptFactory.createCallExpression(base, undefined, [
+                TypeScriptFactory.createStringLiteral(p.name),
               ]);
             })(),
             undefined,
             [
-              ts.factory.createArrowFunction(
+              TypeScriptFactory.createArrowFunction(
                 undefined,
                 undefined,
                 [],
                 undefined,
                 undefined,
-                ts.factory.createCallExpression(
+                TypeScriptFactory.createCallExpression(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(typia),
+                    TypeScriptFactory.createIdentifier(typia),
                     "assert",
                   ),
                   undefined,
                   [
                     project.config.keyword === true
-                      ? ts.factory.createIdentifier(`props.${p.name}`)
-                      : ts.factory.createIdentifier(p.name),
+                      ? TypeScriptFactory.createIdentifier(`props.${p.name}`)
+                      : TypeScriptFactory.createIdentifier(p.name),
                   ],
                 ),
               ),
             ],
           ),
         )
-        .map(ts.factory.createExpressionStatement);
+        .map(TypeScriptFactory.createExpressionStatement) as Node[];
       return [
         validator,
         ...(project.config.propagate !== true
@@ -233,53 +233,55 @@ export namespace SdkHttpSimulationProgrammer {
     };
 
   const tryAndCatch =
-    (importer: ImportDictionary) => (individual: ts.Statement[]) =>
-      ts.factory.createTryStatement(
-        ts.factory.createBlock(individual, true),
-        ts.factory.createCatchClause(
+    (importer: ImportDictionary) => (individual: Node[]) =>
+      TypeScriptFactory.createTryStatement(
+        TypeScriptFactory.createBlock(individual, true),
+        TypeScriptFactory.createCatchClause(
           "exp",
-          ts.factory.createBlock(
+          TypeScriptFactory.createBlock(
             [
-              ts.factory.createIfStatement(
-                ts.factory.createLogicalNot(
-                  ts.factory.createCallExpression(
+              TypeScriptFactory.createIfStatement(
+                TypeScriptFactory.createLogicalNot(
+                  TypeScriptFactory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createIdentifier(
+                      TypeScriptFactory.createIdentifier(
                         SdkImportWizard.typia(importer),
                       ),
                       "is",
                     ),
                     [
-                      ts.factory.createTypeReferenceNode(
+                      TypeScriptFactory.createTypeReferenceNode(
                         SdkImportWizard.HttpError(importer),
                       ),
                     ],
-                    [ts.factory.createIdentifier("exp")],
+                    [TypeScriptFactory.createIdentifier("exp")],
                   ),
                 ),
-                ts.factory.createThrowStatement(
-                  ts.factory.createIdentifier("exp"),
+                TypeScriptFactory.createThrowStatement(
+                  TypeScriptFactory.createIdentifier("exp"),
                 ),
               ),
-              ts.factory.createReturnStatement(
-                ts.factory.createAsExpression(
-                  ts.factory.createObjectLiteralExpression(
+              TypeScriptFactory.createReturnStatement(
+                TypeScriptFactory.createAsExpression(
+                  TypeScriptFactory.createObjectLiteralExpression(
                     [
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "success",
-                        ts.factory.createFalse(),
+                        TypeScriptFactory.createFalse(),
                       ),
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "status",
-                        ts.factory.createIdentifier("exp.status"),
+                        TypeScriptFactory.createIdentifier("exp.status"),
                       ),
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "headers",
-                        ts.factory.createIdentifier("exp.headers"),
+                        TypeScriptFactory.createIdentifier("exp.headers"),
                       ),
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "data",
-                        ts.factory.createIdentifier("exp.toJSON().message"),
+                        TypeScriptFactory.createIdentifier(
+                          "exp.toJSON().message",
+                        ),
                       ),
                     ],
                     true,
@@ -295,18 +297,18 @@ export namespace SdkHttpSimulationProgrammer {
       );
 }
 
-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(
-          ts.factory.createIdentifier(name),
+        TypeScriptFactory.createVariableDeclaration(
+          TypeScriptFactory.createIdentifier(name),
           undefined,
           undefined,
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );