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

package/src/generates/internal/E2eFileProgrammer.ts

@@ -1,233 +1,246 @@
-import { Node, NodeFlags, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
-import { IdentifierFactory, LiteralFactory } from "@nestia/factory";
-
-import { INestiaProject } from "../../structures/INestiaProject";
-import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
-import { FilePrinter } from "./FilePrinter";
-import { ImportDictionary } from "./ImportDictionary";
-import { SdkAliasCollection } from "./SdkAliasCollection";
-import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
-import { SdkImportWizard } from "./SdkImportWizard";
-
-export namespace E2eFileProgrammer {
-  export const generate =
-    (project: INestiaProject) =>
-    (props: { api: string; current: string }) =>
-    async (route: ITypedHttpRoute): Promise<void> => {
-      const importer: ImportDictionary = new ImportDictionary(
-        `${props.current}/${getFunctionName(route)}.ts`,
-      );
-      if (project.config.clone !== true) importer.declarations(route.imports);
-      importer.internal({
-        file: props.api,
-        declaration: false,
-        type: "default",
-        name: "api",
-      });
-      const functor: Node = generateFunctor(project)(importer)(route);
-      await FilePrinter.write({
-        location: importer.file,
-        statements: [
-          ...importer.toStatements(props.current),
-          FilePrinter.enter(),
-          functor,
-        ],
-      });
-    };
-
-  const generateFunctor =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): Node =>
-      TypeScriptFactory.createVariableStatement(
-        [TypeScriptFactory.createModifier(SyntaxKind.ExportKeyword)],
-        TypeScriptFactory.createVariableDeclarationList(
-          [
-            TypeScriptFactory.createVariableDeclaration(
-              TypeScriptFactory.createIdentifier(getFunctionName(route)),
-              undefined,
-              undefined,
-              generateArrow(project)(importer)(route),
-            ),
-          ],
-          NodeFlags.Const,
-        ),
-      );
-
-  const generateArrow =
-    (project: INestiaProject) =>
-    (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute) => {
-      const random = IdentifierFactory.access(
-        TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
-        "random",
-      );
-      const connection = route.headerObject
-        ? TypeScriptFactory.createObjectLiteralExpression(
-            [
-              TypeScriptFactory.createSpreadAssignment(
-                TypeScriptFactory.createIdentifier("connection"),
-              ),
-              TypeScriptFactory.createPropertyAssignment(
-                "headers",
-                TypeScriptFactory.createObjectLiteralExpression(
-                  [
-                    TypeScriptFactory.createSpreadAssignment(
-                      IdentifierFactory.access(
-                        TypeScriptFactory.createIdentifier("connection"),
-                        "headers",
-                      ),
-                    ),
-                    TypeScriptFactory.createSpreadAssignment(
-                      TypeScriptFactory.createCallExpression(
-                        random,
-                        [
-                          project.config.clone === true
-                            ? SdkAliasCollection.from(project)(importer)(
-                                route.headerObject.metadata,
-                              )
-                            : SdkAliasCollection.name(route.headerObject),
-                        ],
-                        undefined,
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ],
-            true,
-          )
-        : TypeScriptFactory.createIdentifier("connection");
-      const entries = SdkHttpParameterProgrammer.getEntries({
-        project,
-        importer,
-        route,
-        body: true,
-        e2e: true,
-        prefix: ["api", "functional", ...route.accessor].join(".") + ".",
-      });
-      const fetch = TypeScriptFactory.createCallExpression(
-        TypeScriptFactory.createIdentifier(
-          ["api", "functional", ...route.accessor].join("."),
-        ),
-        undefined,
-        [
-          connection,
-          ...(project.config.keyword === true && entries.length !== 0
-            ? [
-                LiteralFactory.write(
-                  Object.fromEntries(
-                    entries.map((e) => [
-                      e.key,
-                      TypeScriptFactory.createCallExpression(
-                        IdentifierFactory.access(
-                          TypeScriptFactory.createIdentifier(
-                            SdkImportWizard.typia(importer),
-                          ),
-                          "random",
-                        ),
-                        [getRandomType(importer)(e)],
-                        undefined,
-                      ),
-                    ]),
-                  ),
-                ),
-              ]
-            : entries.map((e) =>
-                TypeScriptFactory.createCallExpression(
-                  IdentifierFactory.access(
-                    TypeScriptFactory.createIdentifier(
-                      SdkImportWizard.typia(importer),
-                    ),
-                    "random",
-                  ),
-                  [getRandomType(importer)(e)],
-                  undefined,
-                ),
-              )),
-        ],
-      );
-      const assert = TypeScriptFactory.createCallExpression(
-        IdentifierFactory.access(
-          TypeScriptFactory.createIdentifier(SdkImportWizard.typia(importer)),
-          "assert",
-        ),
-        undefined,
-        [TypeScriptFactory.createIdentifier("output")],
-      );
-
-      return TypeScriptFactory.createArrowFunction(
-        [TypeScriptFactory.createModifier(SyntaxKind.AsyncKeyword)],
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "connection",
-            TypeScriptFactory.createTypeReferenceNode("api.IConnection"),
-          ),
-        ],
-        undefined,
-        undefined,
-        TypeScriptFactory.createBlock([
-          TypeScriptFactory.createVariableStatement(
-            [],
-            TypeScriptFactory.createVariableDeclarationList(
-              [
-                TypeScriptFactory.createVariableDeclaration(
-                  "output",
-                  undefined,
-                  project.config.propagate !== true &&
-                    route.success.type!.name === "void"
-                    ? undefined
-                    : SdkAliasCollection.response(project)(importer)(route),
-                  TypeScriptFactory.createAwaitExpression(fetch),
-                ),
-              ],
-              NodeFlags.Const,
-            ),
-          ),
-          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("_");
+import {
+  type Node,
+  NodeFlags,
+  type NumericLiteral,
+  SyntaxKind,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+import { INestiaProject } from "../../structures/INestiaProject";
+import { ITypedHttpRoute } from "../../structures/ITypedHttpRoute";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
+import { SdkImportWizard } from "./SdkImportWizard";
+
+export namespace E2eFileProgrammer {
+  export const generate =
+    (project: INestiaProject) =>
+    (props: { api: string; current: string }) =>
+    async (route: ITypedHttpRoute): Promise<void> => {
+      const importer: ImportDictionary = new ImportDictionary(
+        `${props.current}/${getFunctionName(route)}.ts`,
+      );
+      if (project.config.clone !== true) importer.declarations(route.imports);
+      importer.internal({
+        file: props.api,
+        declaration: false,
+        type: "default",
+        name: "api",
+      });
+      const functor: Node = generateFunctor(project)(importer)(route);
+      await FilePrinter.write({
+        location: importer.file,
+        statements: [
+          ...importer.toStatements(props.current),
+          FilePrinter.enter(),
+          functor,
+        ],
+      });
+    };
+
+  const generateFunctor =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute): Node =>
+      factory.createVariableStatement(
+        [factory.createModifier(SyntaxKind.ExportKeyword)],
+        factory.createVariableDeclarationList(
+          [
+            factory.createVariableDeclaration(
+              factory.createIdentifier(getFunctionName(route)),
+              undefined,
+              undefined,
+              generateArrow(project)(importer)(route),
+            ),
+          ],
+          NodeFlags.Const,
+        ),
+      );
+
+  const generateArrow =
+    (project: INestiaProject) =>
+    (importer: ImportDictionary) =>
+    (route: ITypedHttpRoute) => {
+      const random = IdentifierFactory.access(
+        factory.createIdentifier(SdkImportWizard.typia(importer)),
+        "random",
+      );
+      const connection = route.headerObject
+        ? factory.createObjectLiteralExpression(
+            [
+              factory.createSpreadAssignment(
+                factory.createIdentifier("connection"),
+              ),
+              factory.createPropertyAssignment(
+                "headers",
+                factory.createObjectLiteralExpression(
+                  [
+                    factory.createSpreadAssignment(
+                      IdentifierFactory.access(
+                        factory.createIdentifier("connection"),
+                        "headers",
+                      ),
+                    ),
+                    factory.createSpreadAssignment(
+                      factory.createCallExpression(
+                        random,
+                        [
+                          (project.config.clone === true
+                            ? SdkAliasCollection.from(project)(importer)(
+                                route.headerObject.metadata,
+                              )
+                            : SdkAliasCollection.name(
+                                route.headerObject,
+                              )) as TypeNode,
+                        ],
+                        undefined,
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ],
+            true,
+          )
+        : factory.createIdentifier("connection");
+      const entries = SdkHttpParameterProgrammer.getEntries({
+        project,
+        importer,
+        route,
+        body: true,
+        e2e: true,
+        prefix: ["api", "functional", ...route.accessor].join(".") + ".",
+      });
+      const fetch = factory.createCallExpression(
+        factory.createIdentifier(
+          ["api", "functional", ...route.accessor].join("."),
+        ),
+        undefined,
+        [
+          connection,
+          ...(project.config.keyword === true && entries.length !== 0
+            ? [
+                LiteralFactory.write(
+                  Object.fromEntries(
+                    entries.map((e) => [
+                      e.key,
+                      factory.createCallExpression(
+                        IdentifierFactory.access(
+                          factory.createIdentifier(
+                            SdkImportWizard.typia(importer),
+                          ),
+                          "random",
+                        ),
+                        [getRandomType(importer)(e)],
+                        undefined,
+                      ),
+                    ]),
+                  ),
+                ),
+              ]
+            : entries.map((e) =>
+                factory.createCallExpression(
+                  IdentifierFactory.access(
+                    factory.createIdentifier(SdkImportWizard.typia(importer)),
+                    "random",
+                  ),
+                  [getRandomType(importer)(e)],
+                  undefined,
+                ),
+              )),
+        ],
+      );
+      const assert = factory.createCallExpression(
+        IdentifierFactory.access(
+          factory.createIdentifier(SdkImportWizard.typia(importer)),
+          "assert",
+        ),
+        undefined,
+        [factory.createIdentifier("output")],
+      );
+
+      return factory.createArrowFunction(
+        [factory.createModifier(SyntaxKind.AsyncKeyword)],
+        undefined,
+        [
+          IdentifierFactory.parameter(
+            "connection",
+            factory.createTypeReferenceNode("api.IConnection"),
+          ),
+        ],
+        undefined,
+        undefined,
+        factory.createBlock([
+          factory.createVariableStatement(
+            [],
+            factory.createVariableDeclarationList(
+              [
+                factory.createVariableDeclaration(
+                  "output",
+                  undefined,
+                  project.config.propagate !== true &&
+                    route.success.type!.name === "void"
+                    ? undefined
+                    : (SdkAliasCollection.response(project)(importer)(
+                        route,
+                      ) as TypeNode),
+                  factory.createAwaitExpression(fetch),
+                ),
+              ],
+              NodeFlags.Const,
+            ),
+          ),
+          ...(route.success.binary === true
+            ? []
+            : [factory.createExpressionStatement(assert)]),
+        ]),
+      );
+    };
+}
+
+const getRandomType =
+  (importer: ImportDictionary) =>
+  (entry: SdkHttpParameterProgrammer.IEntry): TypeNode => {
+    if (isPlainStringPathParameter(entry) === false)
+      return entry.type as TypeNode;
+    return factory.createIntersectionTypeNode([
+      entry.type as TypeNode,
+      factory.createTypeReferenceNode(
+        factory.createQualifiedName(
+          factory.createIdentifier(
+            importer.external({
+              declaration: true,
+              file: "typia",
+              type: "element",
+              name: "tags",
+            }),
+          ),
+          factory.createIdentifier("MinLength"),
+        ),
+        [
+          factory.createLiteralTypeNode(
+            LiteralFactory.write(1) as NumericLiteral,
+          ),
+        ],
+      ),
+    ]);
+  };
+
+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,65 +1,57 @@
-import {
-  Node,
-  SyntaxKind,
-  TypeScriptFactory,
-  TypeScriptPrinter,
-} from "@nestia/factory";
-import fs from "fs";
-import { format } from "prettier";
-
-export namespace FilePrinter {
-  export const description = <T extends Node>(
-    node: T,
-    comment: string,
-  ): T => {
-    if (comment.length === 0) return node;
-    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 = () =>
-    TypeScriptFactory.createExpressionStatement(
-      TypeScriptFactory.createIdentifier("\n"),
-    );
-
-  export const write = async (props: {
-    location: string;
-    statements: Node[];
-    top?: string;
-  }): Promise<void> => {
-    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> => {
-    try {
-      return await format(script, {
-        parser: "typescript",
-      });
-    } catch {
-      return script;
-    }
-  };
-}
+import {
+  type Node,
+  type Statement,
+  SyntaxKind,
+  TsPrinter,
+  addSyntheticLeadingComment,
+  factory,
+} from "@ttsc/factory";
+import fs from "fs";
+import { format } from "prettier";
+
+export namespace FilePrinter {
+  export const description = <T extends Node>(node: T, comment: string): T => {
+    if (comment.length === 0) return node;
+    return addSyntheticLeadingComment(
+      node,
+      SyntaxKind.MultiLineCommentTrivia,
+      [
+        "*",
+        ...comment
+          .split("\r\n")
+          .join("\n")
+          .split("\n")
+          .map(
+            (str) =>
+              ` * ${str.split("*/").join("*\\\\/").split("*\\/").join("*\\\\/")}`,
+          ),
+        "",
+      ].join("\n"),
+      true,
+    );
+  };
+
+  export const enter = () =>
+    factory.createExpressionStatement(factory.createIdentifier("\n"));
+
+  export const write = async (props: {
+    location: string;
+    statements: Node[];
+    top?: string;
+  }): Promise<void> => {
+    const script: string =
+      (props.top ?? "") +
+      new TsPrinter().printFile(undefined, props.statements as Statement[]);
+    await fs.promises.writeFile(props.location, await beautify(script), "utf8");
+  };
+
+  const beautify = async (script: string): Promise<string> => {
+    try {
+      return await format(script, {
+        parser: "typescript",
+      });
+    } catch {
+      return script;
+    }
+  };
+}