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

package/src/generates/internal/FilePrinter.ts

@@ -1,55 +1,47 @@
 import {
-  Node,
+  type Node,
+  type Statement,
   SyntaxKind,
-  TypeScriptFactory,
-  TypeScriptPrinter,
-} from "@nestia/factory";
+  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 => {
+  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;
+    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 = () =>
-    TypeScriptFactory.createExpressionStatement(
-      TypeScriptFactory.createIdentifier("\n"),
-    );
+    factory.createExpressionStatement(factory.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,
-    });
+    const script: string =
+      (props.top ?? "") +
+      new TsPrinter().printFile(undefined, props.statements as Statement[]);
     await fs.promises.writeFile(props.location, await beautify(script), "utf8");
   };
 

package/src/generates/internal/ImportDictionary.ts

@@ -1,4 +1,4 @@
-import { Node, TypeScriptFactory } from "@nestia/factory";
+import { type ImportClause, type Node, factory } from "@ttsc/factory";
 import path from "path";
 import { HashMap, TreeMap, hash } from "tstl";
 
@@ -109,11 +109,10 @@ export class ImportDictionary {
           .sort((a, b) => a.file.localeCompare(b.file));
         for (const c of compositions)
           container.push(
-            TypeScriptFactory.createImportDeclaration(
+            factory.createImportDeclaration(
               undefined,
               this.toImportClaude(c),
-              TypeScriptFactory.createStringLiteral(c.file),
-              undefined,
+              factory.createStringLiteral(c.file),
             ),
           );
       };
@@ -127,29 +126,28 @@ export class ImportDictionary {
     ];
   }
 
