@nestia/migrate 0.7.5 → 0.7.7

package/src/internal/MigrateInquirer.ts

@@ -1,79 +1,79 @@
-import commander from "commander";
-import inquirer from "inquirer";
-
-export namespace MigrateInquirer {
-  export interface IOutput {
-    mode: "nest" | "sdk";
-    simulate: boolean;
-    input: string;
-    output: string;
-  }
-
-  export const parse = async (): Promise<IOutput> => {
-    // PREPARE ASSETS
-    commander.program.option("--mode [nest/sdk]", "migration mode");
-    commander.program.option(
-      "--input [swagger.json]",
-      "location of target swagger.json file",
-    );
-    commander.program.option("--output [directory]", "output directory path");
-    commander.program.option("--simulate", "Mockup simulator");
-
-    // INTERNAL PROCEDURES
-    const questioned = { value: false };
-    const action = (closure: (options: Partial<IOutput>) => Promise<IOutput>) =>
-      new Promise<IOutput>((resolve, reject) => {
-        commander.program.action(async (options) => {
-          try {
-            resolve(await closure(options));
-          } catch (exp) {
-            reject(exp);
-          }
-        });
-        commander.program.parseAsync().catch(reject);
-      });
-    const select =
-      (name: string) =>
-      (message: string) =>
-      async <Choice extends string>(
-        choices: Choice[],
-        filter?: (value: string) => Choice,
-      ): Promise<Choice> => {
-        questioned.value = true;
-        return (
-          await inquirer.createPromptModule()({
-            type: "list",
-            name: name,
-            message: message,
-            choices: choices,
-            filter,
-          })
-        )[name];
-      };
-    const input = (name: string) => async (message: string) =>
-      (
-        await inquirer.createPromptModule()({
-          type: "input",
-          name,
-          message,
-        })
-      )[name];
-
-    // DO CONSTRUCT
-    return action(async (partial) => {
-      partial.mode ??= await select("mode")("Migration mode")(
-        ["NestJS" as "nest", "SDK" as "sdk"],
-        (value) => (value === "NestJS" ? "nest" : "sdk"),
-      );
-      partial.input ??= await input("input")("Swagger file location");
-      partial.output ??= await input("output")("Output directory path");
-      if (partial.simulate)
-        partial.simulate = (partial.simulate as any) === "true";
-      else
-        partial.simulate =
-          (await select("simulate")("Mokup Simulator")(["true", "false"])) ===
-          "true";
-      return partial as IOutput;
-    });
-  };
-}
+import commander from "commander";
+import inquirer from "inquirer";
+
+export namespace MigrateInquirer {
+  export interface IOutput {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+    input: string;
+    output: string;
+  }
+
+  export const parse = async (): Promise<IOutput> => {
+    // PREPARE ASSETS
+    commander.program.option("--mode [nest/sdk]", "migration mode");
+    commander.program.option(
+      "--input [swagger.json]",
+      "location of target swagger.json file",
+    );
+    commander.program.option("--output [directory]", "output directory path");
+    commander.program.option("--simulate", "Mockup simulator");
+
+    // INTERNAL PROCEDURES
+    const questioned = { value: false };
+    const action = (closure: (options: Partial<IOutput>) => Promise<IOutput>) =>
+      new Promise<IOutput>((resolve, reject) => {
+        commander.program.action(async (options) => {
+          try {
+            resolve(await closure(options));
+          } catch (exp) {
+            reject(exp);
+          }
+        });
+        commander.program.parseAsync().catch(reject);
+      });
+    const select =
+      (name: string) =>
+      (message: string) =>
+      async <Choice extends string>(
+        choices: Choice[],
+        filter?: (value: string) => Choice,
+      ): Promise<Choice> => {
+        questioned.value = true;
+        return (
+          await inquirer.createPromptModule()({
+            type: "list",
+            name: name,
+            message: message,
+            choices: choices,
+            filter,
+          })
+        )[name];
+      };
+    const input = (name: string) => async (message: string) =>
+      (
+        await inquirer.createPromptModule()({
+          type: "input",
+          name,
+          message,
+        })
+      )[name];
+
+    // DO CONSTRUCT
+    return action(async (partial) => {
+      partial.mode ??= await select("mode")("Migration mode")(
+        ["NestJS" as "nest", "SDK" as "sdk"],
+        (value) => (value === "NestJS" ? "nest" : "sdk"),
+      );
+      partial.input ??= await input("input")("Swagger file location");
+      partial.output ??= await input("output")("Output directory path");
+      if (partial.simulate)
+        partial.simulate = (partial.simulate as any) === "true";
+      else
+        partial.simulate =
+          (await select("simulate")("Mokup Simulator")(["true", "false"])) ===
+          "true";
+      return partial as IOutput;
+    });
+  };
+}

