@nestia/migrate 12.0.0-dev.20260612.2 → 12.0.0-rc.1

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({

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)],
           ),
         ),
       ),