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

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -2,22 +2,24 @@ import ts from "typescript";
 import { IJsDocTagInfo } from "typia";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
+import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
-import { SdkAliasCollection } from "./SdkAliasCollection";
 import { SdkImportWizard } from "./SdkImportWizard";
 import { SdkWebSocketNamespaceProgrammer } from "./SdkWebSocketNamespaceProgrammer";
+import { SdkWebSocketParameterProgrammer } from "./SdkWebSocketParameterProgrammer";
 
 export namespace SdkWebSocketRouteProgrammer {
   export const write =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedWebSocketRoute): ts.Statement[] => [
       FilePrinter.description(
-        writeFunction(importer)(route),
+        writeFunction(project)(importer)(route),
         writeDescription(route),
       ),
-      SdkWebSocketNamespaceProgrammer.write(importer)(route),
+      SdkWebSocketNamespaceProgrammer.write(project)(importer)(route),
     ];
 
   const writeDescription = (route: ITypedWebSocketRoute): string => {
@@ -30,7 +32,7 @@ export namespace SdkWebSocketRouteProgrammer {
     const tags: IJsDocTagInfo[] = route.jsDocTags.filter(
       (tag) =>
         tag.name !== "param" ||
-        route.parameters
+        [...route.pathParameters, ...(route.query ? [route.query] : [])]
           .filter((p) => p.category === "param" || p.category === "query")
           .some((p) => p.name === tag.text?.[0]?.text),
     );
@@ -54,9 +56,10 @@ export namespace SdkWebSocketRouteProgrammer {
   };
 
   const writeFunction =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.FunctionDeclaration =>
-      ts.factory.createFunctionDeclaration(
+    (route: ITypedWebSocketRoute): ts.FunctionDeclaration => {
+      return ts.factory.createFunctionDeclaration(
         [
           ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
           ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
@@ -72,125 +75,136 @@ export namespace SdkWebSocketRouteProgrammer {
               [ts.factory.createTypeReferenceNode(`${route.name}.Header`)],
             ),
           ),
-          ...route.parameters
-            .filter((p) => p.category === "param" || p.category === "query")
-            .map((p) =>
-              IdentifierFactory.parameter(
-                p.name,
-                p.category === "param"
-                  ? SdkAliasCollection.name(p)
-                  : ts.factory.createTypeReferenceNode(`${route.name}.Query`),
-              ),
-            ),
-          IdentifierFactory.parameter(
-            "provider",
-            ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
-          ),
+          ...SdkWebSocketParameterProgrammer.getParameterDeclarations({
+            project,
+            route,
+            provider: true,
+            prefix: true,
+          }),
         ],
         ts.factory.createTypeReferenceNode("Promise", [
-          ts.factory.createTypeReferenceNode(`${route.name}.Response`),
+          ts.factory.createTypeReferenceNode(`${route.name}.Output`),
         ]),
-        ts.factory.createBlock(writeFunctionBody(importer)(route), true),
+        ts.factory.createBlock(
+          writeFunctionBody(project)(importer)(route),
+          true,
+        ),
       );
+    };
 
   const writeFunctionBody =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.Statement[] => [
-      local("connector")(
-        ts.factory.createTypeReferenceNode(
-          importer.external({
-            type: false,
-            library: "tgrid",
-            instance: "WebSocketConnector",
-          }),
-          [
-            ts.factory.createTypeReferenceNode(`${route.name}.Header`),
-            ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
-            ts.factory.createTypeReferenceNode(`${route.name}.Listener`),
-          ],
-        ),
-      )(
-        ts.factory.createNewExpression(
-          ts.factory.createIdentifier(
+    (route: ITypedWebSocketRoute): ts.Statement[] => {
+      const access = (key: string) =>
+        project.config.keyword === true
+          ? ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("props"),
+              key,
+            )
+          : ts.factory.createIdentifier(key);
+      return [
+        local("connector")(
+          ts.factory.createTypeReferenceNode(
             importer.external({
               type: false,
               library: "tgrid",
               instance: "WebSocketConnector",
             }),
+            [
+              ts.factory.createTypeReferenceNode(`${route.name}.Header`),
+              ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
+              ts.factory.createTypeReferenceNode(`${route.name}.Listener`),
+            ],
           ),
-          undefined,
-          [
-            ts.factory.createAsExpression(
-              ts.factory.createBinaryExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("connection"),
-                  "headers",
-                ),
-                ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                ts.factory.createObjectLiteralExpression([], false),
-              ),
-              ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
-            ),
-            ts.factory.createIdentifier("provider"),
-          ],
-        ),
-      ),
-      ts.factory.createExpressionStatement(
-        ts.factory.createAwaitExpression(
-          ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("connector"),
-              "connect",
+        )(
+          ts.factory.createNewExpression(
+            ts.factory.createIdentifier(
+              importer.external({
+                type: false,
+                library: "tgrid",
+                instance: "WebSocketConnector",
+              }),
             ),
             undefined,
             [
-              joinPath(
-                ts.factory.createCallExpression(
+              ts.factory.createAsExpression(
+                ts.factory.createBinaryExpression(
                   ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier(route.name),
-                    "path",
+                    ts.factory.createIdentifier("connection"),
+                    "headers",
                   ),
-                  [],
-                  route.parameters
-                    .filter(
-                      (p) => p.category === "param" || p.category === "query",
-                    )
-                    .map((x) => ts.factory.createIdentifier(x.name)),
+                  ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+                  ts.factory.createObjectLiteralExpression([], false),
                 ),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
               ),
+              access("provider"),
             ],
           ),
         ),
-      ),
-      local("driver")(
-        ts.factory.createTypeReferenceNode(
-          importer.external({
-            type: true,
-            library: "tgrid",
-            instance: "Driver",
-          }),
-          [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
+        ts.factory.createExpressionStatement(
+          ts.factory.createAwaitExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier("connector"),
+                "connect",
+              ),
+              undefined,
+              [
+                joinPath(
+                  ts.factory.createCallExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier(route.name),
+                      "path",
+                    ),
+                    [],
+                    project.config.keyword === true &&
+                      SdkWebSocketParameterProgrammer.isPathEmpty(route) ===
+                        false
+                      ? [ts.factory.createIdentifier("props")]
+                      : SdkWebSocketParameterProgrammer.getEntries({
+                          project,
+                          route,
+                          provider: false,
+                          prefix: true,
+                        }).map((p) => ts.factory.createIdentifier(p.key)),
+                  ),
+                ),
+              ],
+            ),
+          ),
         ),
-      )(
-        ts.factory.createCallExpression(
-          ts.factory.createPropertyAccessExpression(
-            ts.factory.createIdentifier("connector"),
-            "getDriver",
+        local("driver")(
+          ts.factory.createTypeReferenceNode(
+            importer.external({
+              type: true,
+              library: "tgrid",
+              instance: "Driver",
+            }),
+            [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
+          ),
+        )(
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("connector"),
+              "getDriver",
+            ),
+            undefined,
+            undefined,
           ),
-          undefined,
-          undefined,
         ),
-      ),
-      ts.factory.createReturnStatement(
-        ts.factory.createObjectLiteralExpression(
-          [
-            ts.factory.createShorthandPropertyAssignment("connector"),
-            ts.factory.createShorthandPropertyAssignment("driver"),
-          ],
-          true,
+        ts.factory.createReturnStatement(
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createShorthandPropertyAssignment("connector"),
+              ts.factory.createShorthandPropertyAssignment("driver"),
+            ],
+            true,
+          ),
         ),
-      ),
-    ];
+      ];
+    };
 }
 
 const local =