package/src/module.ts

@@ -1,4 +1,14 @@
-export * from "./MigrateApplication";
-
-export * from "./structures/ISwagger";
-export * from "./structures/IMigrateProgram";
+export * from "./MigrateApplication";
+
+export * from "./analyzers/MigrateAnalyzer";
+
+export * from "./archivers/MigrateFileArchiver";
+
+export * from "./structures/ISwagger";
+export * from "./structures/ISwaggerComponents";
+export * from "./structures/ISwaggerInfo";
+export * from "./structures/ISwaggerRoute";
+export * from "./structures/ISwaggerSecurity";
+export * from "./structures/ISwaggerSchema";
+export * from "./structures/IMigrateProgram";
+export * from "./structures/IMigrateSchema";

package/src/programmers/{ApiFileProgrammer.ts → MigrateApiFileProgrammer.ts}

@@ -1,14 +1,14 @@
 import ts from "typescript";
 
-import { IMigrateConfig } from "../IMigrateConfig";
+import { IMigrateProgram } from "../module";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ApiFunctionProgrammer } from "./ApiFunctionProgrammer";
-import { ApiNamespaceProgrammer } from "./ApiNamespaceProgrammer";
-import { ImportProgrammer } from "./ImportProgrammer";
+import { MigrateApiFunctionProgrammer } from "./MigrateApiFunctionProgrammer";
+import { MigrateApiNamespaceProgrammer } from "./MigrateApiNamespaceProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
-export namespace ApiFileProgrammer {
+export namespace MigrateApiFileProgrammer {
   export interface IProps {
     namespace: string[];
     entries: IEntry[];
@@ -21,14 +21,14 @@ export namespace ApiFileProgrammer {
   }
 
   export const write =
-    (config: IMigrateConfig) =>
+    (config: IMigrateProgram.IConfig) =>
     (components: ISwaggerComponents) =>
     (props: IProps): ts.Statement[] => {
-      const importer: ImportProgrammer = new ImportProgrammer();
+      const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
       const statements: ts.Statement[] = props.entries
         .map((p) => [
-          ApiFunctionProgrammer.write(config)(components)(importer)(p),
-          ApiNamespaceProgrammer.write(config)(components)(importer)(p),
+          MigrateApiFunctionProgrammer.write(config)(components)(importer)(p),
+          MigrateApiNamespaceProgrammer.write(config)(components)(importer)(p),
         ])
         .flat();
       return [

package/src/programmers/{ApiFunctionProgrammer.ts → MigrateApiFunctionProgrammer.ts}

@@ -1,15 +1,15 @@
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
-import { IMigrateConfig } from "../IMigrateConfig";
+import { IMigrateProgram } from "../module";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
-export namespace ApiFunctionProgrammer {
+export namespace MigrateApiFunctionProgrammer {
   export interface IProps {
     controller: IMigrateController;
     route: IMigrateRoute;
@@ -17,9 +17,9 @@ export namespace ApiFunctionProgrammer {
   }
 
   export const write =
-    (config: IMigrateConfig) =>
+    (config: IMigrateProgram.IConfig) =>
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.FunctionDeclaration =>
       FilePrinter.description(
         ts.factory.createFunctionDeclaration(
@@ -43,7 +43,7 @@ export namespace ApiFunctionProgrammer {
 
   export const writeParameterDeclarations =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.ParameterDeclaration[] => [
       IdentifierFactory.parameter(
         "connection",
@@ -61,7 +61,7 @@ export namespace ApiFunctionProgrammer {
       ...props.route.parameters.map((p) =>
         IdentifierFactory.parameter(
           p.key,
-          SchemaProgrammer.write(components)(importer)(p.schema),
+          MigrateSchemaProgrammer.write(components)(importer)(p.schema),
         ),
       ),
       ...(props.route.query
@@ -95,8 +95,8 @@ export namespace ApiFunctionProgrammer {
     ].join("\n");
 
   const writeBody =
-    (config: IMigrateConfig) =>
-    (importer: ImportProgrammer) =>
+    (config: IMigrateProgram.IConfig) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.Statement[] => {
       const encrypted: boolean = !!props.route.success?.["x-nestia-encrypted"];
       const contentType: string = props.route.body?.type ?? "application/json";

package/src/programmers/{ApiNamespaceProgrammer.ts → MigrateApiNamespaceProgrammer.ts}

@@ -4,16 +4,16 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { IMigrateConfig } from "../IMigrateConfig";
 import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
-import { ApiSimulatationProgrammer } from "./ApiSimulatationProgrammer";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
+import { MigrateApiSimulatationProgrammer } from "./MigrateApiSimulatationProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
-export namespace ApiNamespaceProgrammer {
+export namespace MigrateApiNamespaceProgrammer {
   export interface IProps {
     controller: IMigrateController;
     route: IMigrateRoute;
@@ -21,9 +21,9 @@ export namespace ApiNamespaceProgrammer {
   }
 
   export const write =
-    (config: IMigrateConfig) =>
+    (config: IMigrateProgram.IConfig) =>
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.ModuleDeclaration => {
       const types = writeTypes(components)(importer)(props.route);
       return ts.factory.createModuleDeclaration(
@@ -31,14 +31,18 @@ export namespace ApiNamespaceProgrammer {
         ts.factory.createIdentifier(props.alias),
         ts.factory.createModuleBlock([
           ...types,
-          ...(types.length ? [FilePrinter.enter()] : []),
+          ...(types.length ? [FilePrinter.newLine()] : []),
           writeMetadata(components)(importer)(props),
-          FilePrinter.enter(),
+          FilePrinter.newLine(),
           writePath(components)(importer)(props),
           ...(config.simulate
             ? [
-                ApiSimulatationProgrammer.random(components)(importer)(props),
-                ApiSimulatationProgrammer.simulate(components)(importer)(props),
+                MigrateApiSimulatationProgrammer.random(components)(importer)(
+                  props,
+                ),
+                MigrateApiSimulatationProgrammer.simulate(components)(importer)(
+                  props,
+                ),
               ]
             : []),
         ]),
@@ -62,7 +66,7 @@ export namespace ApiNamespaceProgrammer {
 
   const writeTypes =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (route: IMigrateRoute): ts.TypeAliasDeclaration[] => {
       const array: ts.TypeAliasDeclaration[] = [];
       const declare = (name: string, type: ts.TypeNode) =>
@@ -77,29 +81,37 @@ export namespace ApiNamespaceProgrammer {
       if (route.headers)
         declare(
           "Headers",
-          SchemaProgrammer.write(components)(importer)(route.headers.schema),
+          MigrateSchemaProgrammer.write(components)(importer)(
+            route.headers.schema,
+          ),
         );
       if (route.query)
         declare(
           "Query",
-          SchemaProgrammer.write(components)(importer)(route.query.schema),
+          MigrateSchemaProgrammer.write(components)(importer)(
+            route.query.schema,
+          ),
         );
       if (route.body)
         declare(
           "Input",
-          SchemaProgrammer.write(components)(importer)(route.body.schema),
+          MigrateSchemaProgrammer.write(components)(importer)(
+            route.body.schema,
+          ),
         );
       if (route.success)
         declare(
           "Output",
-          SchemaProgrammer.write(components)(importer)(route.success.schema),
+          MigrateSchemaProgrammer.write(components)(importer)(
+            route.success.schema,
+          ),
         );
       return array;
     };
 
   const writeMetadata =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.VariableStatement =>
       constant("METADATA")(
         ts.factory.createAsExpression(
@@ -147,7 +159,7 @@ export namespace ApiNamespaceProgrammer {
                           })}.http.createAssertQuery`,
                         ),
                         [
-                          SchemaProgrammer.write(components)(importer)(
+                          MigrateSchemaProgrammer.write(components)(importer)(
                             props.route.success.schema,
                           ),
                         ],
@@ -167,7 +179,7 @@ export namespace ApiNamespaceProgrammer {
 
   const writePath =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.VariableStatement => {
       const out = (body: ts.ConciseBody) =>
         constant("path")(
@@ -178,7 +190,7 @@ export namespace ApiNamespaceProgrammer {
               ...props.route.parameters.map((p) =>
                 IdentifierFactory.parameter(
                   p.key,
-                  SchemaProgrammer.write(components)(importer)(p.schema),
+                  MigrateSchemaProgrammer.write(components)(importer)(p.schema),
                 ),
               ),
               ...(props.route.query
@@ -397,7 +409,7 @@ const constant = (name: string) => (expression: ts.Expression) =>
       ts.NodeFlags.Const,
     ),
   );
-const getPath = (props: ApiNamespaceProgrammer.IProps) =>
+const getPath = (props: MigrateApiNamespaceProgrammer.IProps) =>
   [...props.controller.path.split("/"), ...props.route.path.split("/")]
     .filter((str) => !!str.length)
     .join("/");

package/src/programmers/{ApiProgrammer.ts → MigrateApiProgrammer.ts}

@@ -6,16 +6,17 @@ import { IMigrateProgram } from "../module";
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { FilePrinter } from "../utils/FilePrinter";
 import { StringUtil } from "../utils/StringUtil";
-import { ApiFileProgrammer } from "./ApiFileProgrammer";
-import { DtoProgrammer } from "./DtoProgrammer";
-import { ImportProgrammer } from "./ImportProgrammer";
+import { MigrateApiFileProgrammer } from "./MigrateApiFileProgrammer";
+import { MigrateDtoProgrammer } from "./MigrateDtoProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
-export namespace ApiProgrammer {
+export namespace MigrateApiProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] => {
-    const dict: HashMap<string[], ApiFileProgrammer.IProps> = new HashMap(
-      (x) => hash(x.join(".")),
-      (a, b) => a.join(".") === b.join("."),
-    );
+    const dict: HashMap<string[], MigrateApiFileProgrammer.IProps> =
+      new HashMap(
+        (x) => hash(x.join(".")),
+        (a, b) => a.join(".") === b.join("."),
+      );
     for (const controller of program.controllers)
       for (const route of controller.routes) {
         const namespace: string[] = [
@@ -25,7 +26,7 @@ export namespace ApiProgrammer {
           .filter((str) => !!str.length && str[0] !== ":")
           .map(StringUtil.normalize)
           .map((str) => (Escaper.variable(str) ? str : `_${str}`));
-        const last: IPointer<ApiFileProgrammer.IProps> = {
+        const last: IPointer<MigrateApiFileProgrammer.IProps> = {
           value: dict.take(namespace, () => ({
             namespace,
             children: new Set(),
@@ -39,11 +40,14 @@ export namespace ApiProgrammer {
         });
         namespace.slice(0, -1).forEach((_i, i, array) => {
           const partial: string[] = namespace.slice(0, array.length - i);
-          const props: ApiFileProgrammer.IProps = dict.take(partial, () => ({
-            namespace: partial,
-            children: new Set(),
-            entries: [],
-          }));
+          const props: MigrateApiFileProgrammer.IProps = dict.take(
+            partial,
+            () => ({
+              namespace: partial,
+              children: new Set(),
+              entries: [],
+            }),
+          );
           props.children.add(last.value.namespace.at(-1)!);
           last.value = props;
         });
@@ -55,59 +59,59 @@ export namespace ApiProgrammer {
         if (namespace.length) top.children.add(namespace[0]);
       }
     for (const { second: props } of dict)
-      props.entries.forEach(
-        (entry, i) =>
-          (entry.alias = StringUtil.escapeDuplicate([
-            ...props.children,
-            ...entry.route.parameters.map((p) => p.key),
-            ...(entry.route.body ? [entry.route.body.key] : []),
-            ...(entry.route.query ? [entry.route.query.key] : []),
-            ...props.entries.filter((_, j) => i !== j).map((e) => e.alias),
-          ])(entry.alias)),
-      );
+      props.entries.forEach((entry, i) => {
+        entry.alias = StringUtil.escapeDuplicate([
+          ...props.children,
+          ...entry.route.parameters.map((p) => p.key),
+          ...(entry.route.body ? [entry.route.body.key] : []),
+          ...(entry.route.query ? [entry.route.query.key] : []),
+          ...props.entries.filter((_, j) => i !== j).map((e) => e.alias),
+        ])(entry.alias);
+        entry.route.accessor = [...props.namespace, entry.alias];
+      });
 
     const output: IMigrateFile[] = [...dict].map(({ second: props }) => ({
-      location: `src/${program.config.mode === "nest" ? "api/" : ""}functional/${props.namespace.join("/")}`,
+      location: `src/${program.mode === "nest" ? "api/" : ""}functional/${props.namespace.join("/")}`,
       file: "index.ts",
       content: FilePrinter.write({
-        statements: ApiFileProgrammer.write(program.config)(
+        statements: MigrateApiFileProgrammer.write(program)(
           program.swagger.components,
         )(props),
       }),
     }));
-    if (program.config.mode === "sdk")
+    if (program.mode === "sdk")
       output.push(
-        ...[...DtoProgrammer.write(program.swagger.components).entries()].map(
-          ([key, value]) => ({
-            location: "src/structures",
-            file: `${key}.ts`,
-            content: FilePrinter.write({
-              statements: writeDtoFile(key, value),
-            }),
+        ...[
+          ...MigrateDtoProgrammer.write(program.swagger.components).entries(),
+        ].map(([key, value]) => ({
+          location: "src/structures",
+          file: `${key}.ts`,
+          content: FilePrinter.write({
+            statements: writeDtoFile(key, value),
           }),
-        ),
+        })),
       );
     return output;
   };
 
   const writeDtoFile = (
     key: string,
-    modulo: DtoProgrammer.IModule,
+    modulo: MigrateDtoProgrammer.IModule,
   ): ts.Statement[] => {
-    const importer = new ImportProgrammer();
+    const importer = new MigrateImportProgrammer();
     const statements: ts.Statement[] = iterate(importer)(modulo);
     if (statements.length === 0) return [];
 
     return [
       ...importer.toStatements((name) => `./${name}`, key),
-      ...(importer.empty() ? [] : [FilePrinter.enter()]),
+      ...(importer.empty() ? [] : [FilePrinter.newLine()]),
       ...statements,
     ];
   };
 
   const iterate =
-    (importer: ImportProgrammer) =>
-    (modulo: DtoProgrammer.IModule): ts.Statement[] => {
+    (importer: MigrateImportProgrammer) =>
+    (modulo: MigrateDtoProgrammer.IModule): ts.Statement[] => {
       const output: ts.Statement[] = [];
       if (modulo.programmer !== null) output.push(modulo.programmer(importer));
       if (modulo.children.size) {

package/src/programmers/{ApiSimulatationProgrammer.ts → MigrateApiSimulatationProgrammer.ts}

@@ -6,12 +6,12 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ApiFunctionProgrammer } from "./ApiFunctionProgrammer";
-import { ApiNamespaceProgrammer } from "./ApiNamespaceProgrammer";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
+import { MigrateApiFunctionProgrammer } from "./MigrateApiFunctionProgrammer";
+import { MigrateApiNamespaceProgrammer } from "./MigrateApiNamespaceProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
-export namespace ApiSimulatationProgrammer {
+export namespace MigrateApiSimulatationProgrammer {
   export interface IProps {
     controller: IMigrateController;
     route: IMigrateRoute;
@@ -19,7 +19,7 @@ export namespace ApiSimulatationProgrammer {
   }
   export const random =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps) =>
       constant("random")(
         ts.factory.createArrowFunction(
@@ -59,7 +59,7 @@ export namespace ApiSimulatationProgrammer {
             )("random"),
             [
               props.route.success
-                ? SchemaProgrammer.write(components)(importer)(
+                ? MigrateSchemaProgrammer.write(components)(importer)(
                     props.route.success.schema,
                   )
                 : TypeFactory.keyword("void"),
@@ -71,7 +71,7 @@ export namespace ApiSimulatationProgrammer {
 
   export const simulate =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.VariableStatement => {
       const caller = () =>
         ts.factory.createCallExpression(
@@ -103,7 +103,7 @@ export namespace ApiSimulatationProgrammer {
         ts.factory.createArrowFunction(
           undefined,
           undefined,
-          ApiFunctionProgrammer.writeParameterDeclarations(components)(
+          MigrateApiFunctionProgrammer.writeParameterDeclarations(components)(
             importer,
           )(props),
           ts.factory.createTypeReferenceNode(
@@ -123,20 +123,20 @@ export namespace ApiSimulatationProgrammer {
 
   const assert =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (props: IProps): ts.Statement[] => {
       const parameters = [
         ...props.route.parameters.map((p) => ({
           category: "param",
           name: p.key,
-          schema: SchemaProgrammer.write(components)(importer)(p.schema),
+          schema: MigrateSchemaProgrammer.write(components)(importer)(p.schema),
         })),
         ...(props.route.query
           ? [
               {
                 category: "query",
                 name: props.route.query.key,
-                schema: SchemaProgrammer.write(components)(importer)(
+                schema: MigrateSchemaProgrammer.write(components)(importer)(
                   props.route.query.schema,
                 ),
               },
@@ -147,7 +147,7 @@ export namespace ApiSimulatationProgrammer {
               {
                 category: "body",
                 name: props.route.body.key,
-                schema: SchemaProgrammer.write(components)(importer)(
+                schema: MigrateSchemaProgrammer.write(components)(importer)(
                   props.route.body.schema,
                 ),
               },
@@ -182,7 +182,7 @@ export namespace ApiSimulatationProgrammer {
                 ),
                 ts.factory.createPropertyAssignment(
                   "path",
-                  ApiNamespaceProgrammer.writePathCallExpression(props),
+                  MigrateApiNamespaceProgrammer.writePathCallExpression(props),
                 ),
                 ts.factory.createPropertyAssignment(
                   "contentType",
@@ -242,7 +242,7 @@ export namespace ApiSimulatationProgrammer {
     };
 
   const tryAndCatch =
-    (importer: ImportProgrammer) => (individual: ts.Statement[]) =>
+    (importer: MigrateImportProgrammer) => (individual: ts.Statement[]) =>
       ts.factory.createTryStatement(
         ts.factory.createBlock(individual, true),
         ts.factory.createCatchClause(