@nestia/migrate 0.7.0-dev.20240201 → 0.7.1

package/src/programmers/ImportProgrammer.ts

@@ -1,114 +1,114 @@
-import ts from "typescript";
-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();
-  private dtos_: Set<string> = new Set();
-
-  public constructor() {}
-
-  public empty(): boolean {
-    return this.external_.size === 0 && this.dtos_.size === 0;
-  }
-
-  public external(props: ImportProgrammer.IProps): string {
-    const element = 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);
-    return name;
-  }
-
-  public dto(name: string): ts.TypeReferenceNode {
-    const file: string = name.split(".")[0];
-    this.dtos_.add(file);
-    return ts.factory.createTypeReferenceNode(name);
-  }
-
-  public tag(type: string, arg: number | string): ts.TypeReferenceNode {
-    this.external({
-      type: "instance",
-      library: "typia",
-      name: "tags",
-    });
-    return ts.factory.createTypeReferenceNode(`tags.${type}`, [
-      ts.factory.createLiteralTypeNode(
-        typeof arg === "string"
-          ? ts.factory.createStringLiteral(arg)
-          : ExpressionFactory.number(arg),
-      ),
-    ]);
-  }
-
-  public toStatements(
-    dtoPath: (name: string) => string,
-    current?: string,
-  ): ts.Statement[] {
-    return [
-      ...[...this.external_.entries()].map(([library, props]) => {
-        return ts.factory.createImportDeclaration(
-          undefined,
-          ts.factory.createImportClause(
-            false,
-            props.default !== null
-              ? ts.factory.createIdentifier(props.default)
-              : undefined,
-            props.instances.size
-              ? ts.factory.createNamedImports(
-                  [...props.instances].map((i) =>
-                    ts.factory.createImportSpecifier(
-                      false,
-                      undefined,
-                      ts.factory.createIdentifier(i),
-                    ),
-                  ),
-                )
-              : undefined,
-          ),
-          ts.factory.createStringLiteral(library),
-        );
-      }),
-      ...(this.external_.size && this.dtos_.size ? [FilePrinter.enter()] : []),
-      ...[...this.dtos_]
-        .filter(
-          current ? (name) => name !== current!.split(".")[0] : () => true,
-        )
-        .map((i) =>
-          ts.factory.createImportDeclaration(
-            undefined,
-            ts.factory.createImportClause(
-              false,
-              undefined,
-              ts.factory.createNamedImports([
-                ts.factory.createImportSpecifier(
-                  false,
-                  undefined,
-                  ts.factory.createIdentifier(i),
-                ),
-              ]),
-            ),
-            ts.factory.createStringLiteral(dtoPath(i)),
-          ),
-        ),
-    ];
-  }
-}
-export namespace ImportProgrammer {
-  export interface IProps {
-    type: "default" | "instance";
-    library: string;
-    name: string;
-  }
-}
+import ts from "typescript";
+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();
+  private dtos_: Set<string> = new Set();
+
+  public constructor() {}
+
+  public empty(): boolean {
+    return this.external_.size === 0 && this.dtos_.size === 0;
+  }
+
+  public external(props: ImportProgrammer.IProps): string {
+    const element = 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);
+    return name;
+  }
+
+  public dto(name: string): ts.TypeReferenceNode {
+    const file: string = name.split(".")[0];
+    this.dtos_.add(file);
+    return ts.factory.createTypeReferenceNode(name);
+  }
+
+  public tag(type: string, arg: number | string): ts.TypeReferenceNode {
+    this.external({
+      type: "instance",
+      library: "typia",
+      name: "tags",
+    });
+    return ts.factory.createTypeReferenceNode(`tags.${type}`, [
+      ts.factory.createLiteralTypeNode(
+        typeof arg === "string"
+          ? ts.factory.createStringLiteral(arg)
+          : ExpressionFactory.number(arg),
+      ),
+    ]);
+  }
+
+  public toStatements(
+    dtoPath: (name: string) => string,
+    current?: string,
+  ): ts.Statement[] {
+    return [
+      ...[...this.external_.entries()].map(([library, props]) => {
+        return ts.factory.createImportDeclaration(
+          undefined,
+          ts.factory.createImportClause(
+            false,
+            props.default !== null
+              ? ts.factory.createIdentifier(props.default)
+              : undefined,
+            props.instances.size
+              ? ts.factory.createNamedImports(
+                  [...props.instances].map((i) =>
+                    ts.factory.createImportSpecifier(
+                      false,
+                      undefined,
+                      ts.factory.createIdentifier(i),
+                    ),
+                  ),
+                )
+              : undefined,
+          ),
+          ts.factory.createStringLiteral(library),
+        );
+      }),
+      ...(this.external_.size && this.dtos_.size ? [FilePrinter.enter()] : []),
+      ...[...this.dtos_]
+        .filter(
+          current ? (name) => name !== current!.split(".")[0] : () => true,
+        )
+        .map((i) =>
+          ts.factory.createImportDeclaration(
+            undefined,
+            ts.factory.createImportClause(
+              false,
+              undefined,
+              ts.factory.createNamedImports([
+                ts.factory.createImportSpecifier(
+                  false,
+                  undefined,
+                  ts.factory.createIdentifier(i),
+                ),
+              ]),
+            ),
+            ts.factory.createStringLiteral(dtoPath(i)),
+          ),
+        ),
+    ];
+  }
+}
+export namespace ImportProgrammer {
+  export interface IProps {
+    type: "default" | "instance";
+    library: string;
+    name: string;
+  }
+}

