@nestia/migrate 0.5.0 → 0.6.0

package/src/programmers/DtoProgrammer.ts

@@ -1,118 +1,74 @@
-import { IMigrateDto } from "../structures/IMigrateDto";
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
-import { ISwagger } from "../structures/ISwagger";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { MapUtil } from "../utils/MapUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
-
-export namespace DtoProgrammer {
-    export const analyze = (swagger: ISwagger): IMigrateDto[] => {
-        const root: Modulo = new Modulo("");
-
-        // COMPONENTS
-        for (const [id, schema] of Object.entries(
-            swagger.components.schemas ?? {},
-        )) {
-            const modulo = emplace(root)(id);
-            modulo.dto.schema = schema;
-        }
-        return root.toDto().children;
-    };
-
-    const emplace = (modulo: Modulo) => (name: string) => {
-        const identifiers: string[] = name.split(".");
-        for (const key of identifiers)
-            modulo = MapUtil.take(modulo.children)(key)(() => new Modulo(key));
-        return modulo;
-    };
-
-    export const write =
-        (components: ISwaggerComponents) =>
-        (dto: IMigrateDto): string => {
-            const references: ISwaggerSchema.IReference[] = [];
-            const importer: ImportProgrammer = new ImportProgrammer(dto.name);
-            const body: string = iterate(components)(references)(importer)(dto);
-
-            const content: string[] = [
-                ...importer.toScript((name) => `./${name}`, dto.name),
-                ...(importer.empty() ? [] : [""]),
-                body,
-            ];
-            return content.join("\n");
-        };
-
-    const iterate =
-        (components: ISwaggerComponents) =>
-        (references: ISwaggerSchema.IReference[]) =>
-        (importer: ImportProgrammer) =>
-        (dto: IMigrateDto): string => {
-            const content: string[] = [];
-            if (dto.schema) {
-                const description: string | undefined = describe(dto.schema);
-                content.push(
-                    ...(description
-                        ? [
-                              "/**",
-                              ...description.split("\n").map((l) => ` * ${l}`),
-                              " */",
-                          ]
-                        : []),
-                    `export type ${dto.name} = ${SchemaProgrammer.write(
-                        components,
-                    )(references)(importer)(dto.schema)}`,
-                );
-            }
-            if (dto.children.length) {
-                content.push(
-                    `export namespace ${dto.name} {`,
-                    ...dto.children.map((c) =>
-                        iterate(components)(references)(importer)(c)
-                            .split("\n")
-                            .map((l) => `    ${l}`)
-                            .join("\n"),
-                    ),
-                    `}`,
-                );
-            }
-            return content.join("\n");
-        };
-
-    const describe = (schema: ISwaggerSchema): string | undefined => {
-        const content: string[] = [];
-        const add = (text: string) => {
-            if (schema.description && !schema.description.includes(text))
-                content.push(text);
-        };
-        if (schema.description) {
-            content.push(...schema.description.split("\n"));
-            if (!schema.description.split("\n").at(-1)?.startsWith("@"))
-                content.push("");
-        }
-        if (schema.deprecated) add("@deprecated");
-        if (schema.title) add(`@title ${schema.title}`);
-        return content.length ? content.join("\n") : undefined;
-    };
-}
-
-class Modulo {
-    public readonly dto: IMigrateDto;
-    public readonly children: Map<string, Modulo>;
-
-    public constructor(name: string) {
-        this.dto = {
-            name,
-            location: "src/api/structures",
-            schema: null,
-            children: [],
-        };
-        this.children = new Map();
-    }
-
-    public toDto(): IMigrateDto {
-        this.dto.children = Array.from(this.children.values()).map((modulo) =>
-            modulo.toDto(),
-        );
-        return this.dto;
-    }
-}
+import { IPointer } from "tstl";
+import ts from "typescript";
+
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { FilePrinter } from "../utils/FilePrinter";
+import { MapUtil } from "../utils/MapUtil";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { SchemaProgrammer } from "./SchemaProgrammer";
+
+export namespace DtoProgrammer {
+  export interface IModule {
+    name: string;
+    children: Map<string, IModule>;
+    programmer:
+      | null
+      | ((importer: ImportProgrammer) => ts.TypeAliasDeclaration);
+  }
+
+  export const write = (
+    components: ISwaggerComponents,
+  ): Map<string, IModule> => {
+    const dict: Map<string, IModule> = new Map();
+    for (const [key, value] of Object.entries(components.schemas ?? {}))
+      prepare(dict)(key)((importer) =>
+        writeAlias(importer)(components)(key, value),
+      );
+    return dict;
+  };
+
+  const prepare =
+    (dict: Map<string, IModule>) =>
+    (name: string) =>
+    (programmer: (importer: ImportProgrammer) => ts.TypeAliasDeclaration) => {
+      const accessors: string[] = name.split(".");
+      const modulo: IPointer<IModule> = { value: null! };
+
+      accessors.forEach((acc, i) => {
+        modulo.value = MapUtil.take(dict)(acc)(() => ({
+          name: acc,
+          children: new Map(),
+          programmer: null,
+        }));
+        if (i === accessors.length - 1) modulo.value.programmer = programmer;
+        dict = modulo.value.children;
+      });
+      return modulo!;
+    };
+
+  const writeAlias =
+    (importer: ImportProgrammer) =>
+    (components: ISwaggerComponents) =>
+    (key: string, value: ISwaggerSchema) =>
+      FilePrinter.description(
+        ts.factory.createTypeAliasDeclaration(
+          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+          key.split(".").at(-1)!,
+          [],
+          SchemaProgrammer.write(importer)(components)(value),
+        ),
+        writeComment(value),
+      );
+}
+
+const writeComment = (schema: ISwaggerSchema): string =>
+  [
+    ...(schema.description?.length ? [schema.description] : []),
+    ...(schema.description?.length &&
+    (schema.title !== undefined || schema.deprecated === true)
+      ? [""]
+      : []),
+    ...(schema.title !== undefined ? [`@title ${schema.title}`] : []),
+    ...(schema.deprecated === true ? [`@deprecated`] : []),
+  ].join("\n");

