@nestia/sdk 11.2.1 → 12.0.0-dev.20260520.1

package/src/generates/internal/SdkWebSocketNamespaceProgrammer.ts

@@ -1,5 +1,5 @@
-import { ExpressionFactory, IdentifierFactory, TypeFactory } from "@typia/core";
-import ts from "typescript";
+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";
@@ -12,27 +12,27 @@ 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([
+    (route: ITypedWebSocketRoute): Node =>
+      TypeScriptFactory.createModuleDeclaration(
+        [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createIdentifier(route.name),
+        TypeScriptFactory.createModuleBlock([
           ...writeTypes(project)(importer)(route),
           FilePrinter.enter(),
           writePath(project)(route),
         ]),
-        ts.NodeFlags.Namespace,
+        NodeFlags.Namespace,
       );
 
   const writeTypes =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.TypeAliasDeclaration[] => {
-      const output: ts.TypeAliasDeclaration[] = [];
-      const declare = (name: string, type: ts.TypeNode) =>
+    (route: ITypedWebSocketRoute): Node[] => {
+      const output: Node[] = [];
+      const declare = (name: string, type: Node) =>
         output.push(
-          ts.factory.createTypeAliasDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          TypeScriptFactory.createTypeAliasDeclaration(
+            [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
             name,
             undefined,
             type,
@@ -43,12 +43,12 @@ export namespace SdkWebSocketNamespaceProgrammer {
         declare("Props", SdkAliasCollection.websocketProps(route));
       declare(
         "Output",
-        ts.factory.createTypeLiteralNode([
-          ts.factory.createPropertySignature(
+        TypeScriptFactory.createTypeLiteralNode([
+          TypeScriptFactory.createPropertySignature(
             undefined,
             "connector",
             undefined,
-            ts.factory.createTypeReferenceNode(
+            TypeScriptFactory.createTypeReferenceNode(
               importer.external({
                 declaration: false,
                 file: "tgrid",
@@ -56,36 +56,40 @@ export namespace SdkWebSocketNamespaceProgrammer {
                 name: "WebSocketConnector",
               }),
               [
-                ts.factory.createTypeReferenceNode("Header"),
-                ts.factory.createTypeReferenceNode("Provider"),
-                ts.factory.createTypeReferenceNode("Listener"),
+                TypeScriptFactory.createTypeReferenceNode("Header"),
+                TypeScriptFactory.createTypeReferenceNode("Provider"),
+                TypeScriptFactory.createTypeReferenceNode("Listener"),
               ],
             ),
           ),
-          ts.factory.createPropertySignature(
+          TypeScriptFactory.createPropertySignature(
             undefined,
             "driver",
             undefined,
-            ts.factory.createTypeReferenceNode(
+            TypeScriptFactory.createTypeReferenceNode(
               importer.external({
                 declaration: true,
                 file: "tgrid",
                 type: "element",
                 name: "Driver",
               }),
-              [ts.factory.createTypeReferenceNode("Listener")],
+              [TypeScriptFactory.createTypeReferenceNode("Listener")],
             ),
           ),
-          ts.factory.createPropertySignature(
+          TypeScriptFactory.createPropertySignature(
             undefined,
             "reconnect",
             undefined,
-            ts.factory.createFunctionTypeNode(
+            TypeScriptFactory.createFunctionTypeNode(
               undefined,
               [],
-              ts.factory.createTypeReferenceNode(
-                ts.factory.createIdentifier("Promise"),
-                [ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword)],
+              TypeScriptFactory.createTypeReferenceNode(
+                TypeScriptFactory.createIdentifier("Promise"),
+                [
+                  TypeScriptFactory.createKeywordTypeNode(
+                    SyntaxKind.VoidKeyword,
+                  ),
+                ],
               ),
             ),
           ),
@@ -118,10 +122,10 @@ export namespace SdkWebSocketNamespaceProgrammer {
 
   const writePath =
     (project: INestiaProject) =>
-    (route: ITypedWebSocketRoute): ts.VariableStatement => {
-      const out = (body: ts.ConciseBody) =>
+    (route: ITypedWebSocketRoute): Node => {
+      const out = (body: Node) =>
         constant("path")(
-          ts.factory.createArrowFunction(
+          TypeScriptFactory.createArrowFunction(
             [],
             [],
             SdkWebSocketParameterProgrammer.getParameterDeclarations({
@@ -136,57 +140,63 @@ export namespace SdkWebSocketNamespaceProgrammer {
           ),
         );
       if (route.pathParameters.length === 0 && route.query === null)
-        return out(ts.factory.createStringLiteral(route.path));
+        return out(TypeScriptFactory.createStringLiteral(route.path));
 
       const access = (key: string) =>
         project.config.keyword === true
-          ? ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("props"),
+          ? TypeScriptFactory.createPropertyAccessExpression(
+              TypeScriptFactory.createIdentifier("props"),
               key,
             )
-          : ts.factory.createIdentifier(key);
+          : TypeScriptFactory.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]!),
+          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 ts.factory.createTemplateSpan(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("encodeURIComponent"),
+            return TypeScriptFactory.createTemplateSpan(
+              TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier("encodeURIComponent"),
                 undefined,
                 [
-                  ts.factory.createBinaryExpression(
-                    ts.factory.createCallChain(
-                      ts.factory.createPropertyAccessChain(
+                  TypeScriptFactory.createBinaryExpression(
+                    TypeScriptFactory.createCallChain(
+                      TypeScriptFactory.createPropertyAccessChain(
                         access(
                           route.pathParameters.find((p) => p.field === name)!
                             .name,
                         ),
-                        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                        TypeScriptFactory.createToken(
+                          SyntaxKind.QuestionDotToken,
+                        ),
                         "toString",
                       ),
                       undefined,
                       undefined,
                       [],
                     ),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                    ts.factory.createStringLiteral("null"),
+                    TypeScriptFactory.createToken(
+                      SyntaxKind.QuestionQuestionToken,
+                    ),
+                    TypeScriptFactory.createStringLiteral("null"),
                   ),
                 ],
               ),
               (i !== arr.length - 1
-                ? ts.factory.createTemplateMiddle
-                : ts.factory.createTemplateTail)(s.substring(name.length)),
+                ? TypeScriptFactory.createTemplateMiddle
+                : TypeScriptFactory.createTemplateTail)(
+                s.substring(name.length),
+              ),
             );
           }),
         );
       };
       if (route.query === null) return out(template());
 
-      const block = (expr: ts.Expression) => {
+      const block = (expr: Node) => {
         const computeName = (str: string): string =>
           [...route.pathParameters, ...(route.query ? [route.query] : [])].find(
             (p) => p.name === str,
@@ -194,31 +204,31 @@ export namespace SdkWebSocketNamespaceProgrammer {
             ? computeName("_" + str)
             : str;
         const variables: string = computeName("variables");
-        return ts.factory.createBlock(
+        return TypeScriptFactory.createBlock(
           [
             local(variables)("URLSearchParams")(
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
+              TypeScriptFactory.createNewExpression(
+                TypeScriptFactory.createIdentifier("URLSearchParams"),
                 [],
                 [],
               ),
             ),
-            ts.factory.createForOfStatement(
+            TypeScriptFactory.createForOfStatement(
               undefined,
-              ts.factory.createVariableDeclarationList(
+              TypeScriptFactory.createVariableDeclarationList(
                 [
-                  ts.factory.createVariableDeclaration(
-                    ts.factory.createArrayBindingPattern([
-                      ts.factory.createBindingElement(
+                  TypeScriptFactory.createVariableDeclaration(
+                    TypeScriptFactory.createArrayBindingPattern([
+                      TypeScriptFactory.createBindingElement(
                         undefined,
                         undefined,
-                        ts.factory.createIdentifier("key"),
+                        TypeScriptFactory.createIdentifier("key"),
                         undefined,
                       ),
-                      ts.factory.createBindingElement(
+                      TypeScriptFactory.createBindingElement(
                         undefined,
                         undefined,
-                        ts.factory.createIdentifier("value"),
+                        TypeScriptFactory.createIdentifier("value"),
                         undefined,
                       ),
                     ]),
@@ -227,56 +237,56 @@ export namespace SdkWebSocketNamespaceProgrammer {
                     undefined,
                   ),
                 ],
-                ts.NodeFlags.Const,
+                NodeFlags.Const,
               ),
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.entries"),
+              TypeScriptFactory.createCallExpression(
+                TypeScriptFactory.createIdentifier("Object.entries"),
                 undefined,
                 [
-                  ts.factory.createAsExpression(
+                  TypeScriptFactory.createAsExpression(
                     expr,
                     TypeFactory.keyword("any"),
                   ),
                 ],
               ),
-              ts.factory.createIfStatement(
-                ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  ts.factory.createIdentifier("value"),
+              TypeScriptFactory.createIfStatement(
+                TypeScriptFactory.createStrictEquality(
+                  TypeScriptFactory.createIdentifier("undefined"),
+                  TypeScriptFactory.createIdentifier("value"),
                 ),
-                ts.factory.createContinueStatement(),
-                ts.factory.createIfStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Array.isArray"),
+                TypeScriptFactory.createContinueStatement(),
+                TypeScriptFactory.createIfStatement(
+                  TypeScriptFactory.createCallExpression(
+                    TypeScriptFactory.createIdentifier("Array.isArray"),
                     undefined,
-                    [ts.factory.createIdentifier("value")],
+                    [TypeScriptFactory.createIdentifier("value")],
                   ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("value"),
-                        ts.factory.createIdentifier("forEach"),
+                  TypeScriptFactory.createExpressionStatement(
+                    TypeScriptFactory.createCallExpression(
+                      TypeScriptFactory.createPropertyAccessExpression(
+                        TypeScriptFactory.createIdentifier("value"),
+                        TypeScriptFactory.createIdentifier("forEach"),
                       ),
                       undefined,
                       [
-                        ts.factory.createArrowFunction(
+                        TypeScriptFactory.createArrowFunction(
                           undefined,
                           undefined,
                           [IdentifierFactory.parameter("elem")],
                           undefined,
                           undefined,
-                          ts.factory.createCallExpression(
+                          TypeScriptFactory.createCallExpression(
                             IdentifierFactory.access(
-                              ts.factory.createIdentifier(variables),
+                              TypeScriptFactory.createIdentifier(variables),
                               "append",
                             ),
                             undefined,
                             [
-                              ts.factory.createIdentifier("key"),
-                              ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("String"),
+                              TypeScriptFactory.createIdentifier("key"),
+                              TypeScriptFactory.createCallExpression(
+                                TypeScriptFactory.createIdentifier("String"),
                                 undefined,
-                                [ts.factory.createIdentifier("elem")],
+                                [TypeScriptFactory.createIdentifier("elem")],
                               ),
                             ],
                           ),
@@ -284,19 +294,19 @@ export namespace SdkWebSocketNamespaceProgrammer {
                       ],
                     ),
                   ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
+                  TypeScriptFactory.createExpressionStatement(
+                    TypeScriptFactory.createCallExpression(
                       IdentifierFactory.access(
-                        ts.factory.createIdentifier(variables),
+                        TypeScriptFactory.createIdentifier(variables),
                         "set",
                       ),
                       undefined,
                       [
-                        ts.factory.createIdentifier("key"),
-                        ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("String"),
+                        TypeScriptFactory.createIdentifier("key"),
+                        TypeScriptFactory.createCallExpression(
+                          TypeScriptFactory.createIdentifier("String"),
                           undefined,
-                          [ts.factory.createIdentifier("value")],
+                          [TypeScriptFactory.createIdentifier("value")],
                         ),
                       ],
                     ),
@@ -305,35 +315,35 @@ export namespace SdkWebSocketNamespaceProgrammer {
               ),
             ),
             local("location")("string")(template()),
-            ts.factory.createReturnStatement(
-              ts.factory.createConditionalExpression(
-                ts.factory.createStrictEquality(
+            TypeScriptFactory.createReturnStatement(
+              TypeScriptFactory.createConditionalExpression(
+                TypeScriptFactory.createStrictEquality(
                   ExpressionFactory.number(0),
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(variables),
+                    TypeScriptFactory.createIdentifier(variables),
                     "size",
                   ),
                 ),
                 undefined,
-                ts.factory.createIdentifier("location"),
+                TypeScriptFactory.createIdentifier("location"),
                 undefined,
-                ts.factory.createTemplateExpression(
-                  ts.factory.createTemplateHead(""),
+                TypeScriptFactory.createTemplateExpression(
+                  TypeScriptFactory.createTemplateHead(""),
                   [
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createIdentifier("location"),
-                      ts.factory.createTemplateMiddle("?"),
+                    TypeScriptFactory.createTemplateSpan(
+                      TypeScriptFactory.createIdentifier("location"),
+                      TypeScriptFactory.createTemplateMiddle("?"),
                     ),
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createCallExpression(
+                    TypeScriptFactory.createTemplateSpan(
+                      TypeScriptFactory.createCallExpression(
                         IdentifierFactory.access(
-                          ts.factory.createIdentifier(variables),
+                          TypeScriptFactory.createIdentifier(variables),
                           "toString",
                         ),
                         undefined,
                         undefined,
                       ),
-                      ts.factory.createTemplateTail(""),
+                      TypeScriptFactory.createTemplateTail(""),
                     ),
                   ],
                 ),
@@ -347,33 +357,33 @@ export namespace SdkWebSocketNamespaceProgrammer {
     };
 }
 
-const local = (name: string) => (type: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
+const local = (name: string) => (type: string) => (expression: Node) =>
+  TypeScriptFactory.createVariableStatement(
     [],
-    ts.factory.createVariableDeclarationList(
+    TypeScriptFactory.createVariableDeclarationList(
       [
-        ts.factory.createVariableDeclaration(
+        TypeScriptFactory.createVariableDeclaration(
           name,
           undefined,
-          ts.factory.createTypeReferenceNode(type),
+          TypeScriptFactory.createTypeReferenceNode(type),
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );
-const constant = (name: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    ts.factory.createVariableDeclarationList(
+const constant = (name: string) => (expression: Node) =>
+  TypeScriptFactory.createVariableStatement(
+    [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
+    TypeScriptFactory.createVariableDeclarationList(
       [
-        ts.factory.createVariableDeclaration(
+        TypeScriptFactory.createVariableDeclaration(
           name,
           undefined,
           undefined,
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );

package/src/generates/internal/SdkWebSocketParameterProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import { Node, TypeScriptFactory } from "@nestia/factory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedWebSocketRoute } from "../../structures/ITypedWebSocketRoute";
@@ -7,7 +7,7 @@ import { SdkAliasCollection } from "./SdkAliasCollection";
 export namespace SdkWebSocketParameterProgrammer {
   export interface IEntry {
     key: string;
-    type: ts.TypeNode;
+    type: Node;
   }
 
   export const getEntries = (props: {
@@ -26,7 +26,7 @@ export namespace SdkWebSocketParameterProgrammer {
         ? [
             {
               key: "query",
-              type: ts.factory.createTypeReferenceNode(`${prefix}Query`),
+              type: TypeScriptFactory.createTypeReferenceNode(`${prefix}Query`),
             },
           ]
         : []),
@@ -34,7 +34,9 @@ export namespace SdkWebSocketParameterProgrammer {
         ? [
             {
               key: "provider",
-              type: ts.factory.createTypeReferenceNode(`${prefix}Provider`),
+              type: TypeScriptFactory.createTypeReferenceNode(
+                `${prefix}Provider`,
+              ),
             },
           ]
         : []),
@@ -46,23 +48,23 @@ export namespace SdkWebSocketParameterProgrammer {
     route: ITypedWebSocketRoute;
     provider: boolean;
     prefix: boolean;
-  }): ts.ParameterDeclaration[] => {
+  }): Node[] => {
     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"),
+      const node: Node = props.provider
+        ? TypeScriptFactory.createTypeReferenceNode(typeName)
+        : TypeScriptFactory.createTypeReferenceNode("Omit", [
+            TypeScriptFactory.createTypeReferenceNode(typeName),
+            TypeScriptFactory.createLiteralTypeNode(
+              TypeScriptFactory.createStringLiteral("provider"),
             ),
           ]);
       return [
-        ts.factory.createParameterDeclaration(
+        TypeScriptFactory.createParameterDeclaration(
           undefined,
           undefined,
           "props",
@@ -72,7 +74,7 @@ export namespace SdkWebSocketParameterProgrammer {
       ];
     }
     return entries.map((entry) =>
-      ts.factory.createParameterDeclaration(
+      TypeScriptFactory.createParameterDeclaration(
         undefined,
         undefined,
         entry.key,