package/src/programmers/NestControllerProgrammer.ts

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-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";
-
-export namespace NestControllerProgrammer {
-  export const write =
-    (components: ISwaggerComponents) =>
-    (controller: IMigrateController): ts.Statement[] => {
-      const importer: ImportProgrammer = new ImportProgrammer();
-      const $class = ts.factory.createClassDeclaration(
-        [
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                importer.external({
-                  type: "instance",
-                  library: "@nestjs/common",
-                  name: "Controller",
-                }),
-              ),
-              [],
-              [ts.factory.createStringLiteral(controller.path)],
-            ),
-          ),
-          ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
-        ],
-        controller.name,
-        [],
-        [],
-        controller.routes.map(NestMethodProgrammer.write(components)(importer)),
-      );
-      return [
-        ...importer.toStatements(
-          (ref) =>
-            `${"../".repeat(
-              StringUtil.splitWithNormalization(controller.location).length - 1,
-            )}api/structures/${ref}`,
-        ),
-        ...(importer.empty() ? [] : [FilePrinter.enter()]),
-        $class,
-      ];
-    };
-}
+import ts from "typescript";
+
+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";
+
+export namespace NestControllerProgrammer {
+  export const write =
+    (components: ISwaggerComponents) =>
+    (controller: IMigrateController): ts.Statement[] => {
+      const importer: ImportProgrammer = new ImportProgrammer();
+      const $class = ts.factory.createClassDeclaration(
+        [
+          ts.factory.createDecorator(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(
+                importer.external({
+                  type: "instance",
+                  library: "@nestjs/common",
+                  name: "Controller",
+                }),
+              ),
+              [],
+              [ts.factory.createStringLiteral(controller.path)],
+            ),
+          ),
+          ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
+        ],
+        controller.name,
+        [],
+        [],
+        controller.routes.map(NestMethodProgrammer.write(components)(importer)),
+      );
+      return [
+        ...importer.toStatements(
+          (ref) =>
+            `${"../".repeat(
+              StringUtil.splitWithNormalization(controller.location).length - 1,
+            )}api/structures/${ref}`,
+        ),
+        ...(importer.empty() ? [] : [FilePrinter.enter()]),
+        $class,
+      ];
+    };
+}

package/src/programmers/NestProgrammer.ts

@@ -1,74 +1,74 @@
-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";
-
-export namespace NestProgrammer {
-  export const write = (program: IMigrateProgram): IMigrateFile[] =>
-    [
-      {
-        location: "src",
-        file: "MyModule.ts",
-        statements: NestModuleProgrammer.write(program.controllers),
-      },
-      ...program.controllers.map((c) => ({
-        location: c.location,
-        file: `${c.name}.ts`,
-        statements: NestControllerProgrammer.write(program.swagger.components)(
-          c,
-        ),
-      })),
-      ...[...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,
-      content: FilePrinter.write({ statements: o.statements }),
-    }));
-
-  const writeDtoFile = (
-    key: string,
-    modulo: DtoProgrammer.IModule,
-  ): ts.Statement[] => {
-    const importer = new ImportProgrammer();
-    const statements: ts.Statement[] = iterate(importer)(modulo);
-    if (statements.length === 0) return [];
-
-    return [
-      ...importer.toStatements((name) => `./${name}`, key),
-      ...(importer.empty() ? [] : [FilePrinter.enter()]),
-      ...statements,
-    ];
-  };
-
-  const iterate =
-    (importer: ImportProgrammer) =>
-    (modulo: DtoProgrammer.IModule): ts.Statement[] => {
-      const output: ts.Statement[] = [];
-      if (modulo.programmer !== null) output.push(modulo.programmer(importer));
-      if (modulo.children.size) {
-        const internal: ts.Statement[] = [];
-        for (const child of modulo.children.values())
-          internal.push(...iterate(importer)(child));
-        output.push(
-          ts.factory.createModuleDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            ts.factory.createIdentifier(modulo.name),
-            ts.factory.createModuleBlock(internal),
-            ts.NodeFlags.Namespace,
-          ),
-        );
-      }
-      return output;
-    };
-}
+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";
+
+export namespace NestProgrammer {
+  export const write = (program: IMigrateProgram): IMigrateFile[] =>
+    [
+      {
+        location: "src",
+        file: "MyModule.ts",
+        statements: NestModuleProgrammer.write(program.controllers),
+      },
+      ...program.controllers.map((c) => ({
+        location: c.location,
+        file: `${c.name}.ts`,
+        statements: NestControllerProgrammer.write(program.swagger.components)(
+          c,
+        ),
+      })),
+      ...[...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,
+      content: FilePrinter.write({ statements: o.statements }),
+    }));
+
+  const writeDtoFile = (
+    key: string,
+    modulo: DtoProgrammer.IModule,
+  ): ts.Statement[] => {
+    const importer = new ImportProgrammer();
+    const statements: ts.Statement[] = iterate(importer)(modulo);
+    if (statements.length === 0) return [];
+
+    return [
+      ...importer.toStatements((name) => `./${name}`, key),
+      ...(importer.empty() ? [] : [FilePrinter.enter()]),
+      ...statements,
+    ];
+  };
+
+  const iterate =
+    (importer: ImportProgrammer) =>
+    (modulo: DtoProgrammer.IModule): ts.Statement[] => {
+      const output: ts.Statement[] = [];
+      if (modulo.programmer !== null) output.push(modulo.programmer(importer));
+      if (modulo.children.size) {
+        const internal: ts.Statement[] = [];
+        for (const child of modulo.children.values())
+          internal.push(...iterate(importer)(child));
+        output.push(
+          ts.factory.createModuleDeclaration(
+            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            ts.factory.createIdentifier(modulo.name),
+            ts.factory.createModuleBlock(internal),
+            ts.NodeFlags.Namespace,
+          ),
+        );
+      }
+      return output;
+    };
+}

