@nestia/sdk 11.2.1 → 12.0.0-dev.20260520.1

package/src/generates/internal/SdkWebSocketRouteProgrammer.ts

@@ -1,5 +1,5 @@
-import { IdentifierFactory } from "@typia/core";
-import ts from "typescript";
+import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory } from "@nestia/factory";
 import { IJsDocTagInfo } from "typia";
 
 import { INestiaProject } from "../../structures/INestiaProject";
@@ -14,7 +14,7 @@ export namespace SdkWebSocketRouteProgrammer {
   export const write =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.Statement[] => [
+    (route: ITypedWebSocketRoute): Node[] => [
       FilePrinter.description(
         writeFunction(project)(importer)(route),
         writeDescription(route),
@@ -58,11 +58,11 @@ export namespace SdkWebSocketRouteProgrammer {
   const writeFunction =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.FunctionDeclaration => {
-      return ts.factory.createFunctionDeclaration(
+    (route: ITypedWebSocketRoute): Node => {
+      return TypeScriptFactory.createFunctionDeclaration(
         [
-          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-          ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+          TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword),
+          TypeScriptFactory.createModifier(SyntaxKind.AsyncKeyword),
         ],
         undefined,
         route.name,
@@ -70,9 +70,13 @@ export namespace SdkWebSocketRouteProgrammer {
         [
           IdentifierFactory.parameter(
             "connection",
-            ts.factory.createTypeReferenceNode(
+            TypeScriptFactory.createTypeReferenceNode(
               SdkImportWizard.IConnection(importer),
-              [ts.factory.createTypeReferenceNode(`${route.name}.Header`)],
+              [
+                TypeScriptFactory.createTypeReferenceNode(
+                  `${route.name}.Header`,
+                ),
+              ],
             ),
           ),
           ...SdkWebSocketParameterProgrammer.getParameterDeclarations({
@@ -82,10 +86,10 @@ export namespace SdkWebSocketRouteProgrammer {
             prefix: true,
           }),
         ],
-        ts.factory.createTypeReferenceNode("Promise", [
-          ts.factory.createTypeReferenceNode(`${route.name}.Output`),
+        TypeScriptFactory.createTypeReferenceNode("Promise", [
+          TypeScriptFactory.createTypeReferenceNode(`${route.name}.Output`),
         ]),
-        ts.factory.createBlock(
+        TypeScriptFactory.createBlock(
           writeFunctionBody(project)(importer)(route),
           true,
         ),
@@ -95,37 +99,37 @@ export namespace SdkWebSocketRouteProgrammer {
   const writeFunctionBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedWebSocketRoute): ts.Statement[] => {
+    (route: ITypedWebSocketRoute): Node[] => {
       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);
       return [
-        local("url")(ts.factory.createTypeReferenceNode("string"))(
+        local("url")(TypeScriptFactory.createTypeReferenceNode("string"))(
           joinPath(
-            ts.factory.createCallExpression(
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier(route.name),
+            TypeScriptFactory.createCallExpression(
+              TypeScriptFactory.createPropertyAccessExpression(
+                TypeScriptFactory.createIdentifier(route.name),
                 "path",
               ),
               [],
               project.config.keyword === true &&
                 SdkWebSocketParameterProgrammer.isPathEmpty(route) === false
-                ? [ts.factory.createIdentifier("props")]
+                ? [TypeScriptFactory.createIdentifier("props")]
                 : SdkWebSocketParameterProgrammer.getEntries({
                     project,
                     route,
                     provider: false,
                     prefix: true,
-                  }).map((p) => ts.factory.createIdentifier(p.key)),
+                  }).map((p) => TypeScriptFactory.createIdentifier(p.key)),
             ),
           ),
         ),
         local("connector")(
-          ts.factory.createTypeReferenceNode(
+          TypeScriptFactory.createTypeReferenceNode(
             importer.external({
               declaration: false,
               file: "tgrid",
@@ -133,14 +137,18 @@ export namespace SdkWebSocketRouteProgrammer {
               name: "WebSocketConnector",
             }),
             [
-              ts.factory.createTypeReferenceNode(`${route.name}.Header`),
-              ts.factory.createTypeReferenceNode(`${route.name}.Provider`),
-              ts.factory.createTypeReferenceNode(`${route.name}.Listener`),
+              TypeScriptFactory.createTypeReferenceNode(`${route.name}.Header`),
+              TypeScriptFactory.createTypeReferenceNode(
+                `${route.name}.Provider`,
+              ),
+              TypeScriptFactory.createTypeReferenceNode(
+                `${route.name}.Listener`,
+              ),
             ],
           ),
         )(
-          ts.factory.createNewExpression(
-            ts.factory.createIdentifier(
+          TypeScriptFactory.createNewExpression(
+            TypeScriptFactory.createIdentifier(
               importer.external({
                 declaration: false,
                 file: "tgrid",
@@ -150,74 +158,84 @@ export namespace SdkWebSocketRouteProgrammer {
             ),
             undefined,
             [
-              ts.factory.createAsExpression(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("connection"),
+              TypeScriptFactory.createAsExpression(
+                TypeScriptFactory.createBinaryExpression(
+                  TypeScriptFactory.createPropertyAccessExpression(
+                    TypeScriptFactory.createIdentifier("connection"),
                     "headers",
                   ),
-                  ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                  ts.factory.createObjectLiteralExpression([], false),
+                  TypeScriptFactory.createToken(
+                    SyntaxKind.QuestionQuestionToken,
+                  ),
+                  TypeScriptFactory.createObjectLiteralExpression([], false),
+                ),
+                TypeScriptFactory.createKeywordTypeNode(
+                  SyntaxKind.AnyKeyword,
                 ),
-                ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
               ),
               access("provider"),
             ],
           ),
         ),
-        ts.factory.createExpressionStatement(
-          ts.factory.createAwaitExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier("connector"),
+        TypeScriptFactory.createExpressionStatement(
+          TypeScriptFactory.createAwaitExpression(
+            TypeScriptFactory.createCallExpression(
+              TypeScriptFactory.createPropertyAccessExpression(
+                TypeScriptFactory.createIdentifier("connector"),
                 "connect",
               ),
               undefined,
-              [ts.factory.createIdentifier("url")],
+              [TypeScriptFactory.createIdentifier("url")],
             ),
           ),
         ),
         local("driver")(
-          ts.factory.createTypeReferenceNode(
+          TypeScriptFactory.createTypeReferenceNode(
             importer.external({
               declaration: true,
               file: "tgrid",
               type: "element",
               name: "Driver",
             }),
-            [ts.factory.createTypeReferenceNode(`${route.name}.Listener`)],
+            [
+              TypeScriptFactory.createTypeReferenceNode(
+                `${route.name}.Listener`,
+              ),
+            ],
           ),
         )(
-          ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("connector"),
+          TypeScriptFactory.createCallExpression(
+            TypeScriptFactory.createPropertyAccessExpression(
+              TypeScriptFactory.createIdentifier("connector"),
               "getDriver",
             ),
             undefined,
             undefined,
           ),
         ),
-        ts.factory.createReturnStatement(
-          ts.factory.createObjectLiteralExpression(
+        TypeScriptFactory.createReturnStatement(
+          TypeScriptFactory.createObjectLiteralExpression(
             [
-              ts.factory.createShorthandPropertyAssignment("connector"),
-              ts.factory.createShorthandPropertyAssignment("driver"),
-              ts.factory.createPropertyAssignment(
-                ts.factory.createIdentifier("reconnect"),
-                ts.factory.createArrowFunction(
-                  [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+              TypeScriptFactory.createShorthandPropertyAssignment("connector"),
+              TypeScriptFactory.createShorthandPropertyAssignment("driver"),
+              TypeScriptFactory.createPropertyAssignment(
+                TypeScriptFactory.createIdentifier("reconnect"),
+                TypeScriptFactory.createArrowFunction(
+                  [TypeScriptFactory.createToken(SyntaxKind.AsyncKeyword)],
                   undefined,
                   [],
                   undefined,
-                  ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-                  ts.factory.createAwaitExpression(
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("connector"),
-                        ts.factory.createIdentifier("connect"),
+                  TypeScriptFactory.createToken(
+                    SyntaxKind.EqualsGreaterThanToken,
+                  ),
+                  TypeScriptFactory.createAwaitExpression(
+                    TypeScriptFactory.createCallExpression(
+                      TypeScriptFactory.createPropertyAccessExpression(
+                        TypeScriptFactory.createIdentifier("connector"),
+                        TypeScriptFactory.createIdentifier("connect"),
                       ),
                       undefined,
-                      [ts.factory.createIdentifier("url")],
+                      [TypeScriptFactory.createIdentifier("url")],
                     ),
                   ),
                 ),
@@ -231,72 +249,75 @@ export namespace SdkWebSocketRouteProgrammer {
 }
 
 const local =
-  (name: string) => (type: ts.TypeNode) => (expression: ts.Expression) =>
-    ts.factory.createVariableStatement(
+  (name: string) => (type: Node) => (expression: Node) =>
+    TypeScriptFactory.createVariableStatement(
       [],
-      ts.factory.createVariableDeclarationList(
+      TypeScriptFactory.createVariableDeclarationList(
         [
-          ts.factory.createVariableDeclaration(
+          TypeScriptFactory.createVariableDeclaration(
             name,
             undefined,
             type,
             expression,
           ),
         ],
-        ts.NodeFlags.Const,
+        NodeFlags.Const,
       ),
     );
 
-const joinPath = (caller: ts.Expression) =>
-  ts.factory.createTemplateExpression(ts.factory.createTemplateHead("", ""), [
-    ts.factory.createTemplateSpan(
-      ts.factory.createConditionalExpression(
-        ts.factory.createCallExpression(
-          ts.factory.createPropertyAccessExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("connection"),
-              ts.factory.createIdentifier("host"),
+const joinPath = (caller: Node) =>
+  TypeScriptFactory.createTemplateExpression(
+    TypeScriptFactory.createTemplateHead("", ""),
+    [
+      TypeScriptFactory.createTemplateSpan(
+        TypeScriptFactory.createConditionalExpression(
+          TypeScriptFactory.createCallExpression(
+            TypeScriptFactory.createPropertyAccessExpression(
+              TypeScriptFactory.createPropertyAccessExpression(
+                TypeScriptFactory.createIdentifier("connection"),
+                TypeScriptFactory.createIdentifier("host"),
+              ),
+              TypeScriptFactory.createIdentifier("endsWith"),
             ),
-            ts.factory.createIdentifier("endsWith"),
+            undefined,
+            [TypeScriptFactory.createStringLiteral("/")],
           ),
-          undefined,
-          [ts.factory.createStringLiteral("/")],
-        ),
-        ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-        ts.factory.createCallExpression(
-          ts.factory.createPropertyAccessExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("connection"),
-              ts.factory.createIdentifier("host"),
+          TypeScriptFactory.createToken(SyntaxKind.QuestionToken),
+          TypeScriptFactory.createCallExpression(
+            TypeScriptFactory.createPropertyAccessExpression(
+              TypeScriptFactory.createPropertyAccessExpression(
+                TypeScriptFactory.createIdentifier("connection"),
+                TypeScriptFactory.createIdentifier("host"),
+              ),
+              TypeScriptFactory.createIdentifier("substring"),
             ),
-            ts.factory.createIdentifier("substring"),
-          ),
-          undefined,
-          [
-            ts.factory.createNumericLiteral("0"),
-            ts.factory.createBinaryExpression(
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("connection"),
-                  ts.factory.createIdentifier("host"),
+            undefined,
+            [
+              TypeScriptFactory.createNumericLiteral("0"),
+              TypeScriptFactory.createBinaryExpression(
+                TypeScriptFactory.createPropertyAccessExpression(
+                  TypeScriptFactory.createPropertyAccessExpression(
+                    TypeScriptFactory.createIdentifier("connection"),
+                    TypeScriptFactory.createIdentifier("host"),
+                  ),
+                  TypeScriptFactory.createIdentifier("length"),
                 ),
-                ts.factory.createIdentifier("length"),
+                TypeScriptFactory.createToken(SyntaxKind.MinusToken),
+                TypeScriptFactory.createNumericLiteral("1"),
               ),
-              ts.factory.createToken(ts.SyntaxKind.MinusToken),
-              ts.factory.createNumericLiteral("1"),
-            ),
-          ],
-        ),
-        ts.factory.createToken(ts.SyntaxKind.ColonToken),
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier("connection"),
-          ts.factory.createIdentifier("host"),
+            ],
+          ),
+          TypeScriptFactory.createToken(SyntaxKind.ColonToken),
+          TypeScriptFactory.createPropertyAccessExpression(
+            TypeScriptFactory.createIdentifier("connection"),
+            TypeScriptFactory.createIdentifier("host"),
+          ),
         ),
+        TypeScriptFactory.createTemplateMiddle("", ""),
+      ),
+      TypeScriptFactory.createTemplateSpan(
+        caller,
+        TypeScriptFactory.createTemplateTail("", ""),
       ),
-      ts.factory.createTemplateMiddle("", ""),
-    ),
-    ts.factory.createTemplateSpan(
-      caller,
-      ts.factory.createTemplateTail("", ""),
-    ),
-  ]);
+    ],
+  );

package/src/generates/internal/SwaggerOperationComposer.ts

@@ -1,4 +1,4 @@
-import { MetadataSchema } from "@typia/core";
+import { MetadataSchema } from "../../internal/legacy";
 import { OpenApi } from "@typia/interface";
 
 import { INestiaConfig } from "../../INestiaConfig";

package/src/generates/internal/SwaggerOperationParameterComposer.ts

@@ -1,4 +1,4 @@
-import { JsonSchemasProgrammer } from "@typia/core";
+import { JsonSchemasProgrammer, MetadataObjectType } from "../../internal/legacy";
 import { OpenApi } from "@typia/interface";
 import { VariadicSingleton } from "tstl";
 import { IJsDocTagInfo, IJsonSchemaCollection } from "typia";
@@ -31,6 +31,7 @@ export namespace SwaggerOperationParameterComposer {
     props: Omit<IProps<ITypedHttpRouteParameter.IBody>, "config" | "document">,
   ): OpenApi.IOperation.IRequestBody => {
     const description: string | undefined =
+      props.parameter.description ??
       SwaggerDescriptionComposer.descriptionFromJsDocTag({
         jsDocTags: props.jsDocTags,
         tag: "param",
@@ -47,28 +48,28 @@ export namespace SwaggerOperationParameterComposer {
           examples: props.parameter.examples,
         },
       },
-      required: props.parameter.metadata.isRequired(),
+      required: props.parameter.metadata.required,
       ...(props.parameter.encrypted ? { "x-nestia-encrypted": true } : {}),
     };
   };
 
-  export const path = (
+  const path = (
     props: Omit<IProps<ITypedHttpRouteParameter.IPath>, "config" | "document">,
   ): OpenApi.IOperation.IParameter => ({
     name: props.parameter.field,
     in: "path",
     schema: props.schema,
-    required: props.parameter.metadata.isRequired(),
+    required: props.parameter.metadata.required,
     description: parameterDescription(props),
     example: props.parameter.example,
     examples: props.parameter.examples,
   });
 
-  export const query = (
+  const query = (
     props: IProps<ITypedHttpRouteParameter.IQuery>,
   ): OpenApi.IOperation.IParameter[] => decomposible(props);
 
-  export const header = (
+  const header = (
     props: IProps<ITypedHttpRouteParameter.IHeaders>,
   ): OpenApi.IOperation.IParameter[] => decomposible(props);
 
@@ -102,7 +103,7 @@ export namespace SwaggerOperationParameterComposer {
       in: props.parameter.category === "query" ? "query" : "header",
       schema: props.schema,
       description: parameterDescription(props),
-      required: props.parameter.metadata.isRequired(),
+      required: props.parameter.metadata.required,
       example: props.parameter.example,
       examples: props.parameter.examples,
     };
@@ -111,7 +112,7 @@ export namespace SwaggerOperationParameterComposer {
       props.parameter.metadata.objects.length === 0
     )
       return [param];
-    return props.parameter.metadata.objects[0]!.type.properties.filter((p) =>
+    return (props.parameter.metadata.objects[0]!.type as MetadataObjectType).properties.filter((p) =>
       p.jsDocTags.every(
         (tag) => tag.name !== "hidden" && tag.name !== "ignore",
       ),
@@ -132,7 +133,7 @@ export namespace SwaggerOperationParameterComposer {
         name: p.key.constants[0]!.values[0]!.value as string,
         in: props.parameter.category === "query" ? "query" : "header",
         schema: json.schemas[0]!,
-        required: p.value.isRequired(),
+        required: p.value.required,
         description: SwaggerDescriptionComposer.compose({
           description: p.description ?? null,
           jsDocTags: p.jsDocTags,

package/src/generates/internal/SwaggerOperationResponseComposer.ts

@@ -1,4 +1,4 @@
-import { MetadataSchema } from "@typia/core";
+import { MetadataSchema } from "../../internal/legacy";
 import { OpenApi } from "@typia/interface";
 import { VariadicSingleton } from "tstl";