package/src/programmers/ImportProgrammer.ts

@@ -1,60 +1,98 @@
-import { MapUtil } from "../utils/MapUtil";
-
-export class ImportProgrammer {
-    private external_: Map<string, Set<string>> = new Map();
-    private dtos_: Set<string> = new Set();
-
-    public constructor(public readonly name: string | null) {}
-
-    public empty(): boolean {
-        return this.external_.size === 0 && this.dtos_.size === 0;
-    }
-
-    public external(props: ImportProgrammer.IProps): string {
-        MapUtil.take(this.external_)(props.library)(() => new Set()).add(
-            props.instance.split(".")[0],
-        );
-        return props.instance;
-    }
-
-    public tag(type: string, arg: number | string): string {
-        this.external({
-            library: "typia",
-            instance: "tags",
-        });
-        return `tags.${type}<${JSON.stringify(arg)}>`;
-    }
-
-    public dto(name: string): string {
-        const file: string = name.split(".")[0];
-        if (this.name !== file) this.dtos_.add(file);
-        return name;
-    }
-
-    public toScript(
-        dtoPath: (name: string) => string,
-        current?: string,
-    ): string[] {
-        const content: string[] = [...this.external_.entries()].map(
-            ([library, properties]) =>
-                `import { ${[...properties].join(", ")} } from "${library}";`,
-        );
-        if (this.external_.size && this.dtos_.size) content.push("");
-        content.push(
-            ...[...this.dtos_]
-                .filter(
-                    current
-                        ? (name) => name !== current!.split(".")[0]
-                        : () => true,
-                )
-                .map((i) => `import { ${i} } from "${dtoPath(i)}";`),
-        );
-        return content;
-    }
-}
-export namespace ImportProgrammer {
-    export interface IProps {
-        library: string;
-        instance: 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, 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 {
+    MapUtil.take(this.external_)(props.library)(() => new Set()).add(
+      props.instance.split(".")[0],
+    );
+    return props.instance;
+  }
+
+  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({
+      library: "typia",
+      instance: "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, properties]) =>
+        ts.factory.createImportDeclaration(
+          undefined,
+          ts.factory.createImportClause(
+            false,
+            undefined,
+            ts.factory.createNamedImports(
+              [...properties].map((i) =>
+                ts.factory.createImportSpecifier(
+                  false,
+                  undefined,
+                  ts.factory.createIdentifier(i),
+                ),
+              ),
+            ),
+          ),
+          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 {
+    library: string;
+    instance: string;
+  }
+}

package/src/programmers/MigrateProgrammer.ts

@@ -1,62 +1,75 @@
-import { IMigrateController } from "../structures/IMigrateController";
-import { IMigrateDto } from "../structures/IMigrateDto";
-import { IMigrateFile } from "../structures/IMigrateFile";
-import { IMigrateProgram } from "../structures/IMigrateProgram";
-import { ISwagger } from "../structures/ISwagger";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { ControllerProgrammer } from "./ControllerProgrammer";
-import { DtoProgrammer } from "./DtoProgrammer";
-
-export namespace MigrateProgrammer {
-    export const analyze = (swagger: ISwagger): IMigrateProgram => {
-        const controllers: IMigrateController[] =
-            ControllerProgrammer.analyze(swagger);
-        const structures: IMigrateDto[] = DtoProgrammer.analyze(swagger);
-        return {
-            controllers,
-            structures,
-        };
-    };
-
-    export const write =
-        (components: ISwaggerComponents) =>
-        (program: IMigrateProgram): IMigrateFile[] => {
-            return [
-                ...program.structures.map((s) => ({
-                    location: s.location,
-                    file: `${s.name}.ts`,
-                    content: DtoProgrammer.write(components)(s),
-                })),
-                ...program.controllers.map((c) => ({
-                    location: c.location,
-                    file: `${c.name}.ts`,
-                    content: ControllerProgrammer.write(components)(c),
-                })),
-                {
-                    location: "src",
-                    file: "MyModule.ts",
-                    content: MyModule(program.controllers),
-                },
-            ];
-        };
-}
-
-const MyModule = (controllers: IMigrateController[]): string =>
-    [
-        `import { Module } from "@nestjs/common";`,
-        ``,
-        ...controllers.map(
-            (c) =>
-                `import { ${c.name} } from "${c.location.replace(
-                    "src/",
-                    "./",
-                )}/${c.name}";`,
-        ),
-        ``,
-        `@Module({`,
-        `    controllers: [`,
-        ...controllers.map((c) => `        ${c.name},`),
-        `    ],`,
-        `})`,
-        `export class MyModule {}`,
-    ].join("\n");
+import ts from "typescript";
+
+import { IMigrateFile } from "../structures/IMigrateFile";
+import { IMigrateProgram } from "../structures/IMigrateProgram";
+import { ISwagger } from "../structures/ISwagger";
+import { FilePrinter } from "../utils/FilePrinter";
+import { ControllerProgrammer } from "./ControllerProgrammer";
+import { DtoProgrammer } from "./DtoProgrammer";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { ModuleProgrammer } from "./ModuleProgrammer";
+
+export namespace MigrateProgrammer {
+  export const analyze = (swagger: ISwagger): IMigrateProgram => ({
+    swagger,
+    controllers: ControllerProgrammer.analyze(swagger),
+  });
+
+  export const write = (program: IMigrateProgram): IMigrateFile[] =>
+    [
+      {
+        location: "src",
+        file: "MyModule.ts",
+        statements: ModuleProgrammer.write(program.controllers),
+      },
+      ...program.controllers.map((c) => ({
+        location: c.location,
+        file: `${c.name}.ts`,
+        statements: ControllerProgrammer.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/programmers/ModuleProgrammer.ts

@@ -0,0 +1,62 @@
+import ts from "typescript";
+
+import { IMigrateController } from "../structures/IMigrateController";
+import { FilePrinter } from "../utils/FilePrinter";
+
+export namespace ModuleProgrammer {
+  export const write = (controllers: IMigrateController[]): ts.Statement[] => [
+    $import("@nestjs/common")("Module"),
+    ...(controllers.length ? [FilePrinter.enter()] : []),
+    ...controllers.map((c) =>
+      $import(`${c.location.replace("src/", "./")}/${c.name}`)(c.name),
+    ),
+    ...(controllers.length ? [FilePrinter.enter()] : []),
+    ts.factory.createClassDeclaration(
+      [
+        ts.factory.createDecorator(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Module"),
+            undefined,
+            [
+              ts.factory.createObjectLiteralExpression(
+                [
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("controllers"),
+                    ts.factory.createArrayLiteralExpression(
+                      controllers.map((c) =>
+                        ts.factory.createIdentifier(c.name),
+                      ),
+                    ),
+                  ),
+                ],
+                true,
+              ),
+            ],
+          ),
+        ),
+        ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
+      ],
+      "MyModule",
+      undefined,
+      undefined,
+      [],
+    ),
+  ];
+}
+
+const $import = (file: string) => (instance: string) =>
+  ts.factory.createImportDeclaration(
+    undefined,
+    ts.factory.createImportClause(
+      false,
+      undefined,
+      ts.factory.createNamedImports([
+        ts.factory.createImportSpecifier(
+          false,
+          undefined,
+          ts.factory.createIdentifier(instance),
+        ),
+      ]),
+    ),
+    ts.factory.createStringLiteral(file),
+  );