@nestia/migrate 0.5.1 → 0.6.1

package/src/executable/bundle.ts

@@ -1,78 +1,72 @@
-import cp from "child_process";
-import fs from "fs";
-
-import { IMigrateFile } from "../structures/IMigrateFile";
-
-const ROOT = __dirname + "/../..";
-const ASSETS = ROOT + "/assets";
-const TEMPLATE = ASSETS + "/template";
-
-const clone = async (): Promise<void> => {
-    console.log("Preparing bundles...");
-
-    // CLONE REPOSITORY
-    if (fs.existsSync(TEMPLATE))
-        await fs.promises.rm(TEMPLATE, { recursive: true });
-    else
-        try {
-            await fs.promises.mkdir(ASSETS);
-        } catch {}
-
-    cp.execSync(
-        "git clone https://github.com/samchon/nestia-template template",
-        {
-            cwd: __dirname + "/../../assets",
-        },
-    );
-
-    // REMOVE VUNLERABLE FILES
-    for (const path of [
-        `${TEMPLATE}/.git`,
-        `${TEMPLATE}/src/api`,
-        `${TEMPLATE}/src/controllers`,
-        `${TEMPLATE}/src/providers`,
-        `${TEMPLATE}/test/features`,
-    ])
-        await fs.promises.rm(path, { recursive: true });
-};
-
-const iterate = (collection: IMigrateFile[]) => async (location: string) => {
-    const directory: string[] = await fs.promises.readdir(location);
-    for (const file of directory) {
-        const absolute: string = location + "/" + file;
-        const stats: fs.Stats = await fs.promises.stat(absolute);
-        if (stats.isDirectory()) await iterate(collection)(absolute);
-        else {
-            const content: string = await fs.promises.readFile(
-                absolute,
-                "utf-8",
-            );
-            collection.push({
-                location: location.replace(TEMPLATE, ""),
-                file,
-                content,
-            });
-        }
-    }
-};
-
-const archive = async (collection: IMigrateFile[]): Promise<void> => {
-    const body: string = JSON.stringify(collection, null, 4);
-    const content: string = `export const TEMPLATE = ${body}`;
-
-    try {
-        await fs.promises.mkdir(`${ROOT}/src/bundles`);
-    } catch {}
-    await fs.promises.writeFile(`${ROOT}/src/bundles/TEMPLATE.ts`, content);
-};
-
-const main = async (): Promise<void> => {
-    const collection: IMigrateFile[] = [];
-    await clone();
-    await iterate(collection)(TEMPLATE);
-    await archive(collection);
-};
-main().catch((exp) => {
-    console.error(exp);
-    process.exit(-1);
-});
+import cp from "child_process";
+import fs from "fs";
+
+import { IMigrateFile } from "../structures/IMigrateFile";
+
+const ROOT = __dirname + "/../..";
+const ASSETS = ROOT + "/assets";
+const TEMPLATE = ASSETS + "/template";
+
+const clone = async (): Promise<void> => {
+  console.log("Preparing bundles...");
+
+  // CLONE REPOSITORY
+  if (fs.existsSync(TEMPLATE))
+    await fs.promises.rm(TEMPLATE, { recursive: true });
+  else
+    try {
+      await fs.promises.mkdir(ASSETS);
+    } catch {}
+
+  cp.execSync("git clone https://github.com/samchon/nestia-template template", {
+    cwd: __dirname + "/../../assets",
+  });
+
+  // REMOVE VUNLERABLE FILES
+  for (const path of [
+    `${TEMPLATE}/.git`,
+    `${TEMPLATE}/src/api`,
+    `${TEMPLATE}/src/controllers`,
+    `${TEMPLATE}/src/providers`,
+    `${TEMPLATE}/test/features`,
+  ])
+    await fs.promises.rm(path, { recursive: true });
+};
+
+const iterate = (collection: IMigrateFile[]) => async (location: string) => {
+  const directory: string[] = await fs.promises.readdir(location);
+  for (const file of directory) {
+    const absolute: string = location + "/" + file;
+    const stats: fs.Stats = await fs.promises.stat(absolute);
+    if (stats.isDirectory()) await iterate(collection)(absolute);
+    else {
+      const content: string = await fs.promises.readFile(absolute, "utf-8");
+      collection.push({
+        location: location.replace(TEMPLATE, ""),
+        file,
+        content,
+      });
+    }
+  }
+};
+
+const archive = async (collection: IMigrateFile[]): Promise<void> => {
+  const body: string = JSON.stringify(collection, null, 4);
+  const content: string = `export const TEMPLATE = ${body}`;
+
+  try {
+    await fs.promises.mkdir(`${ROOT}/src/bundles`);
+  } catch {}
+  await fs.promises.writeFile(`${ROOT}/src/bundles/TEMPLATE.ts`, content);
+};
+
+const main = async (): Promise<void> => {
+  const collection: IMigrateFile[] = [];
+  await clone();
+  await iterate(collection)(TEMPLATE);
+  await archive(collection);
+};
+main().catch((exp) => {
+  console.error(exp);
+  process.exit(-1);
+});

