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

package/src/programmers/NestiaMigrateApiSimulationProgrammer.ts

@@ -1,9 +1,11 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import { IdentifierFactory, StatementFactory, TypeFactory } from "@nestia/factory";
+import { NodeFlags, SyntaxKind, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "../internal/ts";
 import { OpenApi } from "typia";
 
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { NestiaMigrateApiFunctionProgrammer } from "./NestiaMigrateApiFunctionProgrammer";
 import { NestiaMigrateApiNamespaceProgrammer } from "./NestiaMigrateApiNamespaceProgrammer";
@@ -28,15 +30,15 @@ export namespace NestiaMigrateApiSimulationProgrammer {
       : TypeFactory.keyword("void");
     return constant(
       "random",
-      TypeScriptFactory.createArrowFunction(
+      factory.createArrowFunction(
         undefined,
         undefined,
         [],
         output,
         undefined,
-        TypeScriptFactory.createCallExpression(
+        factory.createCallExpression(
           IdentifierFactory.access(
-            TypeScriptFactory.createIdentifier(
+            factory.createIdentifier(
               ctx.importer.external({
                 type: "default",
                 library: "typia",
@@ -54,14 +56,14 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 
   export const simulate = (ctx: IContext): ts.VariableStatement => {
     const caller = () =>
-      TypeScriptFactory.createCallExpression(
-        TypeScriptFactory.createIdentifier("random"),
+      factory.createCallExpression(
+        factory.createIdentifier("random"),
         undefined,
         undefined,
       );
     return constant(
       "simulate",
-      TypeScriptFactory.createArrowFunction(
+      factory.createArrowFunction(
         undefined,
         undefined,
         NestiaMigrateApiFunctionProgrammer.writeParameterDeclarations(
@@ -72,12 +74,12 @@ export namespace NestiaMigrateApiSimulationProgrammer {
             ? "_connection"
             : undefined,
         ),
-        TypeScriptFactory.createTypeReferenceNode(
+        factory.createTypeReferenceNode(
           ctx.route.success ? "Response" : "void",
         ),
         undefined,
-        TypeScriptFactory.createBlock(
-          [...assert(ctx), TypeScriptFactory.createReturnStatement(caller())],
+        factory.createBlock(
+          [...assert(ctx), factory.createReturnStatement(caller())],
           true,
         ),
       ),
@@ -87,11 +89,8 @@ export namespace NestiaMigrateApiSimulationProgrammer {
   const assert = (ctx: IContext): ts.Statement[] => {
     const property = (key: string) =>
       ctx.config.keyword === true
-        ? IdentifierFactory.access(
-            TypeScriptFactory.createIdentifier("props"),
-            key,
-          )
-        : TypeScriptFactory.createIdentifier(key);
+        ? IdentifierFactory.access(factory.createIdentifier("props"), key)
+        : factory.createIdentifier(key);
     const parameters = [
       ...ctx.route.parameters.map((p) => ({
         category: "param",
@@ -133,9 +132,9 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 
     const validator = StatementFactory.constant({
       name: "assert",
-      value: TypeScriptFactory.createCallExpression(
+      value: factory.createCallExpression(
         IdentifierFactory.access(
-          TypeScriptFactory.createIdentifier(
+          factory.createIdentifier(
             ctx.importer.external({
               type: "instance",
               library: `@nestia/fetcher`,
@@ -146,26 +145,26 @@ export namespace NestiaMigrateApiSimulationProgrammer {
         ),
         undefined,
         [
-          TypeScriptFactory.createObjectLiteralExpression(
+          factory.createObjectLiteralExpression(
             [
-              TypeScriptFactory.createPropertyAssignment(
+              factory.createPropertyAssignment(
                 "method",
-                TypeScriptFactory.createIdentifier("METADATA.method"),
+                factory.createIdentifier("METADATA.method"),
               ),
-              TypeScriptFactory.createPropertyAssignment(
+              factory.createPropertyAssignment(
                 "host",
-                TypeScriptFactory.createIdentifier("connection.host"),
+                factory.createIdentifier("connection.host"),
               ),
-              TypeScriptFactory.createPropertyAssignment(
+              factory.createPropertyAssignment(
                 "path",
                 NestiaMigrateApiNamespaceProgrammer.writePathCallExpression(
                   ctx.config,
                   ctx.route,
                 ),
               ),
-              TypeScriptFactory.createPropertyAssignment(
+              factory.createPropertyAssignment(
                 "contentType",
-                TypeScriptFactory.createStringLiteral(
+                factory.createStringLiteral(
                   ctx.route.success?.type ?? "application/json",
                 ),
               ),
@@ -177,28 +176,28 @@ export namespace NestiaMigrateApiSimulationProgrammer {
     });
     const individual: ts.Statement[] = parameters
       .map((p) =>
-        TypeScriptFactory.createCallExpression(
+        factory.createCallExpression(
           (() => {
             const base = IdentifierFactory.access(
-              TypeScriptFactory.createIdentifier("assert"),
+              factory.createIdentifier("assert"),
               p.category,
             );
             if (p.category !== "param") return base;
-            return TypeScriptFactory.createCallExpression(base, undefined, [
-              TypeScriptFactory.createStringLiteral(p.name),
+            return factory.createCallExpression(base, undefined, [
+              factory.createStringLiteral(p.name),
             ]);
           })(),
           undefined,
           [
-            TypeScriptFactory.createArrowFunction(
+            factory.createArrowFunction(
               undefined,
               undefined,
               [],
               undefined,
               undefined,
-              TypeScriptFactory.createCallExpression(
+              factory.createCallExpression(
                 IdentifierFactory.access(
-                  TypeScriptFactory.createIdentifier(
+                  factory.createIdentifier(
                     ctx.importer.external({
                       type: "default",
                       library: "typia",
@@ -210,7 +209,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                 undefined,
                 [
                   p.category === "headers"
-                    ? TypeScriptFactory.createIdentifier("connection.headers")
+                    ? factory.createIdentifier("connection.headers")
                     : property(p.name),
                 ],
               ),
@@ -218,7 +217,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
           ],
         ),
       )
-      .map(TypeScriptFactory.createExpressionStatement) as ts.Statement[];
+      .map(factory.createExpressionStatement) as ts.Statement[];
     return [validator, tryAndCatch(ctx.importer, individual)];
   };
 
@@ -226,17 +225,17 @@ export namespace NestiaMigrateApiSimulationProgrammer {
     importer: NestiaMigrateImportProgrammer,
     individual: ts.Statement[],
   ) =>
-    TypeScriptFactory.createTryStatement(
-      TypeScriptFactory.createBlock(individual, true),
-      TypeScriptFactory.createCatchClause(
+    factory.createTryStatement(
+      factory.createBlock(individual, true),
+      factory.createCatchClause(
         "exp",
-        TypeScriptFactory.createBlock(
+        factory.createBlock(
           [
-            TypeScriptFactory.createIfStatement(
-              TypeScriptFactory.createLogicalNot(
-                TypeScriptFactory.createCallExpression(
+            factory.createIfStatement(
+              factory.createLogicalNot(
+                factory.createCallExpression(
                   IdentifierFactory.access(
-                    TypeScriptFactory.createIdentifier(
+                    factory.createIdentifier(
                       importer.external({
                         type: "default",
                         library: "typia",
@@ -246,7 +245,7 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                     "is",
                   ),
                   [
-                    TypeScriptFactory.createTypeReferenceNode(
+                    factory.createTypeReferenceNode(
                       importer.external({
                         type: "instance",
                         library: "@nestia/fetcher",
@@ -254,34 +253,30 @@ export namespace NestiaMigrateApiSimulationProgrammer {
                       }),
                     ),
                   ],
-                  [TypeScriptFactory.createIdentifier("exp")],
+                  [factory.createIdentifier("exp")],
                 ),
               ),
-              TypeScriptFactory.createThrowStatement(
-                TypeScriptFactory.createIdentifier("exp"),
-              ),
+              factory.createThrowStatement(factory.createIdentifier("exp")),
             ),
-            TypeScriptFactory.createReturnStatement(
-              TypeScriptFactory.createAsExpression(
-                TypeScriptFactory.createObjectLiteralExpression(
+            factory.createReturnStatement(
+              factory.createAsExpression(
+                factory.createObjectLiteralExpression(
                   [
-                    TypeScriptFactory.createPropertyAssignment(
+                    factory.createPropertyAssignment(
                       "success",
-                      TypeScriptFactory.createFalse(),
+                      factory.createFalse(),
                     ),
-                    TypeScriptFactory.createPropertyAssignment(
+                    factory.createPropertyAssignment(
                       "status",
-                      TypeScriptFactory.createIdentifier("exp.status"),
+                      factory.createIdentifier("exp.status"),
                     ),
-                    TypeScriptFactory.createPropertyAssignment(
+                    factory.createPropertyAssignment(
                       "headers",
-                      TypeScriptFactory.createIdentifier("exp.headers"),
+                      factory.createIdentifier("exp.headers"),
                     ),
-                    TypeScriptFactory.createPropertyAssignment(
+                    factory.createPropertyAssignment(
                       "data",
-                      TypeScriptFactory.createIdentifier(
-                        "exp.toJSON().message",
-                      ),
+                      factory.createIdentifier("exp.toJSON().message"),
                     ),
                   ],
                   true,
@@ -298,17 +293,17 @@ export namespace NestiaMigrateApiSimulationProgrammer {
 }
 
 const constant = (name: string, expression: ts.Expression) =>
-  TypeScriptFactory.createVariableStatement(
-    [TypeScriptFactory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    TypeScriptFactory.createVariableDeclarationList(
+  factory.createVariableStatement(
+    [factory.createModifier(SyntaxKind.ExportKeyword)],
+    factory.createVariableDeclarationList(
       [
-        TypeScriptFactory.createVariableDeclaration(
-          TypeScriptFactory.createIdentifier(name),
+        factory.createVariableDeclaration(
+          factory.createIdentifier(name),
           undefined,
           undefined,
           expression,
         ),
       ],
-      ts.NodeFlags.Const,
+      NodeFlags.Const,
     ),
   );

package/src/programmers/NestiaMigrateApiStartProgrammer.ts

@@ -1,8 +1,9 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import { IdentifierFactory, StatementFactory } from "@nestia/factory";
+import { NodeFlags, SyntaxKind, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "../internal/ts";
 
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import ts from "../internal/ts";
 import { INestiaMigrateContext } from "../structures/INestiaMigrateContext";
 import { FilePrinter } from "../utils/FilePrinter";
 import { NestiaMigrateE2eFunctionProgrammer } from "./NestiaMigrateE2eFileProgrammer";
@@ -24,25 +25,24 @@ export namespace NestiaMigrateApiStartProgrammer {
         (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,
       ),
       FilePrinter.newLine(),
-      TypeScriptFactory.createImportDeclaration(
+      factory.createImportDeclaration(
         undefined,
-        TypeScriptFactory.createImportClause(
+        factory.createImportClause(
           false,
           undefined,
-          TypeScriptFactory.createNamedImports([
-            TypeScriptFactory.createImportSpecifier(
+          factory.createNamedImports([
+            factory.createImportSpecifier(
               false,
               undefined,
-              TypeScriptFactory.createIdentifier("TestGlobal"),
+              factory.createIdentifier("TestGlobal"),
             ),
           ]),
         ),
-        TypeScriptFactory.createStringLiteral("./TestGlobal"),
-        undefined,
+        factory.createStringLiteral("./TestGlobal"),
       ),
       FilePrinter.newLine(),
       main,
-      TypeScriptFactory.createExpressionStatement(writeStarter()),
+      factory.createExpressionStatement(writeStarter()),
     ];
     return {
       "test/start.ts": FilePrinter.write({ statements }),
@@ -56,13 +56,13 @@ export namespace NestiaMigrateApiStartProgrammer {
   ): ts.VariableStatement =>
     StatementFactory.constant({
       name: "main",
-      value: TypeScriptFactory.createArrowFunction(
-        [TypeScriptFactory.createToken(ts.SyntaxKind.AsyncKeyword)],
+      value: factory.createArrowFunction(
+        [factory.createToken(SyntaxKind.AsyncKeyword)],
         undefined,
         [],
         undefined,
         undefined,
-        TypeScriptFactory.createBlock(
+        factory.createBlock(
           [
             writeConnection(ctx, importer),
             ...NestiaMigrateE2eFunctionProgrammer.writeBody({
@@ -81,31 +81,31 @@ export namespace NestiaMigrateApiStartProgrammer {
     ctx: INestiaMigrateContext,
     importer: NestiaMigrateImportProgrammer,
   ): ts.VariableStatement =>
-    TypeScriptFactory.createVariableStatement(
+    factory.createVariableStatement(
       undefined,
-      TypeScriptFactory.createVariableDeclarationList(
+      factory.createVariableDeclarationList(
         [
-          TypeScriptFactory.createVariableDeclaration(
+          factory.createVariableDeclaration(
             "connection",
             undefined,
-            TypeScriptFactory.createTypeReferenceNode(
-              TypeScriptFactory.createQualifiedName(
-                TypeScriptFactory.createIdentifier(
+            factory.createTypeReferenceNode(
+              factory.createQualifiedName(
+                factory.createIdentifier(
                   importer.external({
                     type: "default",
                     library: "@ORGANIZATION/PROJECT-api",
                     name: "api",
                   }),
                 ),
-                TypeScriptFactory.createIdentifier("IConnection"),
+                factory.createIdentifier("IConnection"),
               ),
             ),
-            TypeScriptFactory.createObjectLiteralExpression(
+            factory.createObjectLiteralExpression(
               [
-                TypeScriptFactory.createSpreadAssignment(
-                  TypeScriptFactory.createCallExpression(
-                    TypeScriptFactory.createPropertyAccessExpression(
-                      TypeScriptFactory.createIdentifier("TestGlobal"),
+                factory.createSpreadAssignment(
+                  factory.createCallExpression(
+                    factory.createPropertyAccessExpression(
+                      factory.createIdentifier("TestGlobal"),
                       "connection",
                     ),
                     undefined,
@@ -114,9 +114,9 @@ export namespace NestiaMigrateApiStartProgrammer {
                 ),
                 ...(ctx.application.document().servers?.[0]?.url?.length
                   ? [
-                      TypeScriptFactory.createPropertyAssignment(
+                      factory.createPropertyAssignment(
                         "host",
-                        TypeScriptFactory.createStringLiteral(
+                        factory.createStringLiteral(
                           ctx.application.document().servers![0]!.url,
                         ),
                       ),
@@ -124,9 +124,9 @@ export namespace NestiaMigrateApiStartProgrammer {
                   : []),
                 ...(ctx.config.simulate === true
                   ? [
-                      TypeScriptFactory.createPropertyAssignment(
+                      factory.createPropertyAssignment(
                         "simulate",
-                        TypeScriptFactory.createTrue(),
+                        factory.createTrue(),
                       ),
                     ]
                   : []),
@@ -135,15 +135,15 @@ export namespace NestiaMigrateApiStartProgrammer {
             ),
           ),
         ],
-        ts.NodeFlags.Const,
+        NodeFlags.Const,
       ),
     );
 
   const writeStarter = (): ts.CallExpression =>
-    TypeScriptFactory.createCallExpression(
-      TypeScriptFactory.createPropertyAccessExpression(
-        TypeScriptFactory.createCallExpression(
-          TypeScriptFactory.createIdentifier("main"),
+    factory.createCallExpression(
+      factory.createPropertyAccessExpression(
+        factory.createCallExpression(
+          factory.createIdentifier("main"),
           undefined,
           undefined,
         ),
@@ -151,34 +151,34 @@ export namespace NestiaMigrateApiStartProgrammer {
       ),
       undefined,
       [
-        TypeScriptFactory.createArrowFunction(
+        factory.createArrowFunction(
           undefined,
           undefined,
           [IdentifierFactory.parameter("exp")],
           undefined,
           undefined,
-          TypeScriptFactory.createBlock(
+          factory.createBlock(
             [
-              TypeScriptFactory.createExpressionStatement(
-                TypeScriptFactory.createCallExpression(
-                  TypeScriptFactory.createPropertyAccessExpression(
-                    TypeScriptFactory.createIdentifier("console"),
+              factory.createExpressionStatement(
+                factory.createCallExpression(
+                  factory.createPropertyAccessExpression(
+                    factory.createIdentifier("console"),
                     "log",
                   ),
                   undefined,
-                  [TypeScriptFactory.createIdentifier("exp")],
+                  [factory.createIdentifier("exp")],
                 ),
               ),
-              TypeScriptFactory.createExpressionStatement(
-                TypeScriptFactory.createCallExpression(
-                  TypeScriptFactory.createPropertyAccessExpression(
-                    TypeScriptFactory.createIdentifier("process"),
+              factory.createExpressionStatement(
+                factory.createCallExpression(
+                  factory.createPropertyAccessExpression(
+                    factory.createIdentifier("process"),
                     "exit",
                   ),
                   undefined,
                   [
-                    TypeScriptFactory.createPrefixMinus(
-                      TypeScriptFactory.createNumericLiteral("1"),
+                    factory.createPrefixMinus(
+                      factory.createNumericLiteral("1"),
                     ),
                   ],
                 ),

package/src/programmers/NestiaMigrateDtoProgrammer.ts

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

package/src/programmers/NestiaMigrateE2eFileProgrammer.ts

@@ -1,9 +1,10 @@
-import { TypeScriptFactory } from "@nestia/factory";
-import { IdentifierFactory, LiteralFactory } from "@nestia/factory";
+import { NodeFlags, SyntaxKind, factory } from "@ttsc/factory";
 import { IHttpMigrateRoute } from "@typia/interface";
-import ts from "../internal/ts";
 import { OpenApi } from "typia";
 
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { LiteralFactory } from "../factories/LiteralFactory";
+import ts from "../internal/ts";
 import { INestiaMigrateConfig } from "../structures/INestiaMigrateConfig";
 import { NestiaMigrateImportProgrammer } from "./NestiaMigrateImportProgrammer";
 import { NestiaMigrateSchemaProgrammer } from "./NestiaMigrateSchemaProgrammer";
@@ -17,10 +18,10 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
   }
 
   export const write = (ctx: IContext): ts.FunctionDeclaration =>
-    TypeScriptFactory.createFunctionDeclaration(
+    factory.createFunctionDeclaration(
       [
-        TypeScriptFactory.createModifier(ts.SyntaxKind.ExportKeyword),
-        TypeScriptFactory.createModifier(ts.SyntaxKind.AsyncKeyword),
+        factory.createModifier(SyntaxKind.ExportKeyword),
+        factory.createModifier(SyntaxKind.AsyncKeyword),
       ],
       undefined,
       ["test", "api", ...ctx.route.accessor].join("_"),
@@ -28,30 +29,30 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       [
         IdentifierFactory.parameter(
           "connection",
-          TypeScriptFactory.createTypeReferenceNode(
-            TypeScriptFactory.createQualifiedName(
-              TypeScriptFactory.createIdentifier(
+          factory.createTypeReferenceNode(
+            factory.createQualifiedName(
+              factory.createIdentifier(
                 ctx.importer.external({
                   type: "default",
                   library: "@ORGANIZATION/PROJECT-api",
                   name: "api",
                 }),
               ),
-              TypeScriptFactory.createIdentifier("IConnection"),
+              factory.createIdentifier("IConnection"),
             ),
           ),
         ),
       ],
       undefined,
-      TypeScriptFactory.createBlock(writeBody(ctx), true),
+      factory.createBlock(writeBody(ctx), true),
     );
 
   export const writeBody = (ctx: IContext): ts.Statement[] => [
-    TypeScriptFactory.createVariableStatement(
+    factory.createVariableStatement(
       [],
-      TypeScriptFactory.createVariableDeclarationList(
+      factory.createVariableDeclarationList(
         [
-          TypeScriptFactory.createVariableDeclaration(
+          factory.createVariableDeclaration(
             "output",
             undefined,
             ctx.route.success
@@ -61,16 +62,16 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
                   schema: ctx.route.success.schema,
                 })
               : undefined,
-            TypeScriptFactory.createAwaitExpression(writeCallExpressionn(ctx)),
+            factory.createAwaitExpression(writeCallExpressionn(ctx)),
           ),
         ],
-        ts.NodeFlags.Const,
+        NodeFlags.Const,
       ),
     ),
-    TypeScriptFactory.createExpressionStatement(
-      TypeScriptFactory.createCallExpression(
-        TypeScriptFactory.createPropertyAccessExpression(
-          TypeScriptFactory.createIdentifier(
+    factory.createExpressionStatement(
+      factory.createCallExpression(
+        factory.createPropertyAccessExpression(
+          factory.createIdentifier(
             ctx.importer.external({
               type: "default",
               library: "typia",
@@ -80,28 +81,26 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           "assert",
         ),
         undefined,
-        [TypeScriptFactory.createIdentifier("output")],
+        [factory.createIdentifier("output")],
       ),
     ),
   ];
 
   const writeCallExpressionn = (ctx: IContext): ts.CallExpression => {
-    const fetch = TypeScriptFactory.createPropertyAccessExpression(
-      TypeScriptFactory.createIdentifier("api.functional"),
-      TypeScriptFactory.createIdentifier(ctx.route.accessor.join(".")),
+    const fetch = factory.createPropertyAccessExpression(
+      factory.createIdentifier("api.functional"),
+      factory.createIdentifier(ctx.route.accessor.join(".")),
     );
-    const connection = TypeScriptFactory.createIdentifier("connection");
+    const connection = factory.createIdentifier("connection");
     if (
       ctx.route.parameters.length === 0 &&
       ctx.route.query === null &&
       ctx.route.body === null
     )
-      return TypeScriptFactory.createCallExpression(fetch, undefined, [
-        connection,
-      ]);
+      return factory.createCallExpression(fetch, undefined, [connection]);
 
-    const random = TypeScriptFactory.createPropertyAccessExpression(
-      TypeScriptFactory.createIdentifier(
+    const random = factory.createPropertyAccessExpression(
+      factory.createIdentifier(
         ctx.importer.external({
           type: "default",
           library: "typia",
@@ -111,7 +110,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
       "random",
     );
     if (ctx.config.keyword === true)
-      return TypeScriptFactory.createCallExpression(fetch, undefined, [
+      return factory.createCallExpression(fetch, undefined, [
         connection,
         LiteralFactory.write(
           Object.fromEntries(
@@ -119,7 +118,7 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
               .filter((x) => x !== null)
               .map(({ key, schema: value }) => [
                 key,
-                TypeScriptFactory.createCallExpression(
+                factory.createCallExpression(
                   random,
                   [
                     NestiaMigrateSchemaProgrammer.write({
@@ -134,12 +133,12 @@ export namespace NestiaMigrateE2eFunctionProgrammer {
           ),
         ),
       ]);
-    return TypeScriptFactory.createCallExpression(fetch, undefined, [
+    return factory.createCallExpression(fetch, undefined, [
       connection,
       ...[...ctx.route.parameters, ctx.route.query, ctx.route.body]
         .filter((p) => !!p)
         .map((p) =>
-          TypeScriptFactory.createCallExpression(
+          factory.createCallExpression(
             random,
             [
               NestiaMigrateSchemaProgrammer.write({