package/src/generates/internal/SwaggerOperationComposer.ts

@@ -4,7 +4,6 @@ import { Metadata } from "typia/lib/schemas/metadata/Metadata";
 import { INestiaConfig } from "../../INestiaConfig";
 import { SecurityAnalyzer } from "../../analyses/SecurityAnalyzer";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { ITypedHttpRouteParameter } from "../../structures/ITypedHttpRouteParameter";
 import { SwaggerDescriptionComposer } from "./SwaggerDescriptionComposer";
 import { SwaggerOperationParameterComposer } from "./SwaggerOperationParameterComposer";
 import { SwaggerOperationResponseComposer } from "./SwaggerOperationResponseComposer";
@@ -16,10 +15,6 @@ export namespace SwaggerOperationComposer {
     schema: (metadata: Metadata) => OpenApi.IJsonSchema | undefined;
     route: ITypedHttpRoute;
   }): OpenApi.IOperation => {
-    // FIND REQUEST BODY
-    const body: ITypedHttpRouteParameter.IBody | undefined =
-      props.route.parameters.find((param) => param.category === "body");
-
     // COMPOSE TAGS
     const tags: Set<string> = new Set([
       ...props.route.controller.tags,
@@ -88,7 +83,12 @@ export namespace SwaggerOperationComposer {
           method: props.route.method as "GET",
           path: props.route.path,
         }),
-      parameters: props.route.parameters
+      parameters: [
+        ...props.route.pathParameters,
+        ...props.route.queryParameters,
+        ...(props.route.queryObject ? [props.route.queryObject] : []),
+        ...(props.route.headerObject ? [props.route.headerObject] : []),
+      ]
         .map((p) =>
           SwaggerOperationParameterComposer.compose({
             config: props.config,
@@ -99,11 +99,11 @@ export namespace SwaggerOperationComposer {
           }),
         )
         .flat(),
-      requestBody: body
+      requestBody: props.route.body
         ? SwaggerOperationParameterComposer.body({
-            schema: props.schema(body.metadata)!,
+            schema: props.schema(props.route.body.metadata)!,
             jsDocTags: props.route.jsDocTags,
-            parameter: body,
+            parameter: props.route.body,
           })
         : undefined,
       responses: SwaggerOperationResponseComposer.compose({

package/src/generates/internal/SwaggerOperationParameterComposer.ts

@@ -53,7 +53,7 @@ export namespace SwaggerOperationParameterComposer {
   };
 
   export const path = (
-    props: Omit<IProps<ITypedHttpRouteParameter.IParam>, "config" | "document">,
+    props: Omit<IProps<ITypedHttpRouteParameter.IPath>, "config" | "document">,
   ): OpenApi.IOperation.IParameter => ({
     name: props.parameter.field,
     in: "path",

package/src/structures/ITypedHttpRoute.ts

@@ -14,12 +14,23 @@ export interface ITypedHttpRoute {
   method: string;
   path: string;
   accessor: string[];
-  parameters: ITypedHttpRouteParameter[];
+
+  // PARAMETERS
+  pathParameters: ITypedHttpRouteParameter.IPath[];
+  queryParameters: ITypedHttpRouteParameter.IQuery[];
+  headerParameters: ITypedHttpRouteParameter.IHeaders[];
+  queryObject: ITypedHttpRouteParameter.IQuery | null;
+  headerObject: ITypedHttpRouteParameter.IHeaders | null;
+  body: ITypedHttpRouteParameter.IBody | null;
+
+  // RESPONSES
   success: ITypedHttpRouteSuccess;
   exceptions: Record<
     number | "2XX" | "3XX" | "4XX" | "5XX",
     ITypedHttpRouteException
   >;
+
+  // ADDITIONAL INFORMATION
   security: Record<string, string[]>[];
   tags: string[];
   imports: IReflectTypeImport[];

package/src/structures/ITypedHttpRouteParameter.ts

@@ -6,7 +6,7 @@ import { IReflectType } from "./IReflectType";
 export type ITypedHttpRouteParameter =
   | ITypedHttpRouteParameter.IBody
   | ITypedHttpRouteParameter.IHeaders
-  | ITypedHttpRouteParameter.IParam
+  | ITypedHttpRouteParameter.IPath
   | ITypedHttpRouteParameter.IQuery;
 export namespace ITypedHttpRouteParameter {
   export interface IBody extends IBase<"body"> {
@@ -20,7 +20,7 @@ export namespace ITypedHttpRouteParameter {
   export interface IHeaders extends IBase<"headers"> {
     field: string | null;
   }
-  export interface IParam extends IBase<"param"> {
+  export interface IPath extends IBase<"param"> {
     field: string;
   }
   export interface IQuery extends IBase<"query"> {

package/src/structures/ITypedWebSocketRoute.ts

@@ -13,7 +13,11 @@ export interface ITypedWebSocketRoute {
   accessor: string[];
   function: Function;
   versions: Array<string | typeof VERSION_NEUTRAL> | undefined;
-  parameters: ITypedWebSocketRouteParameter[];
+  acceptor: ITypedWebSocketRouteParameter.IAcceptor;
+  header: ITypedWebSocketRouteParameter.IHeader | null;
+  pathParameters: ITypedWebSocketRouteParameter.IParam[];
+  query: ITypedWebSocketRouteParameter.IQuery | null;
+  driver: ITypedWebSocketRouteParameter.IDriver | null;
   imports: IReflectTypeImport[];
   description: string | null;
   jsDocTags: ts.JSDocTagInfo[];