package/src/executable/migrate.ts

@@ -1,60 +1,59 @@
-#!/usr/bin/env node
-import fs from "fs";
-import path from "path";
-
-import { NestiaMigrateApplication } from "../NestiaMigrateApplication";
-import { ISwagger } from "../structures/ISwagger";
-import { SetupWizard } from "../utils/SetupWizard";
-
-const USAGE = `Wrong command has been detected. Use like below:
-
-npx @nestia/migrate [input] [output]
-
-  ex) npx @nestia/migrate swagger.json my-new-project
-`;
-
-function halt(desc: string): never {
-    console.error(desc);
-    process.exit(-1);
-}
-
-const main = (argv: string[]) => {
-    const resolve = (str: string | undefined) =>
-        str ? path.resolve(str).split("\\").join("/") : undefined;
-    const input: string | undefined = resolve(argv[0]);
-    const output: string | undefined = resolve(argv[1]);
-
-    // VALIDATE ARGUMENTS
-    if (input === undefined || output === undefined) halt(USAGE);
-
-    // VALIDATE OUTPUT DIRECTORY
-    const parent: string = resolve(output + "/..")!;
-    if (fs.existsSync(output)) halt("Output directory alreay exists.");
-    else if (fs.existsSync(parent) === false)
-        halt("Output directory's parent directory does not exist.");
-    else if (fs.statSync(parent).isDirectory() === false)
-        halt("Output directory's parent is not a directory.");
-
-    // READ SWAGGER
-    const swagger: ISwagger = (() => {
-        if (fs.existsSync(input) === false)
-            halt("Unable to find the input swagger.json file.");
-        const stats: fs.Stats = fs.statSync(input);
-        if (stats.isFile() === false)
-            halt("The input swagger.json is not a file.");
-        const content: string = fs.readFileSync(input, "utf-8");
-        const swagger: ISwagger = JSON.parse(content);
-        return swagger;
-    })();
-
-    // DO GENERATE
-    const app = new NestiaMigrateApplication(swagger);
-    app.generate({
-        mkdir: fs.mkdirSync,
-        writeFile: (path, content) => fs.writeFileSync(path, content, "utf8"),
-    })(output);
-
-    // RUN SCRIPTS
-    SetupWizard.setup(output);
-};
-main(process.argv.slice(2));
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+
+import { MigrateApplication } from "../MigrateApplication";
+import { ISwagger } from "../structures/ISwagger";
+import { SetupWizard } from "../utils/SetupWizard";
+
+const USAGE = `Wrong command has been detected. Use like below:
+
+npx @nestia/migrate [input] [output]
+
+  ex) npx @nestia/migrate swagger.json my-new-project
+`;
+
+function halt(desc: string): never {
+  console.error(desc);
+  process.exit(-1);
+}
+
+const main = (argv: string[]) => {
+  const resolve = (str: string | undefined) =>
+    str ? path.resolve(str).split("\\").join("/") : undefined;
+  const input: string | undefined = resolve(argv[0]);
+  const output: string | undefined = resolve(argv[1]);
+
+  // VALIDATE ARGUMENTS
+  if (input === undefined || output === undefined) halt(USAGE);
+
+  // VALIDATE OUTPUT DIRECTORY
+  const parent: string = resolve(output + "/..")!;
+  if (fs.existsSync(output)) halt("Output directory alreay exists.");
+  else if (fs.existsSync(parent) === false)
+    halt("Output directory's parent directory does not exist.");
+  else if (fs.statSync(parent).isDirectory() === false)
+    halt("Output directory's parent is not a directory.");
+
+  // READ SWAGGER
+  const swagger: ISwagger = (() => {
+    if (fs.existsSync(input) === false)
+      halt("Unable to find the input swagger.json file.");
+    const stats: fs.Stats = fs.statSync(input);
+    if (stats.isFile() === false) halt("The input swagger.json is not a file.");
+    const content: string = fs.readFileSync(input, "utf-8");
+    const swagger: ISwagger = JSON.parse(content);
+    return swagger;
+  })();
+
+  // DO GENERATE
+  const app = new MigrateApplication(swagger);
+  app.generate({
+    mkdir: fs.mkdirSync,
+    writeFile: (path, content) => fs.writeFileSync(path, content, "utf8"),
+  })(output);
+
+  // RUN SCRIPTS
+  SetupWizard.setup(output);
+};
+main(process.argv.slice(2));

package/src/index.ts

@@ -1,4 +1,4 @@
-import * as migrate from "./module";
-
-export default migrate;
-export * from "./module";
+import * as migrate from "./module";
+
+export default migrate;
+export * from "./module";

package/src/module.ts

@@ -1,4 +1,4 @@
-export * from "./NestiaMigrateApplication";
-
-export * from "./structures/ISwagger";
-export * from "./structures/IMigrateProgram";
+export * from "./MigrateApplication";
+
+export * from "./structures/ISwagger";
+export * from "./structures/IMigrateProgram";

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;
+  }
+}