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

package/src/generates/SwaggerGenerator.ts

@@ -10,8 +10,8 @@ import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 import { INestiaConfig } from "../INestiaConfig";
 import { ITypedApplication } from "../structures/ITypedApplication";
 import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { ITypedHttpRouteParameter } from "../structures/ITypedHttpRouteParameter";
 import { FileRetriever } from "../utils/FileRetriever";
+import { SdkHttpParameterProgrammer } from "./internal/SdkHttpParameterProgrammer";
 import { SwaggerOperationComposer } from "./internal/SwaggerOperationComposer";
 
 export namespace SwaggerGenerator {
@@ -79,7 +79,7 @@ export namespace SwaggerGenerator {
     const metadatas: Metadata[] = routes
       .map((r) => [
         r.success.metadata,
-        ...r.parameters.map((p) => p.metadata),
+        ...SdkHttpParameterProgrammer.getAll(r).map((p) => p.metadata),
         ...Object.values(r.exceptions).map((e) => e.metadata),
       ])
       .flat()
@@ -128,9 +128,7 @@ export namespace SwaggerGenerator {
               | string
               | {
                   type: string;
-                  /**
-                   * @format uri
-                   */
+                  /** @format uri */
                   url: string;
                 };
           }>(content);
@@ -267,15 +265,9 @@ export namespace SwaggerGenerator {
     for (const fn of customizers) fn();
   };
 
-  const getPath = (route: {
-    path: string;
-    parameters: ITypedHttpRouteParameter[];
-  }): string => {
+  const getPath = (route: ITypedHttpRoute): string => {
     let str: string = route.path;
-    const filtered: ITypedHttpRouteParameter.IParam[] = route.parameters.filter(
-      (param) => param.category === "param",
-    );
-    for (const param of filtered)
+    for (const param of route.pathParameters)
       str = str.replace(`:${param.field}`, `{${param.field}}`);
     return str;
   };

package/src/generates/internal/E2eFileProgrammer.ts

@@ -7,6 +7,7 @@ import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
 
 export namespace E2eFileProgrammer {
@@ -66,14 +67,11 @@ export namespace E2eFileProgrammer {
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) => {
-      const headers = route.parameters.find(
-        (p) => p.category === "headers" && p.field === null,
-      );
       const random = IdentifierFactory.access(
         ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
         "random",
       );
-      const connection = headers
+      const connection = route.headerObject
         ? ts.factory.createObjectLiteralExpression(
             [
               ts.factory.createSpreadAssignment(
@@ -95,9 +93,9 @@ export namespace E2eFileProgrammer {
                         [
                           project.config.clone === true
                             ? SdkAliasCollection.from(project)(importer)(
-                                headers.metadata,
+                                route.headerObject.metadata,
                               )
-                            : SdkAliasCollection.name(headers),
+                            : SdkAliasCollection.name(route.headerObject),
                         ],
                         undefined,
                       ),
@@ -110,6 +108,14 @@ export namespace E2eFileProgrammer {
             true,
           )
         : ts.factory.createIdentifier("connection");
+      const entries = SdkHttpParameterProgrammer.getEntries({
+        project,
+        importer,
+        route,
+        body: true,
+        e2e: true,
+        prefix: ["api", "functional", ...route.accessor].join(".") + ".",
+      });
       const fetch = ts.factory.createCallExpression(
         ts.factory.createIdentifier(
           ["api", "functional", ...route.accessor].join("."),
@@ -117,53 +123,38 @@ export namespace E2eFileProgrammer {
         undefined,
         [
           connection,
-          ...(project.config.keyword === true &&
-          route.parameters.filter((p) => p.category !== "headers").length !== 0
+          ...(project.config.keyword === true && entries.length !== 0
             ? [
                 LiteralFactory.write(
                   Object.fromEntries(
-                    route.parameters
-                      .filter((p) => p.category !== "headers")
-                      .map((p) => [
-                        p.name,
-                        ts.factory.createCallExpression(
-                          IdentifierFactory.access(
-                            ts.factory.createIdentifier(
-                              SdkImportWizard.typia(importer),
-                            ),
-                            "random",
+                    entries.map((e) => [
+                      e.key,
+                      ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                          ts.factory.createIdentifier(
+                            SdkImportWizard.typia(importer),
                           ),
-                          [
-                            project.config.clone === true
-                              ? SdkAliasCollection.from(project)(importer)(
-                                  p.metadata,
-                                )
-                              : SdkAliasCollection.name(p),
-                          ],
-                          undefined,
+                          "random",
                         ),
-                      ]),
+                        [e.type],
+                        undefined,
+                      ),
+                    ]),
                   ),
                 ),
               ]
-            : route.parameters
-                .filter((p) => p.category !== "headers")
-                .map((p) =>
-                  ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                      ts.factory.createIdentifier(
-                        SdkImportWizard.typia(importer),
-                      ),
-                      "random",
+            : entries.map((e) =>
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(
+                    ts.factory.createIdentifier(
+                      SdkImportWizard.typia(importer),
                     ),
-                    [
-                      project.config.clone === true
-                        ? SdkAliasCollection.from(project)(importer)(p.metadata)
-                        : SdkAliasCollection.name(p),
-                    ],
-                    undefined,
+                    "random",
                   ),
-                )),
+                  [e.type],
+                  undefined,
+                ),
+              )),
         ],
       );
       const assert = ts.factory.createCallExpression(

package/src/generates/internal/SdkAliasCollection.ts

@@ -6,7 +6,10 @@ import { INestiaProject } from "../../structures/INestiaProject";
 import { IReflectType } from "../../structures/IReflectType";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
@@ -24,28 +27,76 @@ export namespace SdkAliasCollection {
     (metadata: Metadata) =>
       SdkTypeProgrammer.write(project)(importer)(metadata);
 
-  export const props =
+  export const httpProps =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute): ts.TypeNode =>
       ts.factory.createTypeLiteralNode(
-        route.parameters
-          .filter((p) => p.category !== "headers")
-          .map((param) =>
+        SdkHttpParameterProgrammer.getEntries({
+          project,
+          importer,
+          route,
+          body: true,
+          prefix: false,
+        })
+          .map((e) => {
+            const signature: ts.PropertySignature =
+              ts.factory.createPropertySignature(
+                undefined,
+                e.key,
+                e.required
+                  ? undefined
+                  : ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+                e.type,
+              );
+            const description: string | null =
+              e.parameter.description ??
+              route.jsDocTags
+                ?.find(
+                  (tag) =>
+                    tag.name === "param" &&
+                    tag.text?.[0]?.kind === "parameterName" &&
+                    tag.text?.[0]?.text === e.key,
+                )
+                ?.text?.find((t) => t.kind === "text")?.text ??
+              null;
+            return description?.length
+              ? [
+                  ts.factory.createIdentifier("\n") as any,
+                  FilePrinter.description(signature, description),
+                ]
+              : [signature];
+          })
+          .flat(),
+      );
+
+  export const websocketProps = (route: ITypedWebSocketRoute): ts.TypeNode =>
+    ts.factory.createTypeLiteralNode([
+      ...route.pathParameters.map((p) =>
+        ts.factory.createPropertySignature(
+          undefined,
+          p.name,
+          undefined,
+          SdkAliasCollection.name(p),
+        ),
+      ),
+      ...(route.query
+        ? [
             ts.factory.createPropertySignature(
               undefined,
-              param.name,
-              param.metadata.isRequired() === false
-                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                : undefined,
-              param.category === "body"
-                ? ts.factory.createTypeReferenceNode("Body")
-                : param.category === "query" && param.field === null
-                  ? ts.factory.createTypeReferenceNode("Query")
-                  : SdkTypeProgrammer.write(project)(importer)(param.metadata),
+              "query",
+              undefined,
+              ts.factory.createTypeReferenceNode("Query"),
             ),
-          ),
-      );
+          ]
+        : []),
+      ts.factory.createPropertySignature(
+        undefined,
+        "provider",
+        undefined,
+        ts.factory.createTypeReferenceNode("Provider"),
+      ),
+    ]);
 
   export const headers =
     (project: INestiaProject) =>

package/src/generates/internal/SdkFileProgrammer.ts

@@ -86,7 +86,7 @@ export namespace SdkFileProgrammer {
         statements.push(
           ...(route.protocol === "http"
             ? SdkHttpRouteProgrammer.write(project)(importer)(route)
-            : SdkWebSocketRouteProgrammer.write(importer)(route)),
+            : SdkWebSocketRouteProgrammer.write(project)(importer)(route)),
         );
         if (i !== directory.routes.length - 1)
           statements.push(FilePrinter.enter());

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -30,14 +30,14 @@ export namespace SdkHttpCloneProgrammer {
         prepare({
           dict,
           name: k,
-          programmer: (importer) => write_object(app.project)(importer)(v),
+          programmer: (importer) => writeObject(app.project)(importer)(v),
         });
     for (const [k, v] of app.collection.aliases.entries())
       if (StringUtil.isImplicit(k) === false)
         prepare({
           dict,
           name: k,
-          programmer: (importer) => write_alias(app.project)(importer)(v),
+          programmer: (importer) => writeAlias(app.project)(importer)(v),
         });
     return dict;
   };
@@ -64,7 +64,7 @@ export namespace SdkHttpCloneProgrammer {
     return modulo!;
   };
 
-  const write_alias =
+  const writeAlias =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (alias: MetadataAliasType): ts.TypeAliasDeclaration =>
@@ -78,7 +78,7 @@ export namespace SdkHttpCloneProgrammer {
         writeComment([])(alias.description, alias.jsDocTags),
       );
 
-  const write_object =
+  const writeObject =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (object: MetadataObjectType): ts.TypeAliasDeclaration => {

package/src/generates/internal/SdkHttpCloneReferencer.ts

@@ -4,6 +4,7 @@ import { IReflectType } from "../../structures/IReflectType";
 import { ITypedApplication } from "../../structures/ITypedApplication";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
 import { StringUtil } from "../../utils/StringUtil";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 
 export namespace SdkHttpCloneReferencer {
   export const replace = (app: ITypedApplication): void => {
@@ -21,7 +22,10 @@ export namespace SdkHttpCloneReferencer {
     route: ITypedHttpRoute;
   }): void => {
     const unique: Set<string> = new Set();
-    for (const p of props.route.parameters)
+    for (const p of SdkHttpParameterProgrammer.getSignificant(
+      props.route,
+      true,
+    ))
       visitType({
         unique,
         metadata: p.metadata,

package/src/generates/internal/SdkHttpFunctionProgrammer.ts

@@ -4,25 +4,18 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
 import { StringUtil } from "../../utils/StringUtil";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkImportWizard } from "./SdkImportWizard";
 
 export namespace SdkHttpFunctionProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      props: {
-        headers: ITypedHttpRouteParameter.IHeaders | undefined;
-        query: ITypedHttpRouteParameter.IQuery | undefined;
-        body: ITypedHttpRouteParameter.IBody | undefined;
-      },
-    ): ts.FunctionDeclaration =>
-      ts.factory.createFunctionDeclaration(
+    (route: ITypedHttpRoute): ts.FunctionDeclaration => {
+      return ts.factory.createFunctionDeclaration(
         [
           ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
           ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
@@ -35,67 +28,34 @@ export namespace SdkHttpFunctionProgrammer {
             "connection",
             ts.factory.createTypeReferenceNode(
               SdkImportWizard.IConnection(importer),
-              props.headers
+              route.headerObject !== null
                 ? [ts.factory.createTypeReferenceNode(`${route.name}.Headers`)]
                 : undefined,
             ),
           ),
-          ...(project.config.keyword === true &&
-          route.parameters.filter((p) => p.category !== "headers").length !== 0
-            ? [
-                ts.factory.createParameterDeclaration(
-                  [],
-                  undefined,
-                  "props",
-                  undefined,
-                  ts.factory.createTypeReferenceNode(`${route.name}.IProps`),
-                ),
-              ]
-            : route.parameters
-                .filter((p) => p.category !== "headers")
-                .map((p) =>
-                  ts.factory.createParameterDeclaration(
-                    [],
-                    undefined,
-                    p.name,
-                    p.metadata.optional === true
-                      ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-                      : undefined,
-                    project.config.primitive !== false &&
-                      (p === props.query || p === props.body)
-                      ? ts.factory.createTypeReferenceNode(
-                          `${route.name}.${p === props.query ? "Query" : "Body"}`,
-                        )
-                      : project.config.clone === true
-                        ? SdkAliasCollection.from(project)(importer)(p.metadata)
-                        : SdkAliasCollection.name(p),
-                  ),
-                )),
+          ...SdkHttpParameterProgrammer.getParameterDeclarations({
+            project,
+            importer,
+            route,
+            body: true,
+            prefix: true,
+          }),
         ],
         ts.factory.createTypeReferenceNode("Promise", [
           project.config.propagate === true ||
           route.success.metadata.size() !== 0
-            ? ts.factory.createTypeReferenceNode(`${route.name}.Response`)
+            ? ts.factory.createTypeReferenceNode(`${route.name}.Output`)
             : ts.factory.createTypeReferenceNode("void"),
         ]),
-        ts.factory.createBlock(
-          writeBody(project)(importer)(route, props),
-          true,
-        ),
+        ts.factory.createBlock(writeBody(project)(importer)(route), true),
       );
+    };
 
   const writeBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (
-      route: ITypedHttpRoute,
-      props: {
-        headers: ITypedHttpRouteParameter.IHeaders | undefined;
-        query: ITypedHttpRouteParameter.IQuery | undefined;
-        body: ITypedHttpRouteParameter.IBody | undefined;
-      },
-    ): ts.Statement[] => {
-      const property = (name: string): ts.Expression =>
+    (route: ITypedHttpRoute): ts.Statement[] => {
+      const access = (name: string): ts.Expression =>
         project.config.keyword === true
           ? IdentifierFactory.access(ts.factory.createIdentifier("props"), name)
           : ts.factory.createIdentifier(name);
@@ -104,7 +64,7 @@ export namespace SdkHttpFunctionProgrammer {
           IdentifierFactory.access(
             ts.factory.createIdentifier(
               SdkImportWizard.Fetcher(
-                !!props.body?.encrypted || route.success.encrypted,
+                !!route.body?.encrypted || route.success.encrypted,
               )(importer),
             ),
             project.config.propagate ? "propagate" : "fetch",
@@ -116,7 +76,7 @@ export namespace SdkHttpFunctionProgrammer {
               : [TypeFactory.keyword("any"), TypeFactory.keyword("any")]
             : undefined,
           [
-            props.body && props.body.contentType !== "multipart/form-data"
+            route.body && route.body.contentType !== "multipart/form-data"
               ? ts.factory.createObjectLiteralExpression(
                   [
                     ts.factory.createSpreadAssignment(
@@ -135,7 +95,7 @@ export namespace SdkHttpFunctionProgrammer {
                           ts.factory.createPropertyAssignment(
                             ts.factory.createStringLiteral("Content-Type"),
                             ts.factory.createStringLiteral(
-                              props.body?.contentType ?? "application/json",
+                              route.body?.contentType ?? "application/json",
                             ),
                           ),
                         ],
@@ -172,17 +132,21 @@ export namespace SdkHttpFunctionProgrammer {
                       "path",
                     ),
                     undefined,
-                    getArguments(project, route, false),
+                    SdkHttpParameterProgrammer.getArguments({
+                      project,
+                      route,
+                      body: false,
+                    }),
                   ),
                 ),
               ],
               true,
             ),
-            ...(props.body ? [property(props.body.name)] : []),
+            ...(route.body ? [access(route.body.name)] : []),
             ...(project.config.json &&
-            props.body !== undefined &&
-            (props.body.contentType === "application/json" ||
-              props.body.encrypted === true)
+            route.body !== null &&
+            (route.body.contentType === "application/json" ||
+              route.body.encrypted === true)
               ? [ts.factory.createIdentifier(`${route.name}.stringify`)]
               : []),
           ],
@@ -197,7 +161,11 @@ export namespace SdkHttpFunctionProgrammer {
                 [],
                 [
                   ts.factory.createIdentifier("connection"),
-                  ...getArguments(project, route, true),
+                  ...SdkHttpParameterProgrammer.getArguments({
+                    project,
+                    route,
+                    body: true,
+                  }),
                 ],
               ),
               undefined,
@@ -208,26 +176,24 @@ export namespace SdkHttpFunctionProgrammer {
             : fetch();
       return [
         ...(project.config.assert
-          ? route.parameters
-              .filter((p) => p.category !== "headers")
-              .map((p) =>
-                ts.factory.createExpressionStatement(
-                  ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                      ts.factory.createIdentifier(
-                        SdkImportWizard.typia(importer),
-                      ),
-                      "assert",
+          ? SdkHttpParameterProgrammer.getSignificant(route, true).map((p) =>
+              ts.factory.createExpressionStatement(
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(
+                    ts.factory.createIdentifier(
+                      SdkImportWizard.typia(importer),
                     ),
-                    [
-                      ts.factory.createTypeQueryNode(
-                        ts.factory.createIdentifier(p.name),
-                      ),
-                    ],
-                    [ts.factory.createIdentifier(p.name)],
+                    "assert",
                   ),
+                  [
+                    ts.factory.createTypeQueryNode(
+                      ts.factory.createIdentifier(p.name),
+                    ),
+                  ],
+                  [ts.factory.createIdentifier(p.name)],
                 ),
-              )
+              ),
+            )
           : []),
         ...(route.success.setHeaders.length === 0
           ? [ts.factory.createReturnStatement(output(false))]
@@ -244,7 +210,9 @@ export namespace SdkHttpFunctionProgrammer {
         x[0] === "[" ? `${x}${y}` : `${x}.${y}`;
       const output: string = StringUtil.escapeDuplicate([
         "connection",
-        ...route.parameters.map((p) => p.name),
+        ...SdkHttpParameterProgrammer.getSignificant(route, true).map(
+          (p) => p.name,
+        ),
       ])("output");
       const headers: string = accessor("connection")("headers");
       const data: string = project.config.propagate
@@ -305,21 +273,4 @@ export namespace SdkHttpFunctionProgrammer {
         ts.factory.createReturnStatement(ts.factory.createIdentifier(output)),
       ];
     };
-
-  const getArguments = (
-    project: INestiaProject,
-    route: ITypedHttpRoute,
-    body: boolean,
-  ): ts.Expression[] => {
-    const parameters = route.parameters.filter(
-      (p) =>
-        p.category === "param" ||
-        p.category === "query" ||
-        (body === true && p.category === "body"),
-    );
-    if (parameters.length === 0) return [];
-    else if (project.config.keyword === true)
-      return [ts.factory.createIdentifier("props")];
-    return parameters.map((p) => ts.factory.createIdentifier(p.name));
-  };
 }