@nestia/migrate 11.2.1 → 12.0.0-dev.20260520.1

package/src/programmers/NestiaMigrateApiSimulationProgrammer.ts

@@ -1,6 +1,7 @@
-import { IdentifierFactory, StatementFactory, TypeFactory } from "@typia/core";
+import { TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory, StatementFactory, TypeFactory } 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";
@@ -27,15 +28,15 @@ export namespace NestiaMigrateApiSimulationProgrammer {
       : TypeFactory.keyword("void");
     return constant(
       "random",
-      ts.factory.createArrowFunction(
+      TypeScriptFactory.createArrowFunction(
         undefined,
         undefined,
         [],
         output,
         undefined,
-        ts.factory.createCallExpression(
+        TypeScriptFactory.createCallExpression(
           IdentifierFactory.access(
-            ts.factory.createIdentifier(
+            TypeScriptFactory.createIdentifier(
               ctx.importer.external({
                 type: "default",
                 library: "typia",
@@ -53,14 +54,14 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 
   export const simulate = (ctx: IContext): ts.VariableStatement => {
     const caller = () =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("random"),
+      TypeScriptFactory.createCallExpression(
+        TypeScriptFactory.createIdentifier("random"),
         undefined,
         undefined,
       );
     return constant(
       "simulate",
-      ts.factory.createArrowFunction(
+      TypeScriptFactory.createArrowFunction(
         undefined,
         undefined,
         NestiaMigrateApiFunctionProgrammer.writeParameterDeclarations(
@@ -71,12 +72,12 @@ export namespace NestiaMigrateApiSimulationProgrammer {
             ? "_connection"
             : undefined,
         ),
-        ts.factory.createTypeReferenceNode(
+        TypeScriptFactory.createTypeReferenceNode(
           ctx.route.success ? "Response" : "void",
         ),
         undefined,
-        ts.factory.createBlock(
-          [...assert(ctx), ts.factory.createReturnStatement(caller())],
+        TypeScriptFactory.createBlock(
+          [...assert(ctx), TypeScriptFactory.createReturnStatement(caller())],
           true,
         ),
       ),
@@ -86,8 +87,11 @@ export namespace NestiaMigrateApiSimulationProgrammer {
   const assert = (ctx: IContext): ts.Statement[] => {
     const property = (key: string) =>
       ctx.config.keyword === true
-        ? IdentifierFactory.access(ts.factory.createIdentifier("props"), key)
-        : ts.factory.createIdentifier(key);
+        ? IdentifierFactory.access(
+            TypeScriptFactory.createIdentifier("props"),
+            key,
+          )
+        : TypeScriptFactory.createIdentifier(key);
     const parameters = [
       ...ctx.route.parameters.map((p) => ({
         category: "param",
@@ -129,9 +133,9 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 
     const validator = StatementFactory.constant({
       name: "assert",
-      value: ts.factory.createCallExpression(
+      value: TypeScriptFactory.createCallExpression(
         IdentifierFactory.access(
-          ts.factory.createIdentifier(
+          TypeScriptFactory.createIdentifier(
             ctx.importer.external({
               type: "instance",
               library: `@nestia/fetcher`,
@@ -142,26 +146,26 @@ export namespace NestiaMigrateApiSimulationProgrammer {
         ),
         undefined,
         [
-          ts.factory.createObjectLiteralExpression(
+          TypeScriptFactory.createObjectLiteralExpression(
             [
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "method",
-                ts.factory.createIdentifier("METADATA.method"),
+                TypeScriptFactory.createIdentifier("METADATA.method"),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "host",
-                ts.factory.createIdentifier("connection.host"),
+                TypeScriptFactory.createIdentifier("connection.host"),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "path",
                 NestiaMigrateApiNamespaceProgrammer.writePathCallExpression(
                   ctx.config,
                   ctx.route,
                 ),
               ),
-              ts.factory.createPropertyAssignment(
+              TypeScriptFactory.createPropertyAssignment(
                 "contentType",
-                ts.factory.createStringLiteral(
+                TypeScriptFactory.createStringLiteral(
                   ctx.route.success?.type ?? "application/json",
                 ),
               ),
@@ -171,30 +175,30 @@ export namespace NestiaMigrateApiSimulationProgrammer {
         ],
       ),
     });
-    const individual = parameters
+    const individual: ts.Statement[] = parameters
       .map((p) =>
-        ts.factory.createCallExpression(
+        TypeScriptFactory.createCallExpression(
           (() => {
             const base = IdentifierFactory.access(
-              ts.factory.createIdentifier("assert"),
+              TypeScriptFactory.createIdentifier("assert"),
               p.category,
             );
             if (p.category !== "param") return base;
-            return ts.factory.createCallExpression(base, undefined, [
-              ts.factory.createStringLiteral(p.name),
+            return TypeScriptFactory.createCallExpression(base, undefined, [
+              TypeScriptFactory.createStringLiteral(p.name),
             ]);
           })(),
           undefined,
           [
-            ts.factory.createArrowFunction(
+            TypeScriptFactory.createArrowFunction(
               undefined,
               undefined,
               [],
               undefined,
               undefined,
-              ts.factory.createCallExpression(
+              TypeScriptFactory.createCallExpression(
                 IdentifierFactory.access(
-                  ts.factory.createIdentifier(
+                  TypeScriptFactory.createIdentifier(
                     ctx.importer.external({
                       type: "default",
                       library: "typia",
@@ -206,7 +210,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                 undefined,
                 [
                   p.category === "headers"
-                    ? ts.factory.createIdentifier("connection.headers")
+                    ? TypeScriptFactory.createIdentifier("connection.headers")
                     : property(p.name),
                 ],
               ),
@@ -214,7 +218,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
           ],
         ),
       )
-      .map(ts.factory.createExpressionStatement);
+      .map(TypeScriptFactory.createExpressionStatement) as ts.Statement[];
     return [validator, tryAndCatch(ctx.importer, individual)];
   };
 
@@ -222,17 +226,17 @@ export namespace NestiaMigrateApiSimulationProgrammer {
     importer: NestiaMigrateImportProgrammer,
     individual: ts.Statement[],
   ) =>
-    ts.factory.createTryStatement(
-      ts.factory.createBlock(individual, true),
-      ts.factory.createCatchClause(
+    TypeScriptFactory.createTryStatement(
+      TypeScriptFactory.createBlock(individual, true),
+      TypeScriptFactory.createCatchClause(
         "exp",
-        ts.factory.createBlock(
+        TypeScriptFactory.createBlock(
           [
-            ts.factory.createIfStatement(
-              ts.factory.createLogicalNot(
-                ts.factory.createCallExpression(
+            TypeScriptFactory.createIfStatement(
+              TypeScriptFactory.createLogicalNot(
+                TypeScriptFactory.createCallExpression(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(
+                    TypeScriptFactory.createIdentifier(
                       importer.external({
                         type: "default",
                         library: "typia",
@@ -242,7 +246,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                     "is",
                   ),
                   [
-                    ts.factory.createTypeReferenceNode(
+                    TypeScriptFactory.createTypeReferenceNode(
                       importer.external({
                         type: "instance",
                         library: "@nestia/fetcher",
@@ -250,32 +254,34 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                       }),
                     ),
                   ],
-                  [ts.factory.createIdentifier("exp")],
+                  [TypeScriptFactory.createIdentifier("exp")],
                 ),
               ),
-              ts.factory.createThrowStatement(
-                ts.factory.createIdentifier("exp"),
+              TypeScriptFactory.createThrowStatement(
+                TypeScriptFactory.createIdentifier("exp"),
               ),
             ),
-            ts.factory.createReturnStatement(
-              ts.factory.createAsExpression(
-                ts.factory.createObjectLiteralExpression(
+            TypeScriptFactory.createReturnStatement(
+              TypeScriptFactory.createAsExpression(
+                TypeScriptFactory.createObjectLiteralExpression(
                   [
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "success",
-                      ts.factory.createFalse(),
+                      TypeScriptFactory.createFalse(),
                     ),
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "status",
-                      ts.factory.createIdentifier("exp.status"),
+                      TypeScriptFactory.createIdentifier("exp.status"),
                     ),
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "headers",
-                      ts.factory.createIdentifier("exp.headers"),
+                      TypeScriptFactory.createIdentifier("exp.headers"),
                     ),
-                    ts.factory.createPropertyAssignment(
+                    TypeScriptFactory.createPropertyAssignment(
                       "data",
-                      ts.factory.createIdentifier("exp.toJSON().message"),
+                      TypeScriptFactory.createIdentifier(
+                        "exp.toJSON().message",
+                      ),
                     ),
                   ],
                   true,
@@ -292,12 +298,12 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 }
 
 const constant = (name: string, expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    ts.factory.createVariableDeclarationList(
+  TypeScriptFactory.createVariableStatement(
+    [TypeScriptFactory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    TypeScriptFactory.createVariableDeclarationList(
       [
-        ts.factory.createVariableDeclaration(
-          ts.factory.createIdentifier(name),
+        TypeScriptFactory.createVariableDeclaration(
+          TypeScriptFactory.createIdentifier(name),
           undefined,
           undefined,
           expression,

package/src/programmers/NestiaMigrateApiStartProgrammer.ts

@@ -1,6 +1,7 @@
-import { IdentifierFactory, StatementFactory } from "@typia/core";
+import { TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory, StatementFactory } from "@nestia/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "typescript";
+import ts from "../internal/ts";
 
 import { INestiaMigrateContext } from "../structures/INestiaMigrateContext";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -23,25 +24,25 @@ export namespace NestiaMigrateApiStartProgrammer {
         (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,
       ),
       FilePrinter.newLine(),
-      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("TestGlobal"),
+              TypeScriptFactory.createIdentifier("TestGlobal"),
             ),
           ]),
         ),
-        ts.factory.createStringLiteral("./TestGlobal"),
+        TypeScriptFactory.createStringLiteral("./TestGlobal"),
         undefined,
       ),
       FilePrinter.newLine(),
       main,
-      ts.factory.createExpressionStatement(writeStarter()),
+      TypeScriptFactory.createExpressionStatement(writeStarter()),
     ];
     return {
       "test/start.ts": FilePrinter.write({ statements }),
@@ -55,13 +56,13 @@ export namespace NestiaMigrateApiStartProgrammer {
   ): ts.VariableStatement =>
     StatementFactory.constant({
       name: "main",
-      value: ts.factory.createArrowFunction(
-        [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
+      value: TypeScriptFactory.createArrowFunction(
+        [TypeScriptFactory.createToken(ts.SyntaxKind.AsyncKeyword)],
         undefined,
         [],
         undefined,
         undefined,
-        ts.factory.createBlock(
+        TypeScriptFactory.createBlock(
           [
             writeConnection(ctx, importer),
             ...NestiaMigrateE2eFunctionProgrammer.writeBody({
@@ -80,31 +81,31 @@ export namespace NestiaMigrateApiStartProgrammer {
     ctx: INestiaMigrateContext,
     importer: NestiaMigrateImportProgrammer,
   ): ts.VariableStatement =>
-    ts.factory.createVariableStatement(
+    TypeScriptFactory.createVariableStatement(
       undefined,
-      ts.factory.createVariableDeclarationList(
+      TypeScriptFactory.createVariableDeclarationList(
         [
-          ts.factory.createVariableDeclaration(
+          TypeScriptFactory.createVariableDeclaration(
             "connection",
             undefined,
-            ts.factory.createTypeReferenceNode(
-              ts.factory.createQualifiedName(
-                ts.factory.createIdentifier(
+            TypeScriptFactory.createTypeReferenceNode(
+              TypeScriptFactory.createQualifiedName(
+                TypeScriptFactory.createIdentifier(
                   importer.external({
                     type: "default",
                     library: "@ORGANIZATION/PROJECT-api",
                     name: "api",
                   }),
                 ),
-                ts.factory.createIdentifier("IConnection"),
+                TypeScriptFactory.createIdentifier("IConnection"),
               ),
             ),
-            ts.factory.createObjectLiteralExpression(
+            TypeScriptFactory.createObjectLiteralExpression(
               [
-                ts.factory.createSpreadAssignment(
-                  ts.factory.createCallExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("TestGlobal"),
+                TypeScriptFactory.createSpreadAssignment(
+                  TypeScriptFactory.createCallExpression(
+                    TypeScriptFactory.createPropertyAccessExpression(
+                      TypeScriptFactory.createIdentifier("TestGlobal"),
                       "connection",
                     ),
                     undefined,
@@ -113,9 +114,9 @@ export namespace NestiaMigrateApiStartProgrammer {
                 ),
                 ...(ctx.application.document().servers?.[0]?.url?.length
                   ? [
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "host",
-                        ts.factory.createStringLiteral(
+                        TypeScriptFactory.createStringLiteral(
                           ctx.application.document().servers![0]!.url,
                         ),
                       ),
@@ -123,9 +124,9 @@ export namespace NestiaMigrateApiStartProgrammer {
                   : []),
                 ...(ctx.config.simulate === true
                   ? [
-                      ts.factory.createPropertyAssignment(
+                      TypeScriptFactory.createPropertyAssignment(
                         "simulate",
-                        ts.factory.createTrue(),
+                        TypeScriptFactory.createTrue(),
                       ),
                     ]
                   : []),
@@ -139,10 +140,10 @@ export namespace NestiaMigrateApiStartProgrammer {
     );
 
   const writeStarter = (): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("main"),
+    TypeScriptFactory.createCallExpression(
+      TypeScriptFactory.createPropertyAccessExpression(
+        TypeScriptFactory.createCallExpression(
+          TypeScriptFactory.createIdentifier("main"),
           undefined,
           undefined,
         ),
@@ -150,34 +151,34 @@ export namespace NestiaMigrateApiStartProgrammer {
       ),
       undefined,
       [
-        ts.factory.createArrowFunction(
+        TypeScriptFactory.createArrowFunction(
           undefined,
           undefined,
           [IdentifierFactory.parameter("exp")],
           undefined,
           undefined,
-          ts.factory.createBlock(
+          TypeScriptFactory.createBlock(
             [
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("console"),
+              TypeScriptFactory.createExpressionStatement(
+                TypeScriptFactory.createCallExpression(
+                  TypeScriptFactory.createPropertyAccessExpression(
+                    TypeScriptFactory.createIdentifier("console"),
                     "log",
                   ),
                   undefined,
-                  [ts.factory.createIdentifier("exp")],
+                  [TypeScriptFactory.createIdentifier("exp")],
                 ),
               ),
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("process"),
+              TypeScriptFactory.createExpressionStatement(
+                TypeScriptFactory.createCallExpression(
+                  TypeScriptFactory.createPropertyAccessExpression(
+                    TypeScriptFactory.createIdentifier("process"),
                     "exit",
                   ),
                   undefined,
                   [
-                    ts.factory.createPrefixMinus(
-                      ts.factory.createNumericLiteral("1"),
+                    TypeScriptFactory.createPrefixMinus(
+                      TypeScriptFactory.createNumericLiteral("1"),
                     ),
                   ],
                 ),

package/src/programmers/NestiaMigrateDtoProgrammer.ts

@@ -1,6 +1,7 @@
+import { TypeScriptFactory } from "@nestia/factory";
 import { OpenApi } from "@typia/interface";
 import { IPointer } from "tstl";
-import ts from "typescript";
+import ts from "../internal/ts";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -65,8 +66,8 @@ export namespace NestiaMigrateDtoProgrammer {
     (importer: NestiaMigrateImportProgrammer) =>
     (key: string, value: OpenApi.IJsonSchema) =>
       FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        TypeScriptFactory.createTypeAliasDeclaration(
+          [TypeScriptFactory.createToken(ts.SyntaxKind.ExportKeyword)],
           key.split(".").at(-1)!,
           [],
           NestiaMigrateSchemaProgrammer.write({

package/src/programmers/NestiaMigrateE2eFileProgrammer.ts

@@ -1,6 +1,7 @@
-import { IdentifierFactory, LiteralFactory } from "@typia/core";
+import { TypeScriptFactory } from "@nestia/factory";
+import { IdentifierFactory, LiteralFactory } 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";
@@ -16,10 +17,10 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
   }
 
   export const write = (ctx: IContext): ts.FunctionDeclaration =>
-    ts.factory.createFunctionDeclaration(
+    TypeScriptFactory.createFunctionDeclaration(
       [
-        ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-        ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+        TypeScriptFactory.createModifier(ts.SyntaxKind.ExportKeyword),
+        TypeScriptFactory.createModifier(ts.SyntaxKind.AsyncKeyword),
       ],
       undefined,
       ["test", "api", ...ctx.route.accessor].join("_"),
@@ -27,30 +28,30 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       [
         IdentifierFactory.parameter(
           "connection",
-          ts.factory.createTypeReferenceNode(
-            ts.factory.createQualifiedName(
-              ts.factory.createIdentifier(
+          TypeScriptFactory.createTypeReferenceNode(
+            TypeScriptFactory.createQualifiedName(
+              TypeScriptFactory.createIdentifier(
                 ctx.importer.external({
                   type: "default",
                   library: "@ORGANIZATION/PROJECT-api",
                   name: "api",
                 }),
               ),
-              ts.factory.createIdentifier("IConnection"),
+              TypeScriptFactory.createIdentifier("IConnection"),
             ),
           ),
         ),
       ],
       undefined,
-      ts.factory.createBlock(writeBody(ctx), true),
+      TypeScriptFactory.createBlock(writeBody(ctx), true),
     );
 
   export const writeBody = (ctx: IContext): ts.Statement[] => [
-    ts.factory.createVariableStatement(
+    TypeScriptFactory.createVariableStatement(
       [],
-      ts.factory.createVariableDeclarationList(
+      TypeScriptFactory.createVariableDeclarationList(
         [
-          ts.factory.createVariableDeclaration(
+          TypeScriptFactory.createVariableDeclaration(
             "output",
             undefined,
             ctx.route.success
@@ -60,16 +61,16 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
                   schema: ctx.route.success.schema,
                 })
               : undefined,
-            ts.factory.createAwaitExpression(writeCallExpressionn(ctx)),
+            TypeScriptFactory.createAwaitExpression(writeCallExpressionn(ctx)),
           ),
         ],
         ts.NodeFlags.Const,
       ),
     ),
-    ts.factory.createExpressionStatement(
-      ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier(
+    TypeScriptFactory.createExpressionStatement(
+      TypeScriptFactory.createCallExpression(
+        TypeScriptFactory.createPropertyAccessExpression(
+          TypeScriptFactory.createIdentifier(
             ctx.importer.external({
               type: "default",
               library: "typia",
@@ -79,26 +80,28 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           "assert",
         ),
         undefined,
-        [ts.factory.createIdentifier("output")],
+        [TypeScriptFactory.createIdentifier("output")],
       ),
     ),
   ];
 
   const writeCallExpressionn = (ctx: IContext): ts.CallExpression => {
-    const fetch = ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier("api.functional"),
-      ts.factory.createIdentifier(ctx.route.accessor.join(".")),
+    const fetch = TypeScriptFactory.createPropertyAccessExpression(
+      TypeScriptFactory.createIdentifier("api.functional"),
+      TypeScriptFactory.createIdentifier(ctx.route.accessor.join(".")),
     );
-    const connection = ts.factory.createIdentifier("connection");
+    const connection = TypeScriptFactory.createIdentifier("connection");
     if (
       ctx.route.parameters.length === 0 &&
       ctx.route.query === null &&
       ctx.route.body === null
     )
-      return ts.factory.createCallExpression(fetch, undefined, [connection]);
+      return TypeScriptFactory.createCallExpression(fetch, undefined, [
+        connection,
+      ]);
 
-    const random = ts.factory.createPropertyAccessExpression(
-      ts.factory.createIdentifier(
+    const random = TypeScriptFactory.createPropertyAccessExpression(
+      TypeScriptFactory.createIdentifier(
         ctx.importer.external({
           type: "default",
           library: "typia",
@@ -108,7 +111,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       "random",
     );
     if (ctx.config.keyword === true)
-      return ts.factory.createCallExpression(fetch, undefined, [
+      return TypeScriptFactory.createCallExpression(fetch, undefined, [
         connection,
         LiteralFactory.write(
           Object.fromEntries(
@@ -116,7 +119,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
               .filter((x) => x !== null)
               .map(({ key, schema: value }) => [
                 key,
-                ts.factory.createCallExpression(
+                TypeScriptFactory.createCallExpression(
                   random,
                   [
                     NestiaMigrateSchemaProgrammer.write({
@@ -131,12 +134,12 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           ),
         ),
       ]);
-    return ts.factory.createCallExpression(fetch, undefined, [
+    return TypeScriptFactory.createCallExpression(fetch, undefined, [
       connection,
       ...[...ctx.route.parameters, ctx.route.query, ctx.route.body]
         .filter((p) => !!p)
         .map((p) =>
-          ts.factory.createCallExpression(
+          TypeScriptFactory.createCallExpression(
             random,
             [
               NestiaMigrateSchemaProgrammer.write({

package/src/programmers/NestiaMigrateE2eProgrammer.ts

@@ -1,5 +1,5 @@
 import { IHttpMigrateRoute, OpenApi } from "@typia/interface";
-import ts from "typescript";
+import ts from "../internal/ts";
 
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { INestiaMigrateContext } from "../structures/INestiaMigrateContext";