@nestia/sdk 7.0.0-dev.20250606 → 7.0.0-dev.20250607

package/src/generates/internal/SdkWebSocketNamespaceProgrammer.ts

@@ -3,28 +3,31 @@ import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
+import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
-import { ITypedWebSocketRouteParameter } from "../../structures/ITypedWebSocketRouteParameter";
 import { FilePrinter } from "./FilePrinter";
 import { ImportDictionary } from "./ImportDictionary";
 import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkWebSocketParameterProgrammer } from "./SdkWebSocketParameterProgrammer";
 
 export namespace SdkWebSocketNamespaceProgrammer {
   export const write =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedWebSocketRoute): ts.ModuleDeclaration =>
       ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier(route.name),
         ts.factory.createModuleBlock([
-          ...writeTypes(importer)(route),
+          ...writeTypes(project)(importer)(route),
           FilePrinter.enter(),
-          writePath(route),
+          writePath(project)(route),
         ]),
         ts.NodeFlags.Namespace,
       );
 
   const writeTypes =
+    (project: INestiaProject) =>
     (importer: ImportDictionary) =>
     (route: ITypedWebSocketRoute): ts.TypeAliasDeclaration[] => {
       const output: ts.TypeAliasDeclaration[] = [];
@@ -38,8 +41,10 @@ export namespace SdkWebSocketNamespaceProgrammer {
           ),
         );
 
