@nestia/migrate 11.2.1 → 12.0.0-dev.20260520.1

package/src/programmers/NestiaMigrateImportProgrammer.ts

@@ -1,4 +1,5 @@
-import ts from "typescript";
+import { TypeScriptFactory } from "@nestia/factory";
+import ts from "../internal/ts";
 
 import { TypeLiteralFactory } from "../factories/TypeLiteralFactory";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -28,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 ts.factory.createTypeReferenceNode(
+    return TypeScriptFactory.createTypeReferenceNode(
       namespace?.length
-        ? ts.factory.createQualifiedName(
-            ts.factory.createIdentifier(namespace),
-            ts.factory.createIdentifier(file),
+        ? TypeScriptFactory.createQualifiedName(
+            TypeScriptFactory.createIdentifier(namespace),
+            TypeScriptFactory.createIdentifier(file),
           )
         : name,
     );
@@ -44,7 +45,7 @@ export class NestiaMigrateImportProgrammer {
       library: "typia",
       name: "tags",
     });
-    return ts.factory.createTypeReferenceNode(
+    return TypeScriptFactory.createTypeReferenceNode(
       `${instance}.${type}`,
       arg === undefined ? [] : [TypeLiteralFactory.generate(arg)],
     );
@@ -56,26 +57,26 @@ export class NestiaMigrateImportProgrammer {
   ): ts.Statement[] {
     return [
       ...[...this.external_.entries()].map(([library, props]) =>
-        ts.factory.createImportDeclaration(
+        TypeScriptFactory.createImportDeclaration(
           undefined,
-          ts.factory.createImportClause(
+          TypeScriptFactory.createImportClause(
             false,
             props.default !== null
-              ? ts.factory.createIdentifier(props.default)
+              ? TypeScriptFactory.createIdentifier(props.default)
               : undefined,
             props.instances.size
-              ? ts.factory.createNamedImports(
+              ? TypeScriptFactory.createNamedImports(
                   [...props.instances].map((i) =>
-                    ts.factory.createImportSpecifier(
+                    TypeScriptFactory.createImportSpecifier(
                       false,
                       undefined,
-                      ts.factory.createIdentifier(i),
+                      TypeScriptFactory.createIdentifier(i),
                     ),
                   ),
                 )
               : undefined,
           ),
-          ts.factory.createStringLiteral(library),
+          TypeScriptFactory.createStringLiteral(library),
         ),
       ),
       ...(this.external_.size && this.dtos_.size
@@ -86,20 +87,20 @@ export class NestiaMigrateImportProgrammer {
           current ? (name) => name !== current!.split(".")[0] : () => true,
         )
         .map((i) =>
-          ts.factory.createImportDeclaration(
+          TypeScriptFactory.createImportDeclaration(
             undefined,
-            ts.factory.createImportClause(
+            TypeScriptFactory.createImportClause(
               false,
               undefined,
-              ts.factory.createNamedImports([
-                ts.factory.createImportSpecifier(
+              TypeScriptFactory.createNamedImports([
+                TypeScriptFactory.createImportSpecifier(
                   false,
                   undefined,
-                  ts.factory.createIdentifier(i),
+                  TypeScriptFactory.createIdentifier(i),
                 ),
               ]),
             ),
-            ts.factory.createStringLiteral(dtoPath(i)),
+            TypeScriptFactory.createStringLiteral(dtoPath(i)),
           ),
         ),
     ];

package/src/programmers/NestiaMigrateNestControllerProgrammer.ts

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

package/src/programmers/NestiaMigrateNestMethodProgrammer.ts

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

package/src/programmers/NestiaMigrateNestModuleProgrammer.ts

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

package/src/programmers/NestiaMigrateNestProgrammer.ts

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