package/src/structures/IMigrateProgram.ts

@@ -1,9 +1,9 @@
-import { IMigrateConfig } from "../IMigrateConfig";
-import { IMigrateController } from "./IMigrateController";
-import { ISwagger } from "./ISwagger";
-
-export interface IMigrateProgram {
-  config: IMigrateConfig;
-  controllers: IMigrateController[];
-  swagger: ISwagger;
-}
+import { IMigrateConfig } from "../IMigrateConfig";
+import { IMigrateController } from "./IMigrateController";
+import { ISwagger } from "./ISwagger";
+
+export interface IMigrateProgram {
+  config: IMigrateConfig;
+  controllers: IMigrateController[];
+  swagger: ISwagger;
+}

package/src/structures/IMigrateRoute.ts

@@ -1,44 +1,44 @@
-import { ISwaggerSchema } from "./ISwaggeSchema";
-
-export interface IMigrateRoute {
-  name: string;
-  path: string;
-  method: string;
-  parameters: IMigrateRoute.IParameter[];
-  headers: IMigrateRoute.IHeaders | null;
-  query: IMigrateRoute.IQuery | null;
-  body: IMigrateRoute.IBody | null;
-  success: IMigrateRoute.IBody | null;
-  exceptions: Record<string, IMigrateRoute.IException>;
-  description?: string;
-  tags: string[];
-  deprecated: boolean;
-}
-export namespace IMigrateRoute {
-  export interface IParameter {
-    key: string;
-    schema: ISwaggerSchema;
-    description?: string;
-  }
-  export interface IHeaders {
-    key: string;
-    schema: ISwaggerSchema;
-  }
-  export interface IQuery {
-    key: string;
-    schema: ISwaggerSchema;
-  }
-  export interface IBody {
-    key: string;
-    type:
-      | "text/plain"
-      | "application/json"
-      | "application/x-www-form-urlencoded";
-    schema: ISwaggerSchema;
-    "x-nestia-encrypted"?: boolean;
-  }
-  export interface IException {
-    description?: string;
-    schema: ISwaggerSchema;
-  }
-}
+import { ISwaggerSchema } from "./ISwaggeSchema";
+
+export interface IMigrateRoute {
+  name: string;
+  path: string;
+  method: string;
+  parameters: IMigrateRoute.IParameter[];
+  headers: IMigrateRoute.IHeaders | null;
+  query: IMigrateRoute.IQuery | null;
+  body: IMigrateRoute.IBody | null;
+  success: IMigrateRoute.IBody | null;
+  exceptions: Record<string, IMigrateRoute.IException>;
+  description?: string;
+  tags: string[];
+  deprecated: boolean;
+}
+export namespace IMigrateRoute {
+  export interface IParameter {
+    key: string;
+    schema: ISwaggerSchema;
+    description?: string;
+  }
+  export interface IHeaders {
+    key: string;
+    schema: ISwaggerSchema;
+  }
+  export interface IQuery {
+    key: string;
+    schema: ISwaggerSchema;
+  }
+  export interface IBody {
+    key: string;
+    type:
+      | "text/plain"
+      | "application/json"
+      | "application/x-www-form-urlencoded";
+    schema: ISwaggerSchema;
+    "x-nestia-encrypted"?: boolean;
+  }
+  export interface IException {
+    description?: string;
+    schema: ISwaggerSchema;
+  }
+}