+      if (project.config.keyword === true)
+        declare("Props", SdkAliasCollection.websocketProps(route));
       declare(
-        "Response",
+        "Output",
         ts.factory.createTypeLiteralNode([
           ts.factory.createPropertySignature(
             undefined,
@@ -74,260 +79,259 @@ export namespace SdkWebSocketNamespaceProgrammer {
         ]),
       );
 
-      const acceptor: ITypedWebSocketRouteParameter.IAcceptor =
-        route.parameters.find((x) => x.category === "acceptor")!;
-      const query: ITypedWebSocketRouteParameter.IQuery | undefined =
-        route.parameters.find((x) => x.category === "query");
-      const driver: ITypedWebSocketRouteParameter.IDriver | undefined =
-        route.parameters.find((x) => x.category === "driver");
       declare(
         "Header",
         SdkAliasCollection.name({
-          type: (route.parameters.find((x) => x.category === "header")?.type ??
-            acceptor.type.typeArguments?.[0])!,
+          type: (route.header?.type ?? route.acceptor.type.typeArguments?.[0])!,
         }),
       );
       declare(
         "Provider",
         SdkAliasCollection.name({
           type:
-            driver?.type.typeArguments?.[0] ??
-            acceptor.type.typeArguments?.[2]!,
+            route.driver?.type.typeArguments?.[0] ??
+            route.acceptor.type.typeArguments?.[2]!,
         }),
       );
       declare(
         "Listener",
         SdkAliasCollection.name({
-          type: acceptor.type.typeArguments?.[1]!,
+          type: route.acceptor.type.typeArguments?.[1]!,
         }),
       );
-      if (query) declare("Query", SdkAliasCollection.name(query));
+      if (route.query) declare("Query", SdkAliasCollection.name(route.query));
       return output;
     };
 
-  const writePath = (route: ITypedWebSocketRoute): ts.VariableStatement => {
-    const pathParams: ITypedWebSocketRouteParameter.IParam[] =
-      route.parameters.filter(
-        (p) => p.category === "param",
-      ) as ITypedWebSocketRouteParameter.IParam[];
-    const query: ITypedWebSocketRouteParameter.IQuery | undefined =
-      route.parameters.find((p) => p.category === "query");
-    const total: Array<
-      | ITypedWebSocketRouteParameter.IParam
-      | ITypedWebSocketRouteParameter.IQuery
-    > = [...pathParams, ...(query ? [query] : [])];
-    const out = (body: ts.ConciseBody) =>
-      constant("path")(
-        ts.factory.createArrowFunction(
-          [],
-          [],
-          total.map((p) =>
-            IdentifierFactory.parameter(
-              p.name,
-              p === query
-                ? ts.factory.createTypeReferenceNode(`${route.name}.Query`)
-                : SdkAliasCollection.name(p),
-            ),
+  const writePath =
+    (project: INestiaProject) =>
+    (route: ITypedWebSocketRoute): ts.VariableStatement => {
+      const out = (body: ts.ConciseBody) =>
+        constant("path")(
+          ts.factory.createArrowFunction(
+            [],
+            [],
+            SdkWebSocketParameterProgrammer.getParameterDeclarations({
+              project,
+              route,
+              provider: false,
+              prefix: false,
+            }),
+            undefined,
+            undefined,
+            body,
           ),
-          undefined,
-          undefined,
-          body,
-        ),
-      );
-    if (total.length === 0)
-      return out(ts.factory.createStringLiteral(route.path));
+        );
+      if (route.pathParameters.length === 0 && route.query === null)
+        return out(ts.factory.createStringLiteral(route.path));
 
-    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]),
-        split.slice(1).map((s, i, arr) => {
-          const name: string = s.split("/")[0];
-          return ts.factory.createTemplateSpan(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("encodeURIComponent"),
-              undefined,
-              [
-                ts.factory.createBinaryExpression(
-                  ts.factory.createCallChain(
-                    ts.factory.createPropertyAccessChain(
-                      ts.factory.createIdentifier(
-                        pathParams.find((p) => p.field === name)!.name,
+      const access = (key: string) =>
+        project.config.keyword === true
+          ? ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("props"),
+              key,
+            )
+          : ts.factory.createIdentifier(key);
+      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]),
+          split.slice(1).map((s, i, arr) => {
+            const name: string = s.split("/")[0];
+            return ts.factory.createTemplateSpan(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("encodeURIComponent"),
+                undefined,
+                [
+                  ts.factory.createBinaryExpression(
+                    ts.factory.createCallChain(
+                      ts.factory.createPropertyAccessChain(
+                        access(
+                          route.pathParameters.find((p) => p.field === name)!
+                            .name,
+                        ),
+                        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                        "toString",
                       ),
-                      ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                      "toString",
-                    ),
-                    undefined,
-                    undefined,
-                    [],
-                  ),
-                  ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                  ts.factory.createStringLiteral("null"),
-                ),
-              ],
-            ),
-            (i !== arr.length - 1
-              ? ts.factory.createTemplateMiddle
-              : ts.factory.createTemplateTail)(s.substring(name.length)),
-          );
-        }),
-      );
-    };
-    if (query === undefined) return out(template());
-
-    const block = (expr: ts.Expression) => {
-      const computeName = (str: string): string =>
-        total.find((p) => p.name === str) !== undefined
-          ? computeName("_" + str)
-          : str;
-      const variables: string = computeName("variables");
-      return ts.factory.createBlock(
-        [
-          local(variables)("URLSearchParams")(
-            ts.factory.createNewExpression(
-              ts.factory.createIdentifier("URLSearchParams"),
-              [],
-              [],
-            ),
-          ),
-          ts.factory.createForOfStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-              [
-                ts.factory.createVariableDeclaration(
-                  ts.factory.createArrayBindingPattern([
-                    ts.factory.createBindingElement(
-                      undefined,
                       undefined,
-                      ts.factory.createIdentifier("key"),
                       undefined,
+                      [],
                     ),
-                    ts.factory.createBindingElement(
-                      undefined,
-                      undefined,
-                      ts.factory.createIdentifier("value"),
-                      undefined,
-                    ),
-                  ]),
-                  undefined,
-                  undefined,
-                  undefined,
-                ),
-              ],
-              ts.NodeFlags.Const,
+                    ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+                    ts.factory.createStringLiteral("null"),
+                  ),
+                ],
+              ),
+              (i !== arr.length - 1
+                ? ts.factory.createTemplateMiddle
+                : ts.factory.createTemplateTail)(s.substring(name.length)),
+            );
+          }),
+        );
+      };
+      if (route.query === null) return out(template());
+
+      const block = (expr: ts.Expression) => {
+        const computeName = (str: string): string =>
+          [...route.pathParameters, ...(route.query ? [route.query] : [])].find(
+            (p) => p.name === str,
+          ) !== undefined
+            ? computeName("_" + str)
+            : str;
+        const variables: string = computeName("variables");
+        return ts.factory.createBlock(
+          [
+            local(variables)("URLSearchParams")(
+              ts.factory.createNewExpression(
+                ts.factory.createIdentifier("URLSearchParams"),
+                [],
+                [],
+              ),
             ),
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Object.entries"),
+            ts.factory.createForOfStatement(
               undefined,
-              [ts.factory.createAsExpression(expr, TypeFactory.keyword("any"))],
-            ),
-            ts.factory.createIfStatement(
-              ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                ts.factory.createIdentifier("value"),
-              ),
-              ts.factory.createContinueStatement(),
-              ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("Array.isArray"),
-                  undefined,
-                  [ts.factory.createIdentifier("value")],
-                ),
-                ts.factory.createExpressionStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("value"),
-                      ts.factory.createIdentifier("forEach"),
-                    ),
-                    undefined,
-                    [
-                      ts.factory.createArrowFunction(
+              ts.factory.createVariableDeclarationList(
+                [
+                  ts.factory.createVariableDeclaration(
+                    ts.factory.createArrayBindingPattern([
+                      ts.factory.createBindingElement(
+                        undefined,
                         undefined,
+                        ts.factory.createIdentifier("key"),
                         undefined,
-                        [IdentifierFactory.parameter("elem")],
+                      ),
+                      ts.factory.createBindingElement(
                         undefined,
                         undefined,
-                        ts.factory.createCallExpression(
-                          IdentifierFactory.access(
-                            ts.factory.createIdentifier(variables),
-                            "append",
-                          ),
-                          undefined,
-                          [
-                            ts.factory.createIdentifier("key"),
-                            ts.factory.createCallExpression(
-                              ts.factory.createIdentifier("String"),
-                              undefined,
-                              [ts.factory.createIdentifier("elem")],
-                            ),
-                          ],
-                        ),
+                        ts.factory.createIdentifier("value"),
+                        undefined,
                       ),
-                    ],
+                    ]),
+                    undefined,
+                    undefined,
+                    undefined,
+                  ),
+                ],
+                ts.NodeFlags.Const,
+              ),
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("Object.entries"),
+                undefined,
+                [
+                  ts.factory.createAsExpression(
+                    expr,
+                    TypeFactory.keyword("any"),
                   ),
+                ],
+              ),
+              ts.factory.createIfStatement(
+                ts.factory.createStrictEquality(
+                  ts.factory.createIdentifier("undefined"),
+                  ts.factory.createIdentifier("value"),
                 ),
-                ts.factory.createExpressionStatement(
+                ts.factory.createContinueStatement(),
+                ts.factory.createIfStatement(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                      ts.factory.createIdentifier(variables),
-                      "set",
-                    ),
+                    ts.factory.createIdentifier("Array.isArray"),
                     undefined,
-                    [
-                      ts.factory.createIdentifier("key"),
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("String"),
-                        undefined,
-                        [ts.factory.createIdentifier("value")],
-                      ),
-                    ],
+                    [ts.factory.createIdentifier("value")],
                   ),
-                ),
-              ),
-            ),
-          ),
-          local("location")("string")(template()),
-          ts.factory.createReturnStatement(
-            ts.factory.createConditionalExpression(
-              ts.factory.createStrictEquality(
-                ExpressionFactory.number(0),
-                IdentifierFactory.access(
-                  ts.factory.createIdentifier(variables),
-                  "size",
-                ),
-              ),
-              undefined,
-              ts.factory.createIdentifier("location"),
-              undefined,
-              ts.factory.createTemplateExpression(
-                ts.factory.createTemplateHead(""),
-                [
-                  ts.factory.createTemplateSpan(
-                    ts.factory.createIdentifier("location"),
-                    ts.factory.createTemplateMiddle("?"),
+                  ts.factory.createExpressionStatement(
+                    ts.factory.createCallExpression(
+                      ts.factory.createPropertyAccessExpression(
+                        ts.factory.createIdentifier("value"),
+                        ts.factory.createIdentifier("forEach"),
+                      ),
+                      undefined,
+                      [
+                        ts.factory.createArrowFunction(
+                          undefined,
+                          undefined,
+                          [IdentifierFactory.parameter("elem")],
+                          undefined,
+                          undefined,
+                          ts.factory.createCallExpression(
+                            IdentifierFactory.access(
+                              ts.factory.createIdentifier(variables),
+                              "append",
+                            ),
+                            undefined,
+                            [
+                              ts.factory.createIdentifier("key"),
+                              ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("String"),
+                                undefined,
+                                [ts.factory.createIdentifier("elem")],
+                              ),
+                            ],
+                          ),
+                        ),
+                      ],
+                    ),
                   ),
-                  ts.factory.createTemplateSpan(
+                  ts.factory.createExpressionStatement(
                     ts.factory.createCallExpression(
                       IdentifierFactory.access(
                         ts.factory.createIdentifier(variables),
-                        "toString",
+                        "set",
                       ),
                       undefined,
-                      undefined,
+                      [
+                        ts.factory.createIdentifier("key"),
+                        ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("String"),
+                          undefined,
+                          [ts.factory.createIdentifier("value")],
+                        ),
+                      ],
                     ),
-                    ts.factory.createTemplateTail(""),
                   ),
-                ],
+                ),
               ),
             ),
