@nestia/sdk 11.2.1 → 12.0.0-dev.20260521.1

package/src/generates/SwaggerGenerator.ts

@@ -1,5 +1,5 @@
 import { SwaggerCustomizer } from "@nestia/core";
-import { JsonSchemasProgrammer, MetadataSchema } from "@typia/core";
+import { JsonSchemasProgrammer, MetadataSchema, sizeOf } from "../internal/legacy";
 import {
   OpenApi,
   OpenApiV3,
@@ -11,7 +11,7 @@ import { OpenApiConverter } from "@typia/utils";
 import fs from "fs";
 import path from "path";
 import { Singleton } from "tstl";
-import typia, { IJsonSchemaCollection } from "typia";
+import type { IJsonSchemaCollection } from "typia";
 
 import { INestiaConfig } from "../INestiaConfig";
 import { ITypedApplication } from "../structures/ITypedApplication";
@@ -89,7 +89,7 @@ export namespace SwaggerGenerator {
         ...Object.values(r.exceptions).map((e) => e.metadata),
       ])
       .flat()
-      .filter((m) => m.size() !== 0);
+      .filter((m) => sizeOf(m) !== 0);
 
     // COMPOSE JSON SCHEMAS
     const json: IJsonSchemaCollection = JsonSchemasProgrammer.writeSchemas({
@@ -127,7 +127,7 @@ export namespace SwaggerGenerator {
 
         try {
           const content: string = await fs.promises.readFile(location, "utf8");
-          const data = typia.json.assertParse<{
+          const data = JSON.parse(content) as {
             name?: string;
             version?: string;
             description?: string;
@@ -138,12 +138,16 @@ export namespace SwaggerGenerator {
                   /** @format uri */
                   url: string;
                 };
-          }>(content);
+          };
           return {
-            title: data.name,
-            version: data.version,
-            description: data.description,
-            license: data.license
+            title: typeof data.name === "string" ? data.name : undefined,
+            version:
+              typeof data.version === "string" ? data.version : undefined,
+            description:
+              typeof data.description === "string"
+                ? data.description
+                : undefined,
+            license: isLicense(data.license)
               ? typeof data.license === "string"
                 ? { name: data.license }
                 : typeof data.license === "object"
@@ -191,6 +195,21 @@ export namespace SwaggerGenerator {
     };
   };
 
+  const isLicense = (
+    input: unknown,
+  ): input is
+    | string
+    | {
+        type: string;
+        url: string;
+      } =>
+    typeof input === "string" ||
+    (typeof input === "object" &&
+      input !== null &&
+      Array.isArray(input) === false &&
+      typeof (input as { type?: unknown }).type === "string" &&
+      typeof (input as { url?: unknown }).url === "string");
+
   const fillPaths = (props: {
     config: Omit<INestiaConfig.ISwaggerConfig, "output">;
     document: OpenApi.IDocument;

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,5 +1,5 @@
-import { IdentifierFactory, LiteralFactory } from "@typia/core";
-import ts from "typescript";
+import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory, LiteralFactory } from "@nestia/factory";
 
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
@@ -24,7 +24,7 @@ export namespace E2eFileProgrammer {
         type: "default",
         name: "api",
       });
-      const functor: ts.Statement = generateFunctor(project)(importer)(route);
+      const functor: Node = generateFunctor(project)(importer)(route);
       await FilePrinter.write({
         location: importer.file,
         statements: [
@@ -38,19 +38,19 @@ export namespace E2eFileProgrammer {
   const generateFunctor =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): ts.Statement =>
-      ts.factory.createVariableStatement(
-        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-        ts.factory.createVariableDeclarationList(
+    (route: ITypedHttpRoute): Node =>
+      TypeScriptFactory.createVariableStatement(
+        [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createVariableDeclarationList(
           [
-            ts.factory.createVariableDeclaration(
-              ts.factory.createIdentifier(getFunctionName(route)),
+            TypeScriptFactory.createVariableDeclaration(
+              TypeScriptFactory.createIdentifier(getFunctionName(route)),
               undefined,
               undefined,
               generateArrow(project)(importer)(route),
             ),
           ],
-          ts.NodeFlags.Const,
+          NodeFlags.Const,
         ),
       );
 
@@ -59,27 +59,27 @@ export namespace E2eFileProgrammer {
     (importer: ImportDictionary) =>
     (route: ITypedHttpRoute) => {
       const random = IdentifierFactory.access(
-        ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+        TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
         "random",
       );
       const connection = route.headerObject
-        ? ts.factory.createObjectLiteralExpression(
+        ? TypeScriptFactory.createObjectLiteralExpression(
             [
-              ts.factory.createSpreadAssignment(
-                ts.factory.createIdentifier("connection"),
+              TypeScriptFactory.createSpreadAssignment(
+                TypeScriptFactory.createIdentifier("connection"),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "headers",
-                ts.factory.createObjectLiteralExpression(
+                TypeScriptFactory.createObjectLiteralExpression(
                   [
-                    ts.factory.createSpreadAssignment(
+                    TypeScriptFactory.createSpreadAssignment(
                       IdentifierFactory.access(
-                        ts.factory.createIdentifier("connection"),
+                        TypeScriptFactory.createIdentifier("connection"),
                         "headers",
                       ),
                     ),
-                    ts.factory.createSpreadAssignment(
-                      ts.factory.createCallExpression(
+                    TypeScriptFactory.createSpreadAssignment(
+                      TypeScriptFactory.createCallExpression(
                         random,
                         [
                           project.config.clone === true
@@ -98,7 +98,7 @@ export namespace E2eFileProgrammer {
             ],
             true,
           )
-        : ts.factory.createIdentifier("connection");
+        : TypeScriptFactory.createIdentifier("connection");
       const entries = SdkHttpParameterProgrammer.getEntries({
         project,
         importer,
@@ -107,8 +107,8 @@ export namespace E2eFileProgrammer {
         e2e: true,
         prefix: ["api", "functional", ...route.accessor].join(".") + ".",
       });
-      const fetch = ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
+      const fetch = TypeScriptFactory.createCallExpression(
+        TypeScriptFactory.createIdentifier(
           ["api", "functional", ...route.accessor].join("."),
         ),
         undefined,
@@ -120,14 +120,14 @@ export namespace E2eFileProgrammer {
                   Object.fromEntries(
                     entries.map((e) => [
                       e.key,
-                      ts.factory.createCallExpression(
+                      TypeScriptFactory.createCallExpression(
                         IdentifierFactory.access(
-                          ts.factory.createIdentifier(
+                          TypeScriptFactory.createIdentifier(
                             SdkImportWizard.typia(importer),
                           ),
                           "random",
                         ),
-                        [e.type],
+                        [getRandomType(importer)(e)],
                         undefined,
                       ),
                     ]),
@@ -135,62 +135,99 @@ export namespace E2eFileProgrammer {
                 ),
               ]
             : entries.map((e) =>
-                ts.factory.createCallExpression(
+                TypeScriptFactory.createCallExpression(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(
+                    TypeScriptFactory.createIdentifier(
                       SdkImportWizard.typia(importer),
                     ),
                     "random",
                   ),
-                  [e.type],
+                  [getRandomType(importer)(e)],
                   undefined,
                 ),
               )),
         ],
       );
-      const assert = ts.factory.createCallExpression(
+      const assert = TypeScriptFactory.createCallExpression(
         IdentifierFactory.access(
-          ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+          TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
           "assert",
         ),
         undefined,
-        [ts.factory.createIdentifier("output")],
+        [TypeScriptFactory.createIdentifier("output")],
       );
 
-      return ts.factory.createArrowFunction(
-        [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)],
+      return TypeScriptFactory.createArrowFunction(
+        [TypeScriptFactory.createModifier(SyntaxKind.AsyncKeyword)],
         undefined,
         [
           IdentifierFactory.parameter(
             "connection",
-            ts.factory.createTypeReferenceNode("api.IConnection"),
+            TypeScriptFactory.createTypeReferenceNode("api.IConnection"),
           ),
         ],
         undefined,
         undefined,
-        ts.factory.createBlock([
-          ts.factory.createVariableStatement(
+        TypeScriptFactory.createBlock([
+          TypeScriptFactory.createVariableStatement(
             [],
-            ts.factory.createVariableDeclarationList(
+            TypeScriptFactory.createVariableDeclarationList(
               [
-                ts.factory.createVariableDeclaration(
+                TypeScriptFactory.createVariableDeclaration(
                   "output",
                   undefined,
                   project.config.propagate !== true &&
-                    route.success.type.name === "void"
+                    route.success.type!.name === "void"
                     ? undefined
                     : SdkAliasCollection.response(project)(importer)(route),
-                  ts.factory.createAwaitExpression(fetch),
+                  TypeScriptFactory.createAwaitExpression(fetch),
                 ),
               ],
-              ts.NodeFlags.Const,
+              NodeFlags.Const,
             ),
           ),
-          ts.factory.createExpressionStatement(assert),
+          TypeScriptFactory.createExpressionStatement(assert),
         ]),
       );
     };
 }
 
+const getRandomType =
+  (importer: ImportDictionary) =>
+  (entry: SdkHttpParameterProgrammer.IEntry): Node => {
+    if (isPlainStringPathParameter(entry) === false) return entry.type;
+    return TypeScriptFactory.createIntersectionTypeNode([
+      entry.type,
+      TypeScriptFactory.createTypeReferenceNode(
+        TypeScriptFactory.createQualifiedName(
+          TypeScriptFactory.createIdentifier(
+            importer.external({
+              declaration: true,
+              file: "typia",
+              type: "element",
+              name: "tags",
+            }),
+          ),
+          TypeScriptFactory.createIdentifier("MinLength"),
+        ),
+        [
+          TypeScriptFactory.createLiteralTypeNode(
+            LiteralFactory.write(1) as Node,
+          ),
+        ],
+      ),
+    ]);
+  };
+
+const isPlainStringPathParameter = (
+  entry: SdkHttpParameterProgrammer.IEntry,
+): boolean =>
+  entry.parameter.category === "param" &&
+  entry.parameter.metadata.atomics.length === 1 &&
+  entry.parameter.metadata.atomics[0]!.type === "string" &&
+  entry.parameter.metadata.atomics[0]!.tags.every((row) =>
+    row.every((tag) => tag.kind !== "minLength"),
+  );
+
 const getFunctionName = (route: ITypedHttpRoute): string =>
   ["test", "api", ...route.accessor].join("_");

package/src/generates/internal/FilePrinter.ts

@@ -1,55 +1,56 @@
+import {
+  Node,
+  SyntaxKind,
+  TypeScriptFactory,
+  TypeScriptPrinter,
+} from "@nestia/factory";
 import fs from "fs";
 import { format } from "prettier";
-import ts from "typescript";
 
 export namespace FilePrinter {
-  export const description = <Node extends ts.Node>(
-    node: Node,
+  export const description = <T extends Node>(
+    node: T,
     comment: string,
-  ): Node => {
+  ): T => {
     if (comment.length === 0) return node;
-    ts.addSyntheticLeadingComment(
-      node,
-      ts.SyntaxKind.MultiLineCommentTrivia,
-      [
-        "*",
-        ...comment
-          .split("\r\n")
-          .join("\n")
-          .split("\n")
-          .map(
-            (str) =>
-              ` * ${str.split("*/").join("*\\\\/").split("*\\/").join("*\\\\/")}`,
-          ),
-        "",
-      ].join("\n"),
-      true,
-    );
+    node.emitNode ??= {};
+    node.emitNode.leadingComments = [
+      ...(node.emitNode.leadingComments ?? []),
+      {
+        kind: SyntaxKind.MultiLineCommentTrivia,
+        text: [
+          "*",
+          ...comment
+            .split("\r\n")
+            .join("\n")
+            .split("\n")
+            .map(
+              (str) =>
+                ` * ${str.split("*/").join("*\\\\/").split("*\\/").join("*\\\\/")}`,
+            ),
+          "",
+        ].join("\n"),
+        hasTrailingNewLine: true,
+      },
+    ];
     return node;
   };
 
   export const enter = () =>
-    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
+    TypeScriptFactory.createExpressionStatement(
+      TypeScriptFactory.createIdentifier("\n"),
+    );
 
   export const write = async (props: {
     location: string;
-    statements: ts.Statement[];
+    statements: Node[];
     top?: string;
   }): Promise<void> => {
-    const script: string = ts
-      .createPrinter()
-      .printFile(
-        ts.factory.createSourceFile(
-          props.statements,
-          ts.factory.createToken(ts.SyntaxKind.EndOfFileToken),
-          ts.NodeFlags.None,
-        ),
-      );
-    await fs.promises.writeFile(
-      props.location,
-      await beautify((props.top ?? "") + script),
-      "utf8",
-    );
+    const script: string = TypeScriptPrinter.write({
+      statements: props.statements,
+      top: props.top,
+    });
+    await fs.promises.writeFile(props.location, await beautify(script), "utf8");
   };
 
   const beautify = async (script: string): Promise<string> => {

package/src/generates/internal/ImportDictionary.ts

@@ -1,6 +1,6 @@
+import { Node, TypeScriptFactory } from "@nestia/factory";
 import path from "path";
 import { HashMap, TreeSet, hash } from "tstl";
-import ts from "typescript";
 
 import { ImportAnalyzer } from "../../analyses/ImportAnalyzer";
 import { IReflectImport } from "../../structures/IReflectImport";
@@ -84,11 +84,11 @@ export class ImportDictionary {
     return props.name;
   }
 
-  public toStatements(outDir: string): ts.Statement[] {
+  public toStatements(outDir: string): Node[] {
     outDir = path.resolve(outDir);
 
-    const external: ts.ImportDeclaration[] = [];
-    const internal: ts.ImportDeclaration[] = [];
+    const external: Node[] = [];
+    const internal: Node[] = [];
     const locator = (str: string) => {
       const location: string = path
         .relative(outDir, str)
@@ -103,7 +103,7 @@ export class ImportDictionary {
     };
     const enroll =
       (filter: (str: string) => boolean) =>
-      (container: ts.ImportDeclaration[]) => {
+      (container: Node[]) => {
         const compositions: ICompositeValue[] = this.components_
           .toJSON()
           .filter((c) => filter(c.second.file))
@@ -117,10 +117,10 @@ export class ImportDictionary {
           .sort((a, b) => a.file.localeCompare(b.file));
         for (const c of compositions)
           container.push(
-            ts.factory.createImportDeclaration(
+            TypeScriptFactory.createImportDeclaration(
               undefined,
               this.toImportClaude(c),
-              ts.factory.createStringLiteral(c.file),
+              TypeScriptFactory.createStringLiteral(c.file),
               undefined,
             ),
           );
@@ -135,25 +135,27 @@ export class ImportDictionary {
     ];
   }
 
-  private toImportClaude(c: ICompositeValue): ts.ImportClause {
+  private toImportClaude(c: ICompositeValue): Node {
     if (c.asterisk !== null)
-      return ts.factory.createImportClause(
+      return TypeScriptFactory.createImportClause(
         c.declaration,
         undefined,
-        ts.factory.createNamespaceImport(
-          ts.factory.createIdentifier(c.asterisk),
+        TypeScriptFactory.createNamespaceImport(
+          TypeScriptFactory.createIdentifier(c.asterisk),
         ),
       );
-    return ts.factory.createImportClause(
+    return TypeScriptFactory.createImportClause(
       c.declaration,
-      c.default !== null ? ts.factory.createIdentifier(c.default) : undefined,
+      c.default !== null
+        ? TypeScriptFactory.createIdentifier(c.default)
+        : undefined,
       c.elements.size() !== 0
-        ? ts.factory.createNamedImports(
+        ? TypeScriptFactory.createNamedImports(
             Array.from(c.elements).map((elem) =>
-              ts.factory.createImportSpecifier(
+              TypeScriptFactory.createImportSpecifier(
                 false,
                 undefined,
-                ts.factory.createIdentifier(elem),
+                TypeScriptFactory.createIdentifier(elem),
               ),
             ),
           )