@nestia/migrate 0.7.5 → 0.7.7

package/src/programmers/{DtoProgrammer.ts → MigrateDtoProgrammer.ts}

@@ -1,20 +1,20 @@
 import { IPointer } from "tstl";
 import ts from "typescript";
 
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerSchema } from "../structures/ISwaggerSchema";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
 import { MapUtil } from "../utils/MapUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
-export namespace DtoProgrammer {
+export namespace MigrateDtoProgrammer {
   export interface IModule {
     name: string;
     children: Map<string, IModule>;
     programmer:
       | null
-      | ((importer: ImportProgrammer) => ts.TypeAliasDeclaration);
+      | ((importer: MigrateImportProgrammer) => ts.TypeAliasDeclaration);
   }
 
   export const write = (
@@ -31,7 +31,11 @@ export namespace DtoProgrammer {
   const prepare =
     (dict: Map<string, IModule>) =>
     (name: string) =>
-    (programmer: (importer: ImportProgrammer) => ts.TypeAliasDeclaration) => {
+    (
+      programmer: (
+        importer: MigrateImportProgrammer,
+      ) => ts.TypeAliasDeclaration,
+    ) => {
       const accessors: string[] = name.split(".");
       const modulo: IPointer<IModule> = { value: null! };
 
@@ -49,14 +53,14 @@ export namespace DtoProgrammer {
 
   const writeAlias =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (key: string, value: ISwaggerSchema) =>
       FilePrinter.description(
         ts.factory.createTypeAliasDeclaration(
           [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
           key.split(".").at(-1)!,
           [],
-          SchemaProgrammer.write(components)(importer)(value),
+          MigrateSchemaProgrammer.write(components)(importer)(value),
         ),
         writeComment(value),
       );

package/src/programmers/{ImportProgrammer.ts → MigrateImportProgrammer.ts}

@@ -4,14 +4,8 @@ import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
 import { FilePrinter } from "../utils/FilePrinter";
 import { MapUtil } from "../utils/MapUtil";
 
-export class ImportProgrammer {
-  private external_: Map<
-    string,
-    {
-      default: string | null;
-      instances: Set<string>;
-    }
-  > = new Map();
+export class MigrateImportProgrammer {
+  private external_: Map<string, IClause> = new Map();
   private dtos_: Set<string> = new Set();
 
   public constructor() {}
@@ -20,14 +14,14 @@ export class ImportProgrammer {
     return this.external_.size === 0 && this.dtos_.size === 0;
   }
 
-  public external(props: ImportProgrammer.IProps): string {
-    const element = MapUtil.take(this.external_)(props.library)(() => ({
+  public external(props: MigrateImportProgrammer.IProps): string {
+    const clause: IClause = MapUtil.take(this.external_)(props.library)(() => ({
       default: null,
       instances: new Set(),
     }));
     const name: string = props.name.split(".")[0];
-    if (props.type === "default") element.default = props.name;
-    else element.instances.add(name);
+    if (props.type === "default") clause.default = props.name;
+    else clause.instances.add(name);
     return name;
   }
 
@@ -38,12 +32,12 @@ export class ImportProgrammer {
   }
 
   public tag(type: string, arg: number | string): ts.TypeReferenceNode {
-    this.external({
+    const instance: string = this.external({
       type: "instance",
       library: "typia",
       name: "tags",
     });
-    return ts.factory.createTypeReferenceNode(`tags.${type}`, [
+    return ts.factory.createTypeReferenceNode(`${instance}.${type}`, [
       ts.factory.createLiteralTypeNode(
         typeof arg === "string"
           ? ts.factory.createStringLiteral(arg)
@@ -80,7 +74,9 @@ export class ImportProgrammer {
           ts.factory.createStringLiteral(library),
         );
       }),
-      ...(this.external_.size && this.dtos_.size ? [FilePrinter.enter()] : []),
+      ...(this.external_.size && this.dtos_.size
+        ? [FilePrinter.newLine()]
+        : []),
       ...[...this.dtos_]
         .filter(
           current ? (name) => name !== current!.split(".")[0] : () => true,
@@ -105,10 +101,14 @@ export class ImportProgrammer {
     ];
   }
 }
-export namespace ImportProgrammer {
+export namespace MigrateImportProgrammer {
   export interface IProps {
     type: "default" | "instance";
     library: string;
     name: string;
   }
 }
+interface IClause {
+  default: string | null;
+  instances: Set<string>;
+}

package/src/programmers/{NestControllerProgrammer.ts → MigrateNestControllerProgrammer.ts}

@@ -4,14 +4,14 @@ import { IMigrateController } from "../structures/IMigrateController";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
 import { StringUtil } from "../utils/StringUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { NestMethodProgrammer } from "./NestMethodProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateNestMethodProgrammer } from "./MigrateNestMethodProgrammer";
 
-export namespace NestControllerProgrammer {
+export namespace MigrateNestControllerProgrammer {
   export const write =
     (components: ISwaggerComponents) =>
     (controller: IMigrateController): ts.Statement[] => {
-      const importer: ImportProgrammer = new ImportProgrammer();
+      const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
       const $class = ts.factory.createClassDeclaration(
         [
           ts.factory.createDecorator(
@@ -32,7 +32,9 @@ export namespace NestControllerProgrammer {
         controller.name,
         [],
         [],
-        controller.routes.map(NestMethodProgrammer.write(components)(importer)),
+        controller.routes.map(
+          MigrateNestMethodProgrammer.write(components)(importer),
+        ),
       );
       return [
         ...importer.toStatements(
@@ -41,7 +43,7 @@ export namespace NestControllerProgrammer {
               StringUtil.splitWithNormalization(controller.location).length - 1,
             )}api/structures/${ref}`,
         ),
-        ...(importer.empty() ? [] : [FilePrinter.enter()]),
+        ...(importer.empty() ? [] : [FilePrinter.newLine()]),
         $class,
       ];
     };

package/src/programmers/{NestMethodProgrammer.ts → MigrateNestMethodProgrammer.ts}

@@ -4,20 +4,22 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
 import { IMigrateRoute } from "../structures/IMigrateRoute";
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerSchema } from "../structures/ISwaggerSchema";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
 import { StringUtil } from "../utils/StringUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
-export namespace NestMethodProgrammer {
+export namespace MigrateNestMethodProgrammer {
   export const write =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (route: IMigrateRoute): ts.MethodDeclaration => {
       const output: ts.TypeNode = route.success
-        ? SchemaProgrammer.write(components)(importer)(route.success.schema)
+        ? MigrateSchemaProgrammer.write(components)(importer)(
+            route.success.schema,
+          )
         : TypeFactory.keyword("void");
 
       const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
@@ -76,7 +78,7 @@ export namespace NestMethodProgrammer {
 
   const writeMethodDecorators =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (route: IMigrateRoute): ts.Decorator[] => {
       const external =
         (lib: string) =>
@@ -131,7 +133,11 @@ export namespace NestMethodProgrammer {
           ts.factory.createDecorator(
             ts.factory.createCallExpression(
               external("@nestia/core")("TypedException"),
-              [SchemaProgrammer.write(components)(importer)(value.schema)],
+              [
+                MigrateSchemaProgrammer.write(components)(importer)(
+                  value.schema,
+                ),
+              ],
               [
                 isNaN(Number(key))
                   ? ts.factory.createStringLiteral(key)
@@ -148,7 +154,7 @@ export namespace NestMethodProgrammer {
 
   const writeParameters =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (route: IMigrateRoute): ts.ParameterDeclaration[] => [
       ...route.parameters.map(({ key, schema: value }) =>
         ts.factory.createParameterDeclaration(
@@ -170,7 +176,7 @@ export namespace NestMethodProgrammer {
           undefined,
           StringUtil.normalize(key),
           undefined,
-          SchemaProgrammer.write(components)(importer)(value),
+          MigrateSchemaProgrammer.write(components)(importer)(value),
         ),
       ),
       ...(route.headers
@@ -210,7 +216,7 @@ export namespace NestMethodProgrammer {
   const writeDtoParameter =
     (accessor: { method: string | [string, string]; variable: string }) =>
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema): ts.ParameterDeclaration => {
       const instance = ts.factory.createIdentifier(
         importer.external({
@@ -237,7 +243,7 @@ export namespace NestMethodProgrammer {
         undefined,
         StringUtil.normalize(accessor.variable),
         undefined,
-        SchemaProgrammer.write(components)(importer)(schema),
+        MigrateSchemaProgrammer.write(components)(importer)(schema),
       );
     };
 }

package/src/programmers/{NestModuleProgrammer.ts → MigrateNestModuleProgrammer.ts}

@@ -3,14 +3,14 @@ import ts from "typescript";
 import { IMigrateController } from "../structures/IMigrateController";
 import { FilePrinter } from "../utils/FilePrinter";
 
-export namespace NestModuleProgrammer {
+export namespace MigrateNestModuleProgrammer {
   export const write = (controllers: IMigrateController[]): ts.Statement[] => [
     $import("@nestjs/common")("Module"),
-    ...(controllers.length ? [FilePrinter.enter()] : []),
+    ...(controllers.length ? [FilePrinter.newLine()] : []),
     ...controllers.map((c) =>
       $import(`${c.location.replace("src/", "./")}/${c.name}`)(c.name),
     ),
-    ...(controllers.length ? [FilePrinter.enter()] : []),
+    ...(controllers.length ? [FilePrinter.newLine()] : []),
     ts.factory.createClassDeclaration(
       [
         ts.factory.createDecorator(

package/src/programmers/{NestProgrammer.ts → MigrateNestProgrammer.ts}

@@ -3,33 +3,33 @@ import ts from "typescript";
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { FilePrinter } from "../utils/FilePrinter";
-import { DtoProgrammer } from "./DtoProgrammer";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { NestControllerProgrammer } from "./NestControllerProgrammer";
-import { NestModuleProgrammer } from "./NestModuleProgrammer";
+import { MigrateDtoProgrammer } from "./MigrateDtoProgrammer";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
+import { MigrateNestControllerProgrammer } from "./MigrateNestControllerProgrammer";
+import { MigrateNestModuleProgrammer } from "./MigrateNestModuleProgrammer";
 
-export namespace NestProgrammer {
+export namespace MigrateNestProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] =>
     [
       {
         location: "src",
         file: "MyModule.ts",
-        statements: NestModuleProgrammer.write(program.controllers),
+        statements: MigrateNestModuleProgrammer.write(program.controllers),
       },
       ...program.controllers.map((c) => ({
         location: c.location,
         file: `${c.name}.ts`,
-        statements: NestControllerProgrammer.write(program.swagger.components)(
-          c,
-        ),
+        statements: MigrateNestControllerProgrammer.write(
+          program.swagger.components,
+        )(c),
+      })),
+      ...[
+        ...MigrateDtoProgrammer.write(program.swagger.components).entries(),
+      ].map(([key, value]) => ({
+        location: "src/api/structures",
+        file: `${key}.ts`,
+        statements: writeDtoFile(key, value),
       })),
-      ...[...DtoProgrammer.write(program.swagger.components).entries()].map(
-        ([key, value]) => ({
-          location: "src/api/structures",
-          file: `${key}.ts`,
-          statements: writeDtoFile(key, value),
-        }),
-      ),
     ].map((o) => ({
       location: o.location,
       file: o.file,
@@ -38,22 +38,22 @@ export namespace NestProgrammer {
 
   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/{SchemaProgrammer.ts → MigrateSchemaProgrammer.ts}

@@ -4,47 +4,49 @@ import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { FormatCheatSheet } from "typia/lib/tags/internal/FormatCheatSheet";
 import { Escaper } from "typia/lib/utils/Escaper";
 
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerSchema } from "../structures/ISwaggerSchema";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { FilePrinter } from "../utils/FilePrinter";
-import { SwaggerTypeChecker } from "../utils/JsonTypeChecker";
-import { ImportProgrammer } from "./ImportProgrammer";
+import { SwaggerSwaggerChecker } from "../utils/SwaggerTypeChecker";
+import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
-export namespace SchemaProgrammer {
+export namespace MigrateSchemaProgrammer {
   /* -----------------------------------------------------------
     FACADE
   ----------------------------------------------------------- */
   export const write =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema): ts.TypeNode => {
       const union: ts.TypeNode[] = [];
-      if (SwaggerTypeChecker.isUnknown(schema))
+      if (SwaggerSwaggerChecker.isUnknown(schema))
         return TypeFactory.keyword("any");
-      else if (SwaggerTypeChecker.isNullOnly(schema)) return createNode("null");
-      else if (SwaggerTypeChecker.isNullable(components)(schema))
+      else if (SwaggerSwaggerChecker.isNullOnly(schema))
+        return createNode("null");
+      else if (SwaggerSwaggerChecker.isNullable(components)(schema))
         union.push(createNode("null"));
 
       const type: ts.TypeNode = (() => {
         // ATOMIC
-        if (SwaggerTypeChecker.isBoolean(schema)) return writeBoolean(schema);
-        else if (SwaggerTypeChecker.isInteger(schema))
+        if (SwaggerSwaggerChecker.isBoolean(schema))
+          return writeBoolean(schema);
+        else if (SwaggerSwaggerChecker.isInteger(schema))
           return writeInteger(importer)(schema);
-        else if (SwaggerTypeChecker.isNumber(schema))
+        else if (SwaggerSwaggerChecker.isNumber(schema))
           return writeNumber(importer)(schema);
         // INSTANCES
-        else if (SwaggerTypeChecker.isString(schema))
+        else if (SwaggerSwaggerChecker.isString(schema))
           return writeString(importer)(schema);
-        else if (SwaggerTypeChecker.isArray(schema))
+        else if (SwaggerSwaggerChecker.isArray(schema))
           return writeArray(components)(importer)(schema);
-        else if (SwaggerTypeChecker.isObject(schema))
+        else if (SwaggerSwaggerChecker.isObject(schema))
           return writeObject(components)(importer)(schema);
-        else if (SwaggerTypeChecker.isReference(schema))
+        else if (SwaggerSwaggerChecker.isReference(schema))
           return writeReference(importer)(schema);
         // NESTED UNION
-        else if (SwaggerTypeChecker.isAnyOf(schema))
+        else if (SwaggerSwaggerChecker.isAnyOf(schema))
           return writeUnion(components)(importer)(schema.anyOf);
-        else if (SwaggerTypeChecker.isOneOf(schema))
+        else if (SwaggerSwaggerChecker.isOneOf(schema))
           return writeUnion(components)(importer)(schema.oneOf);
         else return TypeFactory.keyword("any");
       })();
@@ -67,7 +69,7 @@ export namespace SchemaProgrammer {
   };
 
   const writeInteger =
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IInteger): ts.TypeNode =>
       writeNumeric(() => [
         TypeFactory.keyword("number"),
@@ -75,13 +77,13 @@ export namespace SchemaProgrammer {
       ])(importer)(schema);
 
   const writeNumber =
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.INumber): ts.TypeNode =>
       writeNumeric(() => [TypeFactory.keyword("number")])(importer)(schema);
 
   const writeNumeric =
     (factory: () => ts.TypeNode[]) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IInteger | ISwaggerSchema.INumber): ts.TypeNode => {
       if (schema.enum?.length)
         return ts.factory.createUnionTypeNode(
@@ -115,7 +117,7 @@ export namespace SchemaProgrammer {
     };
 
   const writeString =
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IString): ts.TypeNode => {
       if (schema.format === "binary")
         return ts.factory.createTypeReferenceNode("File");
@@ -145,7 +147,7 @@ export namespace SchemaProgrammer {
   ----------------------------------------------------------- */
   const writeArray =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IArray): ts.TypeNode => {
       const intersection: ts.TypeNode[] = [
         ts.factory.createArrayTypeNode(
@@ -163,7 +165,7 @@ export namespace SchemaProgrammer {
 
   const writeObject =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IObject): ts.TypeNode => {
       const regular = () =>
         ts.factory.createTypeLiteralNode(
@@ -190,7 +192,7 @@ export namespace SchemaProgrammer {
 
   const writeRegularProperty =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (required: string[]) =>
     (key: string, value: ISwaggerSchema) =>
       FilePrinter.description(
@@ -209,7 +211,7 @@ export namespace SchemaProgrammer {
 
   const writeDynamicProperty =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (value: ISwaggerSchema) =>
       FilePrinter.description(
         ts.factory.createIndexSignature(
@@ -229,7 +231,7 @@ export namespace SchemaProgrammer {
       );
 
   const writeReference =
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (schema: ISwaggerSchema.IReference): ts.TypeReferenceNode =>
       importer.dto(schema.$ref.split("/").at(-1)!);
 
@@ -238,7 +240,7 @@ export namespace SchemaProgrammer {
   ----------------------------------------------------------- */
   const writeUnion =
     (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
+    (importer: MigrateImportProgrammer) =>
     (elements: ISwaggerSchema[]): ts.UnionTypeNode =>
       ts.factory.createUnionTypeNode(elements.map(write(components)(importer)));
 }

package/src/structures/IMigrateDto.ts

@@ -1,4 +1,4 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
+import { ISwaggerSchema } from "./ISwaggerSchema";
 
 export interface IMigrateDto {
   name: string;

package/src/structures/IMigrateProgram.ts

@@ -1,9 +1,25 @@
-import { IMigrateConfig } from "../IMigrateConfig";
-import { IMigrateController } from "./IMigrateController";
-import { ISwagger } from "./ISwagger";
-
-export interface IMigrateProgram {
-  config: IMigrateConfig;
-  controllers: IMigrateController[];
-  swagger: ISwagger;
-}
+import { IMigrateController } from "./IMigrateController";
+import { IMigrateRoute } from "./IMigrateRoute";
+import { ISwagger } from "./ISwagger";
+import { ISwaggerRoute } from "./ISwaggerRoute";
+
+export interface IMigrateProgram extends IMigrateProgram.IProps {
+  controllers: IMigrateController[];
+}
+export namespace IMigrateProgram {
+  export type Dictionary = Map<ISwaggerRoute, IEntry>;
+  export interface IEntry {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+  }
+  export interface IProps {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+    swagger: ISwagger;
+    dictionary: Dictionary;
+  }
+  export interface IConfig {
+    mode: "nest" | "sdk";
+    simulate: boolean;
+  }
+}

package/src/structures/IMigrateRoute.ts

@@ -1,9 +1,10 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
+import { ISwaggerSchema } from "./ISwaggerSchema";
 
 export interface IMigrateRoute {
   name: string;
   path: string;
   method: string;
+  accessor: string[];
   parameters: IMigrateRoute.IParameter[];
   headers: IMigrateRoute.IHeaders | null;
   query: IMigrateRoute.IQuery | null;

package/src/structures/ISwaggerComponents.ts

@@ -1,4 +1,4 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
+import { ISwaggerSchema } from "./ISwaggerSchema";
 import { ISwaggerSecurity } from "./ISwaggerSecurity";
 
 export interface ISwaggerComponents {