-  private toImportClaude(c: ICompositeValue): Node {
+  private toImportClaude(c: ICompositeValue): ImportClause {
+    // A namespace import cannot carry a per-binding `type` modifier, so the
+    // type-only flag stays off here (a value namespace import resolves type
+    // members fine), matching the legacy printer output `import * as X`.
     if (c.asterisk !== null)
-      return TypeScriptFactory.createImportClause(
-        c.declaration,
+      return factory.createImportClause(
+        false,
         undefined,
-        TypeScriptFactory.createNamespaceImport(
-          TypeScriptFactory.createIdentifier(c.asterisk),
-        ),
+        factory.createNamespaceImport(factory.createIdentifier(c.asterisk)),
       );
-    return TypeScriptFactory.createImportClause(
+    // `c.declaration` (type-only) belongs on the import clause, not on each
+    // specifier — emitting both produces the invalid `import type { type X }`.
+    return factory.createImportClause(
       c.declaration,
-      c.default !== null
-        ? TypeScriptFactory.createIdentifier(c.default)
-        : undefined,
+      c.default !== null ? factory.createIdentifier(c.default) : undefined,
       c.elements.size() !== 0
-        ? TypeScriptFactory.createNamedImports(
+        ? factory.createNamedImports(
             Array.from(c.elements).map(({ first: name, second: alias }) =>
-              TypeScriptFactory.createImportSpecifier(
-                c.declaration,
-                alias !== null
-                  ? TypeScriptFactory.createIdentifier(name)
-                  : undefined,
-                TypeScriptFactory.createIdentifier(alias ?? name),
+              factory.createImportSpecifier(
+                false,
+                alias !== null ? factory.createIdentifier(name) : undefined,
+                factory.createIdentifier(alias ?? name),
               ),
             ),
           )

package/src/generates/internal/SdkAliasCollection.ts

@@ -1,6 +1,11 @@
-import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
-import { TypeFactory } from "@nestia/factory";
+import {
+  SyntaxKind,
+  type TypeElement,
+  type TypeNode,
+  factory,
+} from "@ttsc/factory";
 
+import { TypeFactory } from "../../factories/TypeFactory";
 import { MetadataSchema, sizeOf } from "../../internal/legacy";
 import { INestiaProject } from "../../structures/INestiaProject";
 import { IReflectType } from "../../structures/IReflectType";
@@ -13,35 +18,33 @@ import { SdkHttpParameterProgrammer } from "./SdkHttpParameterProgrammer";
 import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
 
 export namespace SdkAliasCollection {
-  export const name = ({ type }: { type: IReflectType }): Node =>
-    TypeScriptFactory.createTypeReferenceNode(
+  export const name = ({ type }: { type: IReflectType }): TypeNode =>
+    factory.createTypeReferenceNode(
       type.name,
       type.typeArguments
         ? type.typeArguments.map((a) => name({ type: a }))
         : undefined,
     );
 
-  export const binaryChunk = (): Node =>
-    TypeScriptFactory.createTypeReferenceNode("Uint8Array", [
-      TypeScriptFactory.createTypeReferenceNode("ArrayBufferLike"),
+  export const binaryChunk = (): TypeNode =>
+    factory.createTypeReferenceNode("Uint8Array", [
+      factory.createTypeReferenceNode("ArrayBufferLike"),
     ]);
 
-  export const binaryResponse = (): Node =>
-    TypeScriptFactory.createTypeReferenceNode("ReadableStream", [
-      binaryChunk(),
-    ]);
+  export const binaryResponse = (): TypeNode =>
+    factory.createTypeReferenceNode("ReadableStream", [binaryChunk()]);
 
   export const from =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (metadata: MetadataSchema) =>
-      SdkTypeProgrammer.write(project)(importer)(metadata);
+    (metadata: MetadataSchema): TypeNode =>
+      SdkTypeProgrammer.write(project)(importer)(metadata) as TypeNode;
 
   export const httpProps =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): Node =>
-      TypeScriptFactory.createTypeLiteralNode(
+    (route: ITypedHttpRoute): TypeNode =>
+      factory.createTypeLiteralNode(
         SdkHttpParameterProgrammer.getEntries({
           project,
           importer,
@@ -50,12 +53,12 @@ export namespace SdkAliasCollection {
           prefix: false,
         })
           .map((e) => {
-            const signature: Node = TypeScriptFactory.createPropertySignature(
+            const signature: TypeElement = factory.createPropertySignature(
               undefined,
               e.key,
               e.required
                 ? undefined
-                : TypeScriptFactory.createToken(SyntaxKind.QuestionToken),
+                : factory.createToken(SyntaxKind.QuestionToken),
               e.type,
             );
             const description: string | null =
@@ -71,7 +74,7 @@ export namespace SdkAliasCollection {
               null;
             return description?.length
               ? [
-                  TypeScriptFactory.createIdentifier("\n") as any,
+                  factory.createIdentifier("\n") as any,
                   FilePrinter.description(signature, description),
                 ]
               : [signature];
@@ -79,10 +82,10 @@ export namespace SdkAliasCollection {
           .flat(),
       );
 
-  export const websocketProps = (route: ITypedWebSocketRoute): Node =>
-    TypeScriptFactory.createTypeLiteralNode([
+  export const websocketProps = (route: ITypedWebSocketRoute): TypeNode =>
+    factory.createTypeLiteralNode([
       ...route.pathParameters.map((p) =>
-        TypeScriptFactory.createPropertySignature(
+        factory.createPropertySignature(
           undefined,
           p.name,
           undefined,
@@ -91,31 +94,31 @@ export namespace SdkAliasCollection {
       ),
       ...(route.query
         ? [
-            TypeScriptFactory.createPropertySignature(
+            factory.createPropertySignature(
               undefined,
               "query",
               undefined,
-              TypeScriptFactory.createTypeReferenceNode("Query"),
+              factory.createTypeReferenceNode("Query"),
             ),
           ]
         : []),
-      TypeScriptFactory.createPropertySignature(
+      factory.createPropertySignature(
         undefined,
         "provider",
         undefined,
-        TypeScriptFactory.createTypeReferenceNode("Provider"),
+        factory.createTypeReferenceNode("Provider"),
       ),
     ]);
 
   export const headers =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IHeaders): Node => {
+    (param: ITypedHttpRouteParameter.IHeaders): TypeNode => {
       if (project.config.clone === true)
         return from(project)(importer)(param.metadata);
-      const type: Node = name(param);
+      const type: TypeNode = name(param);
       if (project.config.primitive === false) return type;
-      return TypeScriptFactory.createTypeReferenceNode(
+      return factory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -129,12 +132,12 @@ export namespace SdkAliasCollection {
   export const query =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IQuery): Node => {
+    (param: ITypedHttpRouteParameter.IQuery): TypeNode => {
       if (project.config.clone === true)
         return from(project)(importer)(param.metadata);
-      const type: Node = name(param);
+      const type: TypeNode = name(param);
       if (project.config.primitive === false) return type;
-      return TypeScriptFactory.createTypeReferenceNode(
+      return factory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -148,18 +151,18 @@ export namespace SdkAliasCollection {
   export const body =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (param: ITypedHttpRouteParameter.IBody): Node => {
+    (param: ITypedHttpRouteParameter.IBody): TypeNode => {
       if (project.config.clone === true) {
-        const type: Node = from(project)(importer)(param.metadata);
+        const type: TypeNode = from(project)(importer)(param.metadata);
         return param.contentType === "multipart/form-data"
           ? formDataInput(importer)(type)
           : type;
       }
-      const type: Node = name(param);
+      const type: TypeNode = name(param);
       if (param.contentType === "multipart/form-data")
         return formDataInput(importer)(type);
       else if (project.config.primitive === false) return type;
-      return TypeScriptFactory.createTypeReferenceNode(
+      return factory.createTypeReferenceNode(
         importer.external({
           file: "typia",
           declaration: true,
@@ -176,14 +179,17 @@ export namespace SdkAliasCollection {
   export const response =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): Node => {
-      const schema = (p: { metadata: MetadataSchema; type: IReflectType }) =>
+    (route: ITypedHttpRoute): TypeNode => {
+      const schema = (p: {
+        metadata: MetadataSchema;
+        type: IReflectType;
+      }): TypeNode =>
         sizeOf(p.metadata) === 0
           ? TypeFactory.keyword("void")
           : project.config.clone === true
             ? from(project)(importer)(p.metadata)
             : project.config.primitive !== false
-              ? TypeScriptFactory.createTypeReferenceNode(
+              ? factory.createTypeReferenceNode(
                   importer.external({
                     file: "typia",
                     declaration: true,
@@ -197,7 +203,7 @@ export namespace SdkAliasCollection {
                   [name(p)],
                 )
               : name(p);
-      const success: Node =
+      const success: TypeNode =
         route.success.binary === true
           ? binaryResponse()
           : schema(route.success);
@@ -215,7 +221,7 @@ export namespace SdkAliasCollection {
           type: schema(value),
         })),
       ];
-      return TypeScriptFactory.createTypeReferenceNode(
+      return factory.createTypeReferenceNode(
         importer.external({
           file: "@nestia/fetcher",
           declaration: true,
@@ -223,11 +229,11 @@ export namespace SdkAliasCollection {
           name: "IPropagation",
         }),
         [
-          TypeScriptFactory.createTypeLiteralNode(
+          factory.createTypeLiteralNode(
             branches.map((b) =>
-              TypeScriptFactory.createPropertySignature(
+              factory.createPropertySignature(
                 undefined,
-                TypeScriptFactory.createNumericLiteral(b.status),
+                factory.createNumericLiteral(b.status),
                 undefined,
                 b.type,
               ),
@@ -235,8 +241,8 @@ export namespace SdkAliasCollection {
           ),
           ...(route.success.status
             ? [
-                TypeScriptFactory.createLiteralTypeNode(
-                  TypeScriptFactory.createNumericLiteral(route.success.status),
+                factory.createLiteralTypeNode(
+                  factory.createNumericLiteral(route.success.status),
                 ),
               ]
             : []),
@@ -247,7 +253,7 @@ export namespace SdkAliasCollection {
   export const responseBody =
     (project: INestiaProject) =>
     (importer: ImportDictionary) =>
-    (route: ITypedHttpRoute): Node =>
+    (route: ITypedHttpRoute): TypeNode =>
       response({
         ...project,
         config: {
@@ -256,8 +262,8 @@ export namespace SdkAliasCollection {
         },
       })(importer)(route);
 
-  const formDataInput = (importer: ImportDictionary) => (type: Node) =>
-    TypeScriptFactory.createTypeReferenceNode(
+  const formDataInput = (importer: ImportDictionary) => (type: TypeNode) =>
+    factory.createTypeReferenceNode(
       importer.external({
         file: "@nestia/fetcher",
         declaration: true,
@@ -270,5 +276,5 @@ export namespace SdkAliasCollection {
 
 interface IBranch {
   status: string;
-  type: Node;
+  type: TypeNode;
 }

package/src/generates/internal/SdkFileProgrammer.ts

@@ -1,4 +1,4 @@
-import { Node, TypeScriptFactory } from "@nestia/factory";
+import { type Node, factory } from "@ttsc/factory";
 import fs from "fs";
 
 import { INestiaProject } from "../../structures/INestiaProject";
@@ -60,14 +60,11 @@ export namespace SdkFileProgrammer {
       for (const [key, value] of directory.children) {
         await iterate(project)(value)(`${outDir}/${key}`);
         statements.push(
-          TypeScriptFactory.createExportDeclaration(
+          factory.createExportDeclaration(
             undefined,
             false,
-            TypeScriptFactory.createNamespaceExport(
-              TypeScriptFactory.createIdentifier(key),
-            ),
-            TypeScriptFactory.createStringLiteral(`./${key}/index`),
-            undefined,
+            factory.createNamespaceExport(factory.createIdentifier(key)),
+            factory.createStringLiteral(`./${key}/index`),
           ),
         );
       }

package/src/generates/internal/SdkHttpCloneProgrammer.ts

@@ -1,12 +1,12 @@
-import { Node, SyntaxKind, TypeScriptFactory } from "@nestia/factory";
+import { type Node, SyntaxKind, type TypeNode, factory } from "@ttsc/factory";
+import { IPointer } from "tstl";
+import { IJsDocTagInfo } from "typia";
+
 import {
   MetadataAliasType,
   MetadataAtomic,
   MetadataObjectType,
 } from "../../internal/legacy";
-import { IPointer } from "tstl";
-import { IJsDocTagInfo } from "typia";
-
 import { INestiaProject } from "../../structures/INestiaProject";
 import { ITypedApplication } from "../../structures/ITypedApplication";
 import { MapUtil } from "../../utils/MapUtil";
@@ -19,9 +19,7 @@ export namespace SdkHttpCloneProgrammer {
   export interface IModule {
     name: string;
     children: Map<string, IModule>;
-    programmer:
-      | null
-      | ((importer: ImportDictionary) => Node);
+    programmer: null | ((importer: ImportDictionary) => Node);
   }
 
   export const write = (app: ITypedApplication): Map<string, IModule> => {
@@ -71,11 +69,11 @@ export namespace SdkHttpCloneProgrammer {
     (importer: ImportDictionary) =>
     (alias: MetadataAliasType): Node =>
       FilePrinter.description(
-        TypeScriptFactory.createTypeAliasDeclaration(
-          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+        factory.createTypeAliasDeclaration(
+          [factory.createToken(SyntaxKind.ExportKeyword)],
           alias.name.split(".").at(-1)!,
           [],
-          SdkTypeProgrammer.write(project)(importer)(alias.value),
+          SdkTypeProgrammer.write(project)(importer)(alias.value) as TypeNode,
         ),
         writeComment([])(alias.description, alias.jsDocTags),
       );
@@ -85,11 +83,11 @@ export namespace SdkHttpCloneProgrammer {
     (importer: ImportDictionary) =>
     (object: MetadataObjectType): Node => {
       return FilePrinter.description(
-        TypeScriptFactory.createTypeAliasDeclaration(
-          [TypeScriptFactory.createToken(SyntaxKind.ExportKeyword)],
+        factory.createTypeAliasDeclaration(
+          [factory.createToken(SyntaxKind.ExportKeyword)],
           object.name.split(".").at(-1)!,
           [],
-          SdkTypeProgrammer.write_object(project)(importer)(object),
+          SdkTypeProgrammer.write_object(project)(importer)(object) as TypeNode,
         ),
         writeComment([])(object.description ?? null, object.jsDocTags),
       );