@nestia/sdk 12.0.0-dev.20260601.1 → 12.0.0-dev.20260619.1

package/src/generates/internal/SdkWebSocketNamespaceProgrammer.ts

@@ -1,389 +1,383 @@
-import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
-import { ExpressionFactory, IdentifierFactory, TypeFactory } from "@nestia/factory";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
-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): Node =>
-      TypeScriptFactory.createModuleDeclaration(
-        [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
-        TypeScriptFactory.createIdentifier(route.name),
-        TypeScriptFactory.createModuleBlock([
-          ...writeTypes(project)(importer)(route),
-          FilePrinter.enter(),
-          writePath(project)(route),
-        ]),
-        NodeFlags.Namespace,
-      );
-
-  const writeTypes =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): Node[] => {
-      const output: Node[] = [];
-      const declare = (name: string, type: Node) =>
-        output.push(
-          TypeScriptFactory.createTypeAliasDeclaration(
-            [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
-            name,
-            undefined,
-            type,
-          ),
-        );
-
-      if (project.config.keyword === true)
-        declare("Props", SdkAliasCollection.websocketProps(route));
-      declare(
-        "Output",
-        TypeScriptFactory.createTypeLiteralNode([
-          TypeScriptFactory.createPropertySignature(
-            undefined,
-            "connector",
-            undefined,
-            TypeScriptFactory.createTypeReferenceNode(
-              importer.external({
-                declaration: false,
-                file: "tgrid",
-                type: "element",
-                name: "WebSocketConnector",
-              }),
-              [
-                TypeScriptFactory.createTypeReferenceNode("Header"),
-                TypeScriptFactory.createTypeReferenceNode("Provider"),
-                TypeScriptFactory.createTypeReferenceNode("Listener"),
-              ],
-            ),
-          ),
-          TypeScriptFactory.createPropertySignature(
-            undefined,
-            "driver",
-            undefined,
-            TypeScriptFactory.createTypeReferenceNode(
-              importer.external({
-                declaration: true,
-                file: "tgrid",
-                type: "element",
-                name: "Driver",
-              }),
-              [TypeScriptFactory.createTypeReferenceNode("Listener")],
-            ),
-          ),
-          TypeScriptFactory.createPropertySignature(
-            undefined,
-            "reconnect",
-            undefined,
-            TypeScriptFactory.createFunctionTypeNode(
-              undefined,
-              [],
-              TypeScriptFactory.createTypeReferenceNode(
-                TypeScriptFactory.createIdentifier("Promise"),
-                [
-                  TypeScriptFactory.createKeywordTypeNode(
-                    SyntaxKind.VoidKeyword,
-                  ),
-                ],
-              ),
-            ),
-          ),
-        ]),
-      );
-
-      declare(
-        "Header",
-        SdkAliasCollection.name({
-          type: (route.header?.type ?? route.acceptor.type.typeArguments?.[0])!,
-        }),
-      );
-      declare(
-        "Provider",
-        SdkAliasCollection.name({
-          type:
-            route.driver?.type.typeArguments?.[0] ??
-            route.acceptor.type.typeArguments?.[2]!,
-        }),
-      );
-      declare(
-        "Listener",
-        SdkAliasCollection.name({
-          type: route.acceptor.type.typeArguments?.[1]!,
-        }),
-      );
-      if (route.query) declare("Query", SdkAliasCollection.name(route.query));
-      return output;
-    };
-
-  const writePath =
-    (project: INestiaProject) =>
-    (route: ITypedWebSocketRoute): Node => {
-      const out = (body: Node) =>
-        constant("path")(
-          TypeScriptFactory.createArrowFunction(
-            [],
-            [],
-            SdkWebSocketParameterProgrammer.getParameterDeclarations({
-              project,
-              route,
-              provider: false,
-              prefix: false,
-            }),
-            undefined,
-            undefined,
-            body,
-          ),
-        );
-      if (route.pathParameters.length === 0 && route.query === null)
-        return out(TypeScriptFactory.createStringLiteral(route.path));
-
-      const access = (key: string) =>
-        project.config.keyword === true
-          ? TypeScriptFactory.createPropertyAccessExpression(
-              TypeScriptFactory.createIdentifier("props"),
-              key,
-            )
-          : TypeScriptFactory.createIdentifier(key);
-      const template = () => {
-        const split: string[] = route.path.split(":");
-        if (split.length === 1)
-          return TypeScriptFactory.createStringLiteral(route.path);
-        return TypeScriptFactory.createTemplateExpression(
-          TypeScriptFactory.createTemplateHead(split[0]!),
-          split.slice(1).map((s, i, arr) => {
-            const name: string = s.split("/")[0]!;
-            return TypeScriptFactory.createTemplateSpan(
-              TypeScriptFactory.createCallExpression(
-                TypeScriptFactory.createIdentifier("encodeURIComponent"),
-                undefined,
-                [
-                  TypeScriptFactory.createBinaryExpression(
-                    TypeScriptFactory.createCallChain(
-                      TypeScriptFactory.createPropertyAccessChain(
-                        access(
-                          route.pathParameters.find((p) => p.field === name)!
-                            .name,
-                        ),
-                        TypeScriptFactory.createToken(
-                          SyntaxKind.QuestionDotToken,
-                        ),
-                        "toString",
-                      ),
-                      undefined,
-                      undefined,
-                      [],
-                    ),
-                    TypeScriptFactory.createToken(
-                      SyntaxKind.QuestionQuestionToken,
-                    ),
-                    TypeScriptFactory.createStringLiteral("null"),
-                  ),
-                ],
-              ),
-              (i !== arr.length - 1
-                ? TypeScriptFactory.createTemplateMiddle
-                : TypeScriptFactory.createTemplateTail)(
-                s.substring(name.length),
-              ),
-            );
-          }),
-        );
-      };
-      if (route.query === null) return out(template());
-
-      const block = (expr: Node) => {
-        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 TypeScriptFactory.createBlock(
-          [
-            local(variables)("URLSearchParams")(
-              TypeScriptFactory.createNewExpression(
-                TypeScriptFactory.createIdentifier("URLSearchParams"),
-                [],
-                [],
-              ),
-            ),
-            TypeScriptFactory.createForOfStatement(
-              undefined,
-              TypeScriptFactory.createVariableDeclarationList(
-                [
-                  TypeScriptFactory.createVariableDeclaration(
-                    TypeScriptFactory.createArrayBindingPattern([
-                      TypeScriptFactory.createBindingElement(
-                        undefined,
-                        undefined,
-                        TypeScriptFactory.createIdentifier("key"),
-                        undefined,
-                      ),
-                      TypeScriptFactory.createBindingElement(
-                        undefined,
-                        undefined,
-                        TypeScriptFactory.createIdentifier("value"),
-                        undefined,
-                      ),
-                    ]),
-                    undefined,
-                    undefined,
-                    undefined,
-                  ),
-                ],
-                NodeFlags.Const,
-              ),
-              TypeScriptFactory.createCallExpression(
-                TypeScriptFactory.createIdentifier("Object.entries"),
-                undefined,
-                [
-                  TypeScriptFactory.createAsExpression(
-                    expr,
-                    TypeFactory.keyword("any"),
-                  ),
-                ],
-              ),
-              TypeScriptFactory.createIfStatement(
-                TypeScriptFactory.createStrictEquality(
-                  TypeScriptFactory.createIdentifier("undefined"),
-                  TypeScriptFactory.createIdentifier("value"),
-                ),
-                TypeScriptFactory.createContinueStatement(),
-                TypeScriptFactory.createIfStatement(
-                  TypeScriptFactory.createCallExpression(
-                    TypeScriptFactory.createIdentifier("Array.isArray"),
-                    undefined,
-                    [TypeScriptFactory.createIdentifier("value")],
-                  ),
-                  TypeScriptFactory.createExpressionStatement(
-                    TypeScriptFactory.createCallExpression(
-                      TypeScriptFactory.createPropertyAccessExpression(
-                        TypeScriptFactory.createIdentifier("value"),
-                        TypeScriptFactory.createIdentifier("forEach"),
-                      ),
-                      undefined,
-                      [
-                        TypeScriptFactory.createArrowFunction(
-                          undefined,
-                          undefined,
-                          [IdentifierFactory.parameter("elem")],
-                          undefined,
-                          undefined,
-                          TypeScriptFactory.createCallExpression(
-                            IdentifierFactory.access(
-                              TypeScriptFactory.createIdentifier(variables),
-                              "append",
-                            ),
-                            undefined,
-                            [
-                              TypeScriptFactory.createIdentifier("key"),
-                              TypeScriptFactory.createCallExpression(
-                                TypeScriptFactory.createIdentifier("String"),
-                                undefined,
-                                [TypeScriptFactory.createIdentifier("elem")],
-                              ),
-                            ],
-                          ),
-                        ),
-                      ],
-                    ),
-                  ),
-                  TypeScriptFactory.createExpressionStatement(
-                    TypeScriptFactory.createCallExpression(
-                      IdentifierFactory.access(
-                        TypeScriptFactory.createIdentifier(variables),
-                        "set",
-                      ),
-                      undefined,
-                      [
-                        TypeScriptFactory.createIdentifier("key"),
-                        TypeScriptFactory.createCallExpression(
-                          TypeScriptFactory.createIdentifier("String"),
-                          undefined,
-                          [TypeScriptFactory.createIdentifier("value")],
-                        ),
-                      ],
-                    ),
-                  ),
-                ),
-              ),
-            ),
-            local("location")("string")(template()),
-            TypeScriptFactory.createReturnStatement(
-              TypeScriptFactory.createConditionalExpression(
-                TypeScriptFactory.createStrictEquality(
-                  ExpressionFactory.number(0),
-                  IdentifierFactory.access(
-                    TypeScriptFactory.createIdentifier(variables),
-                    "size",
-                  ),
-                ),
-                undefined,
-                TypeScriptFactory.createIdentifier("location"),
-                undefined,
-                TypeScriptFactory.createTemplateExpression(
-                  TypeScriptFactory.createTemplateHead(""),
-                  [
-                    TypeScriptFactory.createTemplateSpan(
-                      TypeScriptFactory.createIdentifier("location"),
-                      TypeScriptFactory.createTemplateMiddle("?"),
-                    ),
-                    TypeScriptFactory.createTemplateSpan(
-                      TypeScriptFactory.createCallExpression(
-                        IdentifierFactory.access(
-                          TypeScriptFactory.createIdentifier(variables),
-                          "toString",
-                        ),
-                        undefined,
-                        undefined,
-                      ),
-                      TypeScriptFactory.createTemplateTail(""),
-                    ),
-                  ],
-                ),
-              ),
-            ),
-          ],
-          true,
-        );
-      };
-      return out(block(access(route.query.name)));
-    };
-}
-
-const local = (name: string) => (type: string) => (expression: Node) =>
-  TypeScriptFactory.createVariableStatement(
-    [],
-    TypeScriptFactory.createVariableDeclarationList(
-      [
-        TypeScriptFactory.createVariableDeclaration(
-          name,
-          undefined,
-          TypeScriptFactory.createTypeReferenceNode(type),
-          expression,
-        ),
-      ],
-      NodeFlags.Const,
-    ),
-  );
-const constant = (name: string) => (expression: Node) =>
-  TypeScriptFactory.createVariableStatement(
-    [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
-    TypeScriptFactory.createVariableDeclarationList(
-      [
-        TypeScriptFactory.createVariableDeclaration(
-          name,
-          undefined,
-          undefined,
-          expression,
-        ),
-      ],
-      NodeFlags.Const,
-    ),
-  );
+import {
+  type Block,
+  type Expression,
+  NodeFlags,
+  type Statement,
+  SyntaxKind,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
+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): Statement =>
+      factory.createModuleDeclaration(
+        [factory.createToken(SyntaxKind.ExportKeyword)],
+        factory.createIdentifier(route.name),
+        factory.createModuleBlock([
+          ...writeTypes(project)(importer)(route),
+          FilePrinter.enter(),
+          writePath(project)(route),
+        ]),
+        NodeFlags.Namespace,
+      );
+
+  const writeTypes =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedWebSocketRoute): Statement[] => {
+      const output: Statement[] = [];
+      const declare = (name: string, type: TypeNode) =>
+        output.push(
+          factory.createTypeAliasDeclaration(
+            [factory.createModifier(SyntaxKind.ExportKeyword)],
+            name,
+            undefined,
+            type,
+          ),
+        );
+
+      if (project.config.keyword === true)
+        declare("Props", SdkAliasCollection.websocketProps(route));
+      declare(
+        "Output",
+        factory.createTypeLiteralNode([
+          factory.createPropertySignature(
+            undefined,
+            "connector",
+            undefined,
+            factory.createTypeReferenceNode(
+              importer.external({
+                declaration: false,
+                file: "tgrid",
+                type: "element",
+                name: "WebSocketConnector",
+              }),
+              [
+                factory.createTypeReferenceNode("Header"),
+                factory.createTypeReferenceNode("Provider"),
+                factory.createTypeReferenceNode("Listener"),
+              ],
+            ),
+          ),
+          factory.createPropertySignature(
+            undefined,
+            "driver",
+            undefined,
+            factory.createTypeReferenceNode(
+              importer.external({
+                declaration: true,
+                file: "tgrid",
+                type: "element",
+                name: "Driver",
+              }),
+              [factory.createTypeReferenceNode("Listener")],
+            ),
+          ),
+          factory.createPropertySignature(
+            undefined,
+            "reconnect",
+            undefined,
+            factory.createFunctionTypeNode(
+              undefined,
+              [],
+              factory.createTypeReferenceNode(
+                factory.createIdentifier("Promise"),
+                [factory.createKeywordTypeNode(SyntaxKind.VoidKeyword)],
+              ),
+            ),
+          ),
+        ]),
+      );
+
+      declare(
+        "Header",
+        SdkAliasCollection.name({
+          type: (route.header?.type ?? route.acceptor.type.typeArguments?.[0])!,
+        }),
+      );
+      declare(
+        "Provider",
+        SdkAliasCollection.name({
+          type:
+            route.driver?.type.typeArguments?.[0] ??
+            route.acceptor.type.typeArguments?.[2]!,
+        }),
+      );
+      declare(
+        "Listener",
+        SdkAliasCollection.name({
+          type: route.acceptor.type.typeArguments?.[1]!,
+        }),
+      );
+      if (route.query) declare("Query", SdkAliasCollection.name(route.query));
+      return output;
+    };
+
+  const writePath =
+    (project: INestiaProject) =>
+    (route: ITypedWebSocketRoute): Statement => {
+      const out = (body: Block | Expression) =>
+        constant("path")(
+          factory.createArrowFunction(
+            [],
+            [],
+            SdkWebSocketParameterProgrammer.getParameterDeclarations({
+              project,
+              route,
+              provider: false,
+              prefix: false,
+            }),
+            undefined,
+            undefined,
+            body,
+          ),
+        );
+      if (route.pathParameters.length === 0 && route.query === null)
+        return out(factory.createStringLiteral(route.path));
+
+      const access = (key: string) =>
+        project.config.keyword === true
+          ? factory.createPropertyAccessExpression(
+              factory.createIdentifier("props"),
+              key,
+            )
+          : factory.createIdentifier(key);
+      const template = () => {
+        const split: string[] = route.path.split(":");
+        if (split.length === 1) return factory.createStringLiteral(route.path);
+        return factory.createTemplateExpression(
+          factory.createTemplateHead(split[0]!),
+          split.slice(1).map((s, i, arr) => {
+            const name: string = s.split("/")[0]!;
+            return factory.createTemplateSpan(
+              factory.createCallExpression(
+                factory.createIdentifier("encodeURIComponent"),
+                undefined,
+                [
+                  factory.createBinaryExpression(
+                    factory.createCallChain(
+                      factory.createPropertyAccessChain(
+                        access(
+                          route.pathParameters.find((p) => p.field === name)!
+                            .name,
+                        ),
+                        factory.createToken(SyntaxKind.QuestionDotToken),
+                        "toString",
+                      ),
+                      undefined,
+                      undefined,
+                      [],
+                    ),
+                    factory.createToken(SyntaxKind.QuestionQuestionToken),
+                    factory.createStringLiteral("null"),
+                  ),
+                ],
+              ),
+              (i !== arr.length - 1
+                ? factory.createTemplateMiddle
+                : factory.createTemplateTail)(s.substring(name.length)),
+            );
+          }),
+        );
+      };
+      if (route.query === null) return out(template());
+
+      const block = (expr: 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 factory.createBlock(
+          [
+            local(variables)("URLSearchParams")(
+              factory.createNewExpression(
+                factory.createIdentifier("URLSearchParams"),
+                [],
+                [],
+              ),
+            ),
+            factory.createForOfStatement(
+              undefined,
+              factory.createVariableDeclarationList(
+                [
+                  factory.createVariableDeclaration(
+                    factory.createArrayBindingPattern([
+                      factory.createBindingElement(
+                        undefined,
+                        undefined,
+                        factory.createIdentifier("key"),
+                        undefined,
+                      ),
+                      factory.createBindingElement(
+                        undefined,
+                        undefined,
+                        factory.createIdentifier("value"),
+                        undefined,
+                      ),
+                    ]),
+                    undefined,
+                    undefined,
+                    undefined,
+                  ),
+                ],
+                NodeFlags.Const,
+              ),
+              factory.createCallExpression(
+                factory.createIdentifier("Object.entries"),
+                undefined,
+                [factory.createAsExpression(expr, TypeFactory.keyword("any"))],
+              ),
+              factory.createIfStatement(
+                factory.createStrictEquality(
+                  factory.createIdentifier("undefined"),
+                  factory.createIdentifier("value"),
+                ),
+                factory.createContinueStatement(),
+                factory.createIfStatement(
+                  factory.createCallExpression(
+                    factory.createIdentifier("Array.isArray"),
+                    undefined,
+                    [factory.createIdentifier("value")],
+                  ),
+                  factory.createExpressionStatement(
+                    factory.createCallExpression(
+                      factory.createPropertyAccessExpression(
+                        factory.createIdentifier("value"),
+                        factory.createIdentifier("forEach"),
+                      ),
+                      undefined,
+                      [
+                        factory.createArrowFunction(
+                          undefined,
+                          undefined,
+                          [IdentifierFactory.parameter("elem")],
+                          undefined,
+                          undefined,
+                          factory.createCallExpression(
+                            IdentifierFactory.access(
+                              factory.createIdentifier(variables),
+                              "append",
+                            ),
+                            undefined,
+                            [
+                              factory.createIdentifier("key"),
+                              factory.createCallExpression(
+                                factory.createIdentifier("String"),
+                                undefined,
+                                [factory.createIdentifier("elem")],
+                              ),
+                            ],
+                          ),
+                        ),
+                      ],
+                    ),
+                  ),
+                  factory.createExpressionStatement(
+                    factory.createCallExpression(
+                      IdentifierFactory.access(
+                        factory.createIdentifier(variables),
+                        "set",
+                      ),
+                      undefined,
+                      [
+                        factory.createIdentifier("key"),
+                        factory.createCallExpression(
+                          factory.createIdentifier("String"),
+                          undefined,
+                          [factory.createIdentifier("value")],
+                        ),
+                      ],
+                    ),
+                  ),
+                ),
+              ),
+            ),
+            local("location")("string")(template()),
+            factory.createReturnStatement(
+              factory.createConditionalExpression(
+                factory.createStrictEquality(
+                  ExpressionFactory.number(0),
+                  IdentifierFactory.access(
+                    factory.createIdentifier(variables),
+                    "size",
+                  ),
+                ),
+                undefined,
+                factory.createIdentifier("location"),
+                undefined,
+                factory.createTemplateExpression(
+                  factory.createTemplateHead(""),
+                  [
+                    factory.createTemplateSpan(
+                      factory.createIdentifier("location"),
+                      factory.createTemplateMiddle("?"),
+                    ),
+                    factory.createTemplateSpan(
+                      factory.createCallExpression(
+                        IdentifierFactory.access(
+                          factory.createIdentifier(variables),
+                          "toString",
+                        ),
+                        undefined,
+                        undefined,
+                      ),
+                      factory.createTemplateTail(""),
+                    ),
+                  ],
+                ),
+              ),
+            ),
+          ],
+          true,
+        );
+      };
+      return out(block(access(route.query.name)));
+    };
+}
+
+const local = (name: string) => (type: string) => (expression: Expression) =>
+  factory.createVariableStatement(
+    [],
+    factory.createVariableDeclarationList(
+      [
+        factory.createVariableDeclaration(
+          name,
+          undefined,
+          factory.createTypeReferenceNode(type),
+          expression,
+        ),
+      ],
+      NodeFlags.Const,
+    ),
+  );
+const constant = (name: string) => (expression: Expression) =>
+  factory.createVariableStatement(
+    [factory.createModifier(SyntaxKind.ExportKeyword)],
+    factory.createVariableDeclarationList(
+      [
+        factory.createVariableDeclaration(
+          name,
+          undefined,
+          undefined,
+          expression,
+        ),
+      ],
+      NodeFlags.Const,
+    ),
+  );