-          ),
-        ],
-        true,
-      );
+            local("location")("string")(template()),
+            ts.factory.createReturnStatement(
+              ts.factory.createConditionalExpression(
+                ts.factory.createStrictEquality(
+                  ExpressionFactory.number(0),
+                  IdentifierFactory.access(
+                    ts.factory.createIdentifier(variables),
+                    "size",
+                  ),
+                ),
+                undefined,
+                ts.factory.createIdentifier("location"),
+                undefined,
+                ts.factory.createTemplateExpression(
+                  ts.factory.createTemplateHead(""),
+                  [
+                    ts.factory.createTemplateSpan(
+                      ts.factory.createIdentifier("location"),
+                      ts.factory.createTemplateMiddle("?"),
+                    ),
+                    ts.factory.createTemplateSpan(
+                      ts.factory.createCallExpression(
+                        IdentifierFactory.access(
+                          ts.factory.createIdentifier(variables),
+                          "toString",
+                        ),
+                        undefined,
+                        undefined,
+                      ),
+                      ts.factory.createTemplateTail(""),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ],
+          true,
+        );
+      };
+      return out(block(access(route.query.name)));
     };
-    return out(block(ts.factory.createIdentifier(query.name)));
-  };
 }
 
 const local = (name: string) => (type: string) => (expression: ts.Expression) =>

