@nestia/sdk 7.0.0-dev.20250605-3 → 7.0.0-dev.20250607

package/src/generates/internal/SdkHttpNamespaceProgrammer.ts

@@ -7,10 +7,10 @@ import { Escaper } from "typia/lib/utils/Escaper";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkHttpSimulationProgrammer } from "./SdkHttpSimulationProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
 
@@ -18,37 +18,28 @@ export namespace SdkHttpNamespaceProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      props: {
-        headers: ITypedHttpRouteParameter.IHeaders | undefined;
-        query: ITypedHttpRouteParameter.IQuery | undefined;
-        body: ITypedHttpRouteParameter.IBody | undefined;
-      },
-    ): ts.ModuleDeclaration => {
-      const types = writeTypes(project)(importer)(route, props);
+    (route: ITypedHttpRoute): ts.ModuleDeclaration => {
+      const types: ts.TypeAliasDeclaration[] =
+        writeTypes(project)(importer)(route);
       return ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier(route.name),
         ts.factory.createModuleBlock([
           ...types,
           ...(types.length ? [FilePrinter.enter()] : []),
-          writeMetadata(project)(importer)(route, props),
+          writeMetadata(project)(importer)(route),
           FilePrinter.enter(),
-          writePath(project)(importer)(route, props.query),
+          writePath(project)(importer)(route),
           ...(project.config.simulate
             ? [
                 SdkHttpSimulationProgrammer.random(project)(importer)(route),
-                SdkHttpSimulationProgrammer.simulate(project)(importer)(
-                  route,
-                  props,
-                ),
+                SdkHttpSimulationProgrammer.simulate(project)(importer)(route),
               ]
             : []),
           ...(project.config.json &&
-          props.body !== undefined &&
-          (props.body.contentType === "application/json" ||
-            props.body.encrypted === true)
+          route.body &&
+          (route.body.contentType === "application/json" ||
+            route.body.encrypted === true)
             ? [writeStringify(project)(importer)]
             : []),
         ]),
@@ -59,14 +50,7 @@ export namespace SdkHttpNamespaceProgrammer {
   const writeTypes =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      props: {
-        headers: ITypedHttpRouteParameter.IHeaders | undefined;
-        query: ITypedHttpRouteParameter.IQuery | undefined;
-        body: ITypedHttpRouteParameter.IBody | undefined;
-      },
-    ): ts.TypeAliasDeclaration[] => {
+    (route: ITypedHttpRoute): ts.TypeAliasDeclaration[] => {
       const array: ts.TypeAliasDeclaration[] = [];
       const declare = (name: string, type: ts.TypeNode) =>
         array.push(
@@ -79,27 +63,30 @@ export namespace SdkHttpNamespaceProgrammer {
         );
       if (
         project.config.keyword === true &&
-        route.parameters.filter((p) => p.category !== "headers").length !== 0
+        SdkHttpParameterProgrammer.getSignificant(route, true).length !== 0
       )
-        declare("IProps", SdkAliasCollection.props(project)(importer)(route));
-      if (props.headers !== undefined)
+        declare(
+          "Props",
+          SdkAliasCollection.httpProps(project)(importer)(route),
+        );
+      if (route.headerObject)
         declare(
           "Headers",
-          SdkAliasCollection.headers(project)(importer)(props.headers),
+          SdkAliasCollection.headers(project)(importer)(route.headerObject),
         );
-      if (props.query !== undefined)
+      if (route.queryObject)
         declare(
           "Query",
-          SdkAliasCollection.query(project)(importer)(props.query),
+          SdkAliasCollection.query(project)(importer)(route.queryObject),
         );
-      if (props.body !== undefined)
-        declare("Body", SdkAliasCollection.body(project)(importer)(props.body));
+      if (route.body)
+        declare("Body", SdkAliasCollection.body(project)(importer)(route.body));
       if (
         project.config.propagate === true ||
         route.success.metadata.size() !== 0
       )
         declare(
-          "Response",
+          "Output",
           SdkAliasCollection.response(project)(importer)(route),
         );
       return array;
@@ -108,14 +95,7 @@ export namespace SdkHttpNamespaceProgrammer {
   const writeMetadata =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      props: {
-        headers: ITypedHttpRouteParameter.IHeaders | undefined;
-        query: ITypedHttpRouteParameter.IQuery | undefined;
-        body: ITypedHttpRouteParameter.IBody | undefined;
-      },
-    ): ts.VariableStatement =>
+    (route: ITypedHttpRoute): ts.VariableStatement =>
       constant("METADATA")(
         ts.factory.createAsExpression(
           ts.factory.createObjectLiteralExpression(
@@ -130,12 +110,12 @@ export namespace SdkHttpNamespaceProgrammer {
               ),
               ts.factory.createPropertyAssignment(
                 "request",
-                props.body
+                route.body
                   ? LiteralFactory.write(
-                      props.body !== undefined
+                      route.body !== undefined
                         ? {
-                            type: props.body.contentType,
-                            encrypted: !!props.body.encrypted,
+                            type: route.body.contentType,
+                            encrypted: !!route.body.encrypted,
                           }
                         : {
                             type: "application/json",
@@ -192,79 +172,33 @@ export namespace SdkHttpNamespaceProgrammer {
   const writePath =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      query: ITypedHttpRouteParameter.IQuery | undefined,
-    ): ts.VariableStatement => {
-      interface IProperty {
-        key: string;
-        value: ts.TypeNode;
-        required: boolean;
-      }
-      const g = {
-        total: [
-          ...route.parameters.filter(
-            (param) => param.category === "param" || param.category === "query",
-          ),
-        ],
-        query: route.parameters
-          .filter((param) => param.category === "query")
-          .filter((param) => param.field !== null),
-        path: route.parameters.filter((param) => param.category === "param"),
-      };
-      const properties: IProperty[] = g.total.map((p) => ({
-        key: p.name,
-        value:
-          p === query
-            ? p.metadata.isRequired() === false
-              ? ts.factory.createUnionTypeNode([
-                  ts.factory.createTypeReferenceNode(`${route.name}.Query`),
-                  ts.factory.createTypeReferenceNode("undefined"),
-                ])
-              : ts.factory.createTypeReferenceNode(`${route.name}.Query`)
-            : project.config.clone === true
-              ? SdkAliasCollection.from(project)(importer)(p.metadata)
-              : SdkAliasCollection.name(p),
-        required: p.metadata.isRequired(),
-      }));
+    (route: ITypedHttpRoute): ts.VariableStatement => {
       const out = (body: ts.ConciseBody) =>
         constant("path")(
           ts.factory.createArrowFunction(
             [],
             [],
-            project.config.keyword === true && properties.length !== 0
-              ? [
-                  IdentifierFactory.parameter(
-                    "p",
-                    ts.factory.createTypeLiteralNode(
-                      properties.map((p) =>
-                        ts.factory.createPropertySignature(
-                          undefined,
-                          p.key,
-                          p.required
-                            ? undefined
-                            : ts.factory.createToken(
-                                ts.SyntaxKind.QuestionToken,
-                              ),
-                          p.value,
-                        ),
-                      ),
-                    ),
-                  ),
-                ]
-              : properties.map((p) =>
-                  IdentifierFactory.parameter(p.key, p.value),
-                ),
+            SdkHttpParameterProgrammer.getParameterDeclarations({
+              project,
+              importer,
+              route,
+              body: false,
+              prefix: false,
+            }),
             undefined,
             undefined,
             body,
           ),
         );
-      if (g.total.length === 0)
+      const parameters = SdkHttpParameterProgrammer.getSignificant(
+        route,
+        false,
+      );
+      if (parameters.length === 0)
         return out(ts.factory.createStringLiteral(route.path));
 
       const access = (name: string) =>
-        project.config.keyword === true ? `p.${name}` : name;
+        project.config.keyword === true ? `props.${name}` : name;
       const template = () => {
         const split: string[] = route.path.split(":");
         if (split.length === 1)
@@ -282,7 +216,10 @@ export namespace SdkHttpNamespaceProgrammer {
                     ts.factory.createCallChain(
                       ts.factory.createPropertyAccessChain(
                         ts.factory.createIdentifier(
-                          access(g.path.find((p) => p.field === name)!.name),
+                          access(
+                            route.pathParameters.find((p) => p.field === name)!
+                              .name,
+                          ),
                         ),
                         ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
                         "toString",
@@ -303,11 +240,12 @@ export namespace SdkHttpNamespaceProgrammer {
           }),
         );
       };
-      if (query === undefined && g.query.length === 0) return out(template());
+      if (route.queryObject === null && route.queryParameters.length === 0)
+        return out(template());
 
       const block = (expr: ts.Expression) => {
         const computeName = (str: string): string =>
-          g.total.find((p) => p.name === str) !== undefined
+          parameters.find((p) => p.name === str) !== undefined
             ? computeName("_" + str)
             : str;
         const variables: string = computeName("variables");
@@ -460,30 +398,32 @@ export namespace SdkHttpNamespaceProgrammer {
           true,
         );
       };
-      if (query !== undefined && g.query.length === 0)
+      if (route.queryObject !== null && route.queryParameters.length === 0)
         return out(
           block(
-            query.metadata.isRequired() === false
+            route.queryObject.metadata.isRequired() === false
               ? ts.factory.createBinaryExpression(
-                  ts.factory.createIdentifier(query.name),
+                  ts.factory.createIdentifier(route.queryObject.name),
                   ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
                   ts.factory.createObjectLiteralExpression([], false),
                 )
-              : ts.factory.createIdentifier(access(query.name)),
+              : ts.factory.createIdentifier(access(route.queryObject.name)),
           ),
         );
       return out(
         block(
           ts.factory.createObjectLiteralExpression(
             [
-              ...(query
+              ...(route.queryObject
                 ? [
                     ts.factory.createSpreadAssignment(
-                      ts.factory.createIdentifier(access(query.name)),
+                      ts.factory.createIdentifier(
+                        access(route.queryObject.name),
+                      ),
                     ),
                   ]
                 : []),
-              ...g.query.map((q) =>
+              ...route.queryParameters.map((q) =>
                 ts.factory.createPropertyAssignment(
                   Escaper.variable(q.field!)
                     ? q.field!

package/src/generates/internal/SdkHttpParameterProgrammer.ts

@@ -0,0 +1,178 @@
+import ts from "typescript";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkAliasCollection } from "./SdkAliasCollection";
+
+export namespace SdkHttpParameterProgrammer {
+  export interface IEntry {
+    key: string;
+    required: boolean;
+    type: ts.TypeNode;
+    parameter: ITypedHttpRouteParameter;
+  }
+
+  export const getAll = (
+    route: ITypedHttpRoute,
+  ): ITypedHttpRouteParameter[] => [
+    ...route.pathParameters,
+    ...route.queryParameters,
+    ...route.headerParameters,
+    ...(route.queryObject ? [route.queryObject] : []),
+    ...(route.body ? [route.body] : []),
+    ...(route.headerObject ? [route.headerObject] : []),
+  ];
+
+  export const getSignificant = (route: ITypedHttpRoute, body: boolean) => [
+    ...route.pathParameters,
+    ...route.queryParameters,
+    ...(route.queryObject ? [route.queryObject] : []),
+    ...(body && route.body ? [route.body] : []),
+  ];
+
+  export const getEntries = (props: {
+    project: INestiaProject;
+    importer: ImportDictionary;
+    route: ITypedHttpRoute;
+    body: boolean;
+    prefix: boolean | string;
+    e2e?: boolean;
+  }): IEntry[] => {
+    if (
+      props.route.pathParameters.length === 0 &&
+      props.route.queryParameters.length === 0 &&
+      props.route.queryObject === null &&
+      (props.body === false || props.route.body === null)
+    )
+      return [];
+    const prefix =
+      typeof props.prefix === "string"
+        ? props.prefix
+        : props.prefix === true
+          ? `${props.route.name}.`
+          : "";
+    return [
+      ...[...props.route.pathParameters, ...props.route.queryParameters].map(
+        (p) => ({
+          key: p.name,
+          required: p.metadata.isRequired(),
+          type:
+            props.project.config.clone === true
+              ? SdkAliasCollection.from(props.project)(props.importer)(
+                  p.metadata,
+                )
+              : SdkAliasCollection.name(p),
+          parameter: p,
+        }),
+      ),
+      ...(props.route.queryObject
+        ? [
+            {
+              key: props.route.queryObject.name,
+              required: props.route.queryObject.metadata.isRequired(),
+              type:
+                props.e2e === true
+                  ? props.project.config.clone === true
+                    ? SdkAliasCollection.from(props.project)(props.importer)(
+                        props.route.queryObject.metadata,
+                      )
+                    : SdkAliasCollection.name(props.route.queryObject)
+                  : ts.factory.createTypeReferenceNode(`${prefix}Query`),
+              parameter: props.route.queryObject,
+            },
+          ]
+        : []),
+      ...(props.body && props.route.body
+        ? [
+            {
+              key: props.route.body.name,
+              required: props.route.body.metadata.isRequired(),
+              type:
+                props.e2e === true
+                  ? props.project.config.clone === true
+                    ? SdkAliasCollection.from(props.project)(props.importer)(
+                        props.route.body.metadata,
+                      )
+                    : SdkAliasCollection.name(props.route.body)
+                  : ts.factory.createTypeReferenceNode(`${prefix}Body`),
+              parameter: props.route.body,
+            },
+          ]
+        : []),
+    ];
+  };
+
+  export const getParameterDeclarations = (props: {
+    project: INestiaProject;
+    importer: ImportDictionary;
+    route: ITypedHttpRoute;
+    body: boolean;
+    prefix: boolean;
+  }): ts.ParameterDeclaration[] => {
+    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 =
+        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),
+              ),
+            ])
+          : ts.factory.createTypeReferenceNode(typeName);
+      return [
+        ts.factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          "props",
+          undefined,
+          node,
+          undefined,
+        ),
+      ];
+    }
+    return entries.map((e) =>
+      ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        e.key,
+        e.required
+          ? undefined
+          : ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+        e.type,
+        undefined,
+      ),
+    );
+  };
+
+  export const getArguments = (props: {
+    project: INestiaProject;
+    route: ITypedHttpRoute;
+    body: boolean;
+  }): ts.Expression[] => {
+    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}`),
+    );
+  };
+}

package/src/generates/internal/SdkHttpRouteProgrammer.ts

@@ -8,29 +8,19 @@ import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkHttpFunctionProgrammer } from "./SdkHttpFunctionProgrammer";
 import { SdkHttpNamespaceProgrammer } from "./SdkHttpNamespaceProgrammer";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 
 export namespace SdkHttpRouteProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement[] => {
-      const props = {
-        headers: route.parameters
-          .filter((p) => p.category === "headers")
-          .find((p) => p.field === null),
-        query: route.parameters
-          .filter((p) => p.category === "query")
-          .find((p) => p.field === null),
-        body: route.parameters.find((p) => p.category === "body"),
-      };
-      return [
-        FilePrinter.description(
-          SdkHttpFunctionProgrammer.write(project)(importer)(route, props),
-          describe(project.config, route),
-        ),
-        SdkHttpNamespaceProgrammer.write(project)(importer)(route, props),
-      ];
-    };
+    (route: ITypedHttpRoute): ts.Statement[] => [
+      FilePrinter.description(
+        SdkHttpFunctionProgrammer.write(project)(importer)(route),
+        describe(project.config, route),
+      ),
+      SdkHttpNamespaceProgrammer.write(project)(importer)(route),
+    ];
 
   const describe = (config: INestiaConfig, route: ITypedHttpRoute): string => {
     // MAIN DESCRIPTION
@@ -40,9 +30,7 @@ export namespace SdkHttpRouteProgrammer {
     const tagComments: string[] = [];
 
     // PARAMETERS
-    for (const p of route.parameters) {
-      if (p.category === "headers") continue;
-
+    for (const p of SdkHttpParameterProgrammer.getSignificant(route, true)) {
       const description: string | undefined =
         p.description ??
         p.jsDocTags.find((tag) => tag.name === "description")?.text?.[0].text ??