@nestia/migrate 12.0.0-dev.20260612.1 → 12.0.0-dev.20260619.1

package/src/programmers/NestiaMigrateImportProgrammer.ts

@@ -1,7 +1,7 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import ts from "../internal/ts";
+import { factory } from "@ttsc/factory";
 
 import { TypeLiteralFactory } from "../factories/TypeLiteralFactory";
+import ts from "../internal/ts";
 import { FilePrinter } from "../utils/FilePrinter";
 import { MapUtil } from "../utils/MapUtil";
 
@@ -29,11 +29,11 @@ export class NestiaMigrateImportProgrammer {
   public dto(name: string, namespace?: string): ts.TypeReferenceNode {
     const file: string = name.split(".")[0]!;
     this.dtos_.add(file);
-    return TypeScriptFactory.createTypeReferenceNode(
+    return factory.createTypeReferenceNode(
       namespace?.length
-        ? TypeScriptFactory.createQualifiedName(
-            TypeScriptFactory.createIdentifier(namespace),
-            TypeScriptFactory.createIdentifier(file),
+        ? factory.createQualifiedName(
+            factory.createIdentifier(namespace),
+            factory.createIdentifier(file),
           )
         : name,
     );
@@ -45,7 +45,7 @@ export class NestiaMigrateImportProgrammer {
       library: "typia",
       name: "tags",
     });
-    return TypeScriptFactory.createTypeReferenceNode(
+    return factory.createTypeReferenceNode(
       `${instance}.${type}`,
       arg === undefined ? [] : [TypeLiteralFactory.generate(arg)],
     );
@@ -57,26 +57,26 @@ export class NestiaMigrateImportProgrammer {
   ): ts.Statement[] {
     return [
       ...[...this.external_.entries()].map(([library, props]) =>
-        TypeScriptFactory.createImportDeclaration(
+        factory.createImportDeclaration(
           undefined,
-          TypeScriptFactory.createImportClause(
+          factory.createImportClause(
             false,
             props.default !== null
-              ? TypeScriptFactory.createIdentifier(props.default)
+              ? factory.createIdentifier(props.default)
               : undefined,
             props.instances.size
-              ? TypeScriptFactory.createNamedImports(
+              ? factory.createNamedImports(
                   [...props.instances].map((i) =>
-                    TypeScriptFactory.createImportSpecifier(
+                    factory.createImportSpecifier(
                       false,
                       undefined,
-                      TypeScriptFactory.createIdentifier(i),
+                      factory.createIdentifier(i),
                     ),
                   ),
                 )
               : undefined,
           ),
-          TypeScriptFactory.createStringLiteral(library),
+          factory.createStringLiteral(library),
         ),
       ),
       ...(this.external_.size && this.dtos_.size
@@ -87,20 +87,20 @@ export class NestiaMigrateImportProgrammer {
           current ? (name) => name !== current!.split(".")[0] : () => true,
         )
         .map((i) =>
-          TypeScriptFactory.createImportDeclaration(
+          factory.createImportDeclaration(
             undefined,
-            TypeScriptFactory.createImportClause(
+            factory.createImportClause(
               false,
               undefined,
-              TypeScriptFactory.createNamedImports([
-                TypeScriptFactory.createImportSpecifier(
+              factory.createNamedImports([
+                factory.createImportSpecifier(
                   false,
                   undefined,
-                  TypeScriptFactory.createIdentifier(i),
+                  factory.createIdentifier(i),
                 ),
               ]),
             ),
-            TypeScriptFactory.createStringLiteral(dtoPath(i)),
+            factory.createStringLiteral(dtoPath(i)),
           ),
         ),
     ];

package/src/programmers/NestiaMigrateNestControllerProgrammer.ts

@@ -1,7 +1,7 @@
-import { TypeScriptFactory } from "@nestia/factory";
+import { SyntaxKind, factory } from "@ttsc/factory";
 import { OpenApi } from "@typia/interface";
-import ts from "../internal/ts";
 
+import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -19,11 +19,11 @@ export namespace NestiaMigrateNestControllerProgrammer {
   export const write = (props: IProps): ts.Statement[] => {
     const importer: NestiaMigrateImportProgrammer =
       new NestiaMigrateImportProgrammer();
-    const $class = TypeScriptFactory.createClassDeclaration(
+    const $class = factory.createClassDeclaration(
       [
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
-            TypeScriptFactory.createIdentifier(
+        factory.createDecorator(
+          factory.createCallExpression(
+            factory.createIdentifier(
               importer.external({
                 type: "instance",
                 library: "@nestjs/common",
@@ -31,10 +31,10 @@ export namespace NestiaMigrateNestControllerProgrammer {
               }),
             ),
             [],
-            [TypeScriptFactory.createStringLiteral(props.controller.path)],
+            [factory.createStringLiteral(props.controller.path)],
           ),
         ),
-        TypeScriptFactory.createToken(ts.SyntaxKind.ExportKeyword),
+        factory.createToken(SyntaxKind.ExportKeyword),
       ],
       props.controller.name,
       [],

package/src/programmers/NestiaMigrateNestMethodProgrammer.ts

@@ -1,14 +1,12 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import {
-  ExpressionFactory,
-  IdentifierFactory,
-  LiteralFactory,
-  TypeFactory,
-} from "@nestia/factory";
+import { SyntaxKind, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "../internal/ts";
 import { OpenApi } from "typia";
 
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { LiteralFactory } from "../factories/LiteralFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -34,51 +32,48 @@ export namespace NestiaMigrateNestMethodProgrammer {
         })
       : TypeFactory.keyword("void");
 
-    const method: ts.MethodDeclaration =
-      TypeScriptFactory.createMethodDeclaration(
+    const method: ts.MethodDeclaration = factory.createMethodDeclaration(
+      [
+        ...writeMethodDecorators(ctx),
+        factory.createToken(SyntaxKind.PublicKeyword),
+        factory.createToken(SyntaxKind.AsyncKeyword),
+      ],
+      undefined,
+      ctx.route.accessor.at(-1)!,
+      undefined,
+      undefined,
+      writeParameters(ctx),
+      factory.createTypeReferenceNode("Promise", [output]),
+      factory.createBlock(
         [
-          ...writeMethodDecorators(ctx),
-          TypeScriptFactory.createToken(ts.SyntaxKind.PublicKeyword),
-          TypeScriptFactory.createToken(ts.SyntaxKind.AsyncKeyword),
-        ],
-        undefined,
-        ctx.route.accessor.at(-1)!,
-        undefined,
-        undefined,
-        writeParameters(ctx),
-        TypeScriptFactory.createTypeReferenceNode("Promise", [output]),
-        TypeScriptFactory.createBlock(
-          [
-            ...[
-              ...ctx.route.parameters.map((p) => p.key),
-              ...(ctx.route.headers ? ["headers"] : []),
-              ...(ctx.route.query ? ["query"] : []),
-              ...(ctx.route.body ? ["body"] : []),
-            ].map((str) =>
-              TypeScriptFactory.createExpressionStatement(
-                TypeScriptFactory.createIdentifier(str),
-              ),
-            ),
-            TypeScriptFactory.createReturnStatement(
-              TypeScriptFactory.createCallExpression(
-                IdentifierFactory.access(
-                  TypeScriptFactory.createIdentifier(
-                    ctx.importer.external({
-                      type: "default",
-                      library: "typia",
-                      name: "typia",
-                    }),
-                  ),
-                  "random",
+          ...[
+            ...ctx.route.parameters.map((p) => p.key),
+            ...(ctx.route.headers ? ["headers"] : []),
+            ...(ctx.route.query ? ["query"] : []),
+            ...(ctx.route.body ? ["body"] : []),
+          ].map((str) =>
+            factory.createExpressionStatement(factory.createIdentifier(str)),
+          ),
+          factory.createReturnStatement(
+            factory.createCallExpression(
+              IdentifierFactory.access(
+                factory.createIdentifier(
+                  ctx.importer.external({
+                    type: "default",
+                    library: "typia",
+                    name: "typia",
+                  }),
                 ),
-                [output],
-                undefined,
+                "random",
               ),
+              [output],
+              undefined,
             ),
-          ],
-          true,
-        ),
-      );
+          ),
+        ],
+        true,
+      ),
+    );
     return FilePrinter.description(
       method,
       writeDescription(ctx.config, ctx.route),
@@ -96,7 +91,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
 
   const writeMethodDecorators = (ctx: IContext): ts.Decorator[] => {
     const external = (lib: string, instance: string): ts.Identifier =>
-      TypeScriptFactory.createIdentifier(
+      factory.createIdentifier(
         ctx.importer.external({
           type: "instance",
           library: lib,
@@ -116,8 +111,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
     // HUMAN-ONLY
     if (ctx.route.operation()["x-samchon-human"] === true)
       decorators.push(
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestia/core", "HumanRoute"),
             undefined,
             undefined,
@@ -132,15 +127,15 @@ export namespace NestiaMigrateNestMethodProgrammer {
       .filter((str) => !!str.length)
       .join("/");
     const router = (instance: string) =>
-      TypeScriptFactory.createDecorator(
-        TypeScriptFactory.createCallExpression(
+      factory.createDecorator(
+        factory.createCallExpression(
           IdentifierFactory.access(
             external("@nestia/core", instance),
             StringUtil.capitalize(ctx.route.method),
           ),
           [],
           localPath.length
-            ? [TypeScriptFactory.createStringLiteral(localPath)]
+            ? [factory.createStringLiteral(localPath)]
             : undefined,
         ),
       );
@@ -148,11 +143,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("EncryptedRoute"));
     else if (ctx.route.success?.type === "text/plain")
       decorators.push(
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestjs/common", StringUtil.capitalize(ctx.route.method)),
             [],
-            [TypeScriptFactory.createStringLiteral(ctx.route.path)],
+            [factory.createStringLiteral(ctx.route.path)],
           ),
         ),
       );
@@ -160,11 +155,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("TypedQuery"));
     else if (ctx.route.method === "head")
       decorators.push(
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestjs/common", "Head"),
             [],
-            [TypeScriptFactory.createStringLiteral(ctx.route.path)],
+            [factory.createStringLiteral(ctx.route.path)],
           ),
         ),
       );
@@ -175,8 +170,8 @@ export namespace NestiaMigrateNestMethodProgrammer {
       decorators.push(router("TypedRoute"));
     for (const [key, value] of Object.entries(ctx.route.exceptions ?? {}))
       decorators.push(
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             external("@nestia/core", "TypedException"),
             [
               NestiaMigrateSchemaProgrammer.write({
@@ -187,14 +182,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
             ],
             [
               isNaN(Number(key))
-                ? TypeScriptFactory.createStringLiteral(key)
+                ? factory.createStringLiteral(key)
                 : ExpressionFactory.number(Number(key)),
               ...(value.response().description?.length
-                ? [
-                    TypeScriptFactory.createStringLiteral(
-                      value.response().description!,
-                    ),
-                  ]
+                ? [factory.createStringLiteral(value.response().description!)]
                 : []),
             ],
           ),
@@ -205,12 +196,12 @@ export namespace NestiaMigrateNestMethodProgrammer {
 
   const writeParameters = (ctx: IContext): ts.ParameterDeclaration[] => [
     ...ctx.route.parameters.map((p) =>
-      TypeScriptFactory.createParameterDeclaration(
+      factory.createParameterDeclaration(
         [
           ...writeExampleDecorators("Parameter")(ctx.importer)(p.parameter()),
-          TypeScriptFactory.createDecorator(
-            TypeScriptFactory.createCallExpression(
-              TypeScriptFactory.createIdentifier(
+          factory.createDecorator(
+            factory.createCallExpression(
+              factory.createIdentifier(
                 ctx.importer.external({
                   type: "instance",
                   library: "@nestia/core",
@@ -218,7 +209,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
                 }),
               ),
               undefined,
-              [TypeScriptFactory.createStringLiteral(p.key)],
+              [factory.createStringLiteral(p.key)],
             ),
           ),
         ],
@@ -278,14 +269,14 @@ export namespace NestiaMigrateNestMethodProgrammer {
             arguments:
               ctx.route.body.type === "multipart/form-data"
                 ? [
-                    TypeScriptFactory.createArrowFunction(
+                    factory.createArrowFunction(
                       undefined,
                       undefined,
                       [],
                       undefined,
                       undefined,
-                      TypeScriptFactory.createCallExpression(
-                        TypeScriptFactory.createIdentifier(
+                      factory.createCallExpression(
+                        factory.createIdentifier(
                           ctx.importer.external({
                             type: "default",
                             library: "multer",
@@ -326,7 +317,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
       example?: any;
       examples?: Record<string, any>;
     }): ts.ParameterDeclaration => {
-      const instance = TypeScriptFactory.createIdentifier(
+      const instance = factory.createIdentifier(
         importer.external({
           type: "instance",
           library: "@nestia/core",
@@ -336,11 +327,11 @@ export namespace NestiaMigrateNestMethodProgrammer {
               : accessor.method[0],
         }),
       );
-      return TypeScriptFactory.createParameterDeclaration(
+      return factory.createParameterDeclaration(
         [
           ...writeExampleDecorators("Parameter")(importer)(props),
-          TypeScriptFactory.createDecorator(
-            TypeScriptFactory.createCallExpression(
+          factory.createDecorator(
+            factory.createCallExpression(
               typeof accessor.method === "string"
                 ? instance
                 : IdentifierFactory.access(instance, accessor.method[1]),
@@ -352,7 +343,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
         undefined,
         accessor.variable,
         props.required === false
-          ? TypeScriptFactory.createToken(ts.SyntaxKind.QuestionToken)
+          ? factory.createToken(SyntaxKind.QuestionToken)
           : undefined,
         NestiaMigrateSchemaProgrammer.write({
           components,
@@ -371,10 +362,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
     }): ts.Decorator[] => [
       ...(media.example !== undefined
         ? [
-            TypeScriptFactory.createDecorator(
-              TypeScriptFactory.createCallExpression(
+            factory.createDecorator(
+              factory.createCallExpression(
                 IdentifierFactory.access(
-                  TypeScriptFactory.createIdentifier(
+                  factory.createIdentifier(
                     importer.external({
                       type: "instance",
                       library: "@nestia/core",
@@ -390,10 +381,10 @@ export namespace NestiaMigrateNestMethodProgrammer {
           ]
         : []),
       ...Object.entries(media.examples ?? {}).map(([key, value]) =>
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
+        factory.createDecorator(
+          factory.createCallExpression(
             IdentifierFactory.access(
-              TypeScriptFactory.createIdentifier(
+              factory.createIdentifier(
                 importer.external({
                   type: "instance",
                   library: "@nestia/core",
@@ -403,10 +394,7 @@ export namespace NestiaMigrateNestMethodProgrammer {
               kind,
             ),
             [],
-            [
-              TypeScriptFactory.createStringLiteral(key),
-              LiteralFactory.write(value),
-            ],
+            [factory.createStringLiteral(key), LiteralFactory.write(value)],
           ),
         ),
       ),

package/src/programmers/NestiaMigrateNestModuleProgrammer.ts

@@ -1,6 +1,6 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import ts from "../internal/ts";
+import { SyntaxKind, factory } from "@ttsc/factory";
 
+import ts from "../internal/ts";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
 
@@ -14,21 +14,19 @@ export namespace NestiaMigrateNestModuleProgrammer {
       $import(`${c.location.replace("src/", "./")}/${c.name}`)(c.name),
     ),
     ...(controllers.length ? [FilePrinter.newLine()] : []),
-    TypeScriptFactory.createClassDeclaration(
+    factory.createClassDeclaration(
       [
-        TypeScriptFactory.createDecorator(
-          TypeScriptFactory.createCallExpression(
-            TypeScriptFactory.createIdentifier("Module"),
+        factory.createDecorator(
+          factory.createCallExpression(
+            factory.createIdentifier("Module"),
             undefined,
             [
-              TypeScriptFactory.createObjectLiteralExpression(
+              factory.createObjectLiteralExpression(
                 [
-                  TypeScriptFactory.createPropertyAssignment(
-                    TypeScriptFactory.createIdentifier("controllers"),
-                    TypeScriptFactory.createArrayLiteralExpression(
-                      controllers.map((c) =>
-                        TypeScriptFactory.createIdentifier(c.name),
-                      ),
+                  factory.createPropertyAssignment(
+                    factory.createIdentifier("controllers"),
+                    factory.createArrayLiteralExpression(
+                      controllers.map((c) => factory.createIdentifier(c.name)),
                       true,
                     ),
                   ),
@@ -38,7 +36,7 @@ export namespace NestiaMigrateNestModuleProgrammer {
             ],
           ),
         ),
-        TypeScriptFactory.createToken(ts.SyntaxKind.ExportKeyword),
+        factory.createToken(SyntaxKind.ExportKeyword),
       ],
       "MyModule",
       undefined,
@@ -49,18 +47,18 @@ export namespace NestiaMigrateNestModuleProgrammer {
 }
 
 const $import = (file: string) => (instance: string) =>
-  TypeScriptFactory.createImportDeclaration(
+  factory.createImportDeclaration(
     undefined,
-    TypeScriptFactory.createImportClause(
+    factory.createImportClause(
       false,
       undefined,
-      TypeScriptFactory.createNamedImports([
-        TypeScriptFactory.createImportSpecifier(
+      factory.createNamedImports([
+        factory.createImportSpecifier(
           false,
           undefined,
-          TypeScriptFactory.createIdentifier(instance),
+          factory.createIdentifier(instance),
         ),
       ]),
     ),
-    TypeScriptFactory.createStringLiteral(file),
+    factory.createStringLiteral(file),
   );

package/src/programmers/NestiaMigrateNestProgrammer.ts

@@ -1,7 +1,7 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import ts from "../internal/ts";
+import { NodeFlags, SyntaxKind, factory } from "@ttsc/factory";
 
 import { NestiaMigrateControllerAnalyzer } from "../analyzers/NestiaMigrateControllerAnalyzer";
+import ts from "../internal/ts";
 import { INestiaMigrateContext } from "../structures/INestiaMigrateContext";
 import { INestiaMigrateController } from "../structures/INestiaMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -75,11 +75,11 @@ export namespace NestiaMigrateNestProgrammer {
         for (const child of modulo.children.values())
           internal.push(...iterate(importer)(child));
         output.push(
-          TypeScriptFactory.createModuleDeclaration(
-            [TypeScriptFactory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            TypeScriptFactory.createIdentifier(modulo.name),
-            TypeScriptFactory.createModuleBlock(internal),
-            ts.NodeFlags.Namespace,
+          factory.createModuleDeclaration(
+            [factory.createModifier(SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(modulo.name),
+            factory.createModuleBlock(internal),
+            NodeFlags.Namespace,
           ),
         );
       }