package/src/generates/internal/SdkWebSocketParameterProgrammer.ts

@@ -0,0 +1,87 @@
+import ts from "typescript";
+
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+import { SdkAliasCollection } from "./SdkAliasCollection";
+
+export namespace SdkWebSocketParameterProgrammer {
+  export interface IEntry {
+    key: string;
+    type: ts.TypeNode;
+  }
+
+  export const getEntries = (props: {
+    project: INestiaProject;
+    route: ITypedWebSocketRoute;
+    provider: boolean;
+    prefix: boolean;
+  }): IEntry[] => {
+    const prefix: string = props.prefix ? `${props.route.name}.` : "";
+    return [
+      ...props.route.pathParameters.map((p) => ({
+        key: p.name,
+        type: SdkAliasCollection.name(p),
+      })),
+      ...(props.route.query
+        ? [
+            {
+              key: "query",
+              type: ts.factory.createTypeReferenceNode(`${prefix}Query`),
+            },
+          ]
+        : []),
+      ...(props.provider
+        ? [
+            {
+              key: "provider",
+              type: ts.factory.createTypeReferenceNode(`${prefix}Provider`),
+            },
+          ]
+        : []),
+    ];
+  };
+
+  export const getParameterDeclarations = (props: {
+    project: INestiaProject;
+    route: ITypedWebSocketRoute;
+    provider: 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.TypeNode = props.provider
+        ? ts.factory.createTypeReferenceNode(typeName)
+        : ts.factory.createTypeReferenceNode("Omit", [
+            ts.factory.createTypeReferenceNode(typeName),
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("provider"),
+            ),
+          ]);
+      return [
+        ts.factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          "props",
+          undefined,
+          node,
+        ),
+      ];
+    }
+    return entries.map((entry) =>
+      ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        entry.key,
+        undefined,
+        entry.type,
+      ),
+    );
+  };
+
+  export const isPathEmpty = (route: ITypedWebSocketRoute): boolean =>
+    route.pathParameters.length === 0 && route.query === null;
+}