@nestia/migrate 0.1.0

package/src/executable/bundle.ts

@@ -0,0 +1,74 @@
+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}/src/api`,
+        `${TEMPLATE}/src/controllers`,
+        `${TEMPLATE}/src/providers`,
+        `${TEMPLATE}/test/features`,
+        `${TEMPLATE}/dist`,
+    ])
+        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}`;
+    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

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import fs from "fs";
+
+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 = async (argv: string[]) => {
+    const input: string | undefined = argv[0];
+    const output: string | undefined = argv[1];
+
+    // VALIDATE ARGUMENTS
+    if (input === undefined || output === undefined) halt(USAGE);
+    else if (fs.existsSync(output)) halt("Output directory alreay exists.");
+    else if (fs.existsSync(output + "/..") === false)
+        halt("Output directory's parent directory does not exist.");
+    else if ((await fs.promises.stat(output + "/..")).isDirectory() === false)
+        halt("Output directory's parent is not a directory.");
+
+    // READ SWAGGER
+    const swagger: ISwagger = await (async () => {
+        if (fs.existsSync(input) === false)
+            halt("Unable to find the input swagger.json file.");
+        const stats: fs.Stats = await fs.promises.stat(input);
+        if (stats.isFile() === false)
+            halt("The input swagger.json is not a file.");
+        const content: string = await fs.readFileSync(input, "utf-8");
+        const swagger: ISwagger = JSON.parse(content);
+        return swagger;
+    })();
+
+    // DO GENERATE
+    const app = new NestiaMigrateApplication(swagger);
+    await app.generate({
+        mkdir: fs.promises.mkdir,
+        writeFile: (path, content) =>
+            fs.promises.writeFile(path, content, "utf8"),
+    })(output);
+
+    // RUN SCRIPTS
+    SetupWizard.setup(output);
+};
+main(process.argv.slice(2)).catch((exp) => {
+    console.log(exp);
+    process.exit(-1);
+});

package/src/index.ts

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

package/src/module.ts

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

package/src/programmers/ControllerProgrammer.ts

@@ -0,0 +1,159 @@
+import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwagger } from "../structures/ISwagger";
+import { MapUtil } from "../utils/MapUtil";
+import { StringUtil } from "../utils/StringUtil";
+import { RouteProgrammer } from "./RouteProgrammer";
+
+export namespace ControllerProgrammer {
+    export const analyze = (swagger: ISwagger): IMigrateController[] => {
+        const dict: Map<string, IMigrateRoute[]> = new Map();
+
+        // GATHER ROUTES
+        for (const [path, collection] of Object.entries(swagger.paths)) {
+            // PREPARE DIRECTORIES
+            const location: string = StringUtil.split(path)
+                .filter((str) => str[0] !== "{")
+                .join("/");
+            for (const s of sequence(location)) MapUtil.take(dict)(s)(() => []);
+
+            // INSERT ROUTES TO THE LAST DIRECTORY
+            const routes: IMigrateRoute[] = MapUtil.take(dict)(location)(
+                () => [],
+            );
+            for (const [method, value] of Object.entries(collection)) {
+                const r: IMigrateRoute | null = RouteProgrammer.analyze(
+                    swagger,
+                )({
+                    path,
+                    method,
+                })(value);
+                if (r !== null) routes.push(r);
+            }
+        }
+
+        // ABSORB STANDALONE ROUTES
+        const emended: Map<string, IMigrateRoute[]> = new Map(
+            [...dict.entries()].sort((a, b) => a[0].localeCompare(b[0])),
+        );
+        for (const [location, routes] of emended) {
+            if (routes.length !== 1) continue;
+            for (const s of sequence(location).slice(0, 1)) {
+                const parent = emended.get(s);
+                if (parent) {
+                    parent.push(...routes);
+                    emended.delete(location);
+                    break;
+                }
+            }
+        }
+
+        // GENERATE CONTROLLERS
+        return [...emended.entries()]
+            .filter(([_l, routes]) => !!routes.length)
+            .map(([location, routes]) => {
+                const prefix: string = StringUtil.commonPrefix(
+                    routes.map((r) => r.path),
+                );
+                for (const r of routes)
+                    r.path = StringUtil.reJoinWithoutParameters(
+                        r.path.replace(prefix, ""),
+                    );
+                const controller: IMigrateController = {
+                    name: StringUtil.pascal(location) + "Controller",
+                    path: StringUtil.reJoinWithoutParameters(prefix),
+                    location: "src/controllers/" + location,
+                    routes,
+                };
+                naming(controller);
+                return controller;
+            });
+    };
+
+    const sequence = (location: string): string[] =>
+        StringUtil.split(location)
+            .map((_str, i, entire) => entire.slice(0, i + 1).join("/"))
+            .slice(0, -1)
+            .reverse();
+
+    const naming = (controller: IMigrateController): void => {
+        interface IRouteCapsule {
+            variables: string[];
+            route: IMigrateRoute;
+        }
+        const dict: Map<string, IRouteCapsule[]> = new Map();
+        for (const route of controller.routes) {
+            const additional: string[] = StringUtil.split(route.path);
+            const statics: string[] = additional.filter(
+                (str) => str[0] !== ":",
+            );
+            if (statics.length)
+                route.name = StringUtil.camel(statics.join("/"));
+            else
+                MapUtil.take(dict)(route.method)(() => []).push({
+                    variables: additional
+                        .filter((str) => str[0] === ":")
+                        .map((str) => str.substring(1)),
+                    route,
+                });
+        }
+
+        for (const [method, capsules] of dict) {
+            const emended: string = method === "delete" ? "erase" : method;
+            for (const c of capsules) {
+                const empty: boolean = c.variables.length === 0;
+                c.route.name = empty
+                    ? emended
+                    : StringUtil.camel(
+                          `${emended}By/${c.variables.join("/and/")}`,
+                      );
+            }
+        }
+    };
+
+    export const write = (controller: IMigrateController): string => {
+        const references: ISwaggerSchema.IReference[] = [];
+        const body: string = [
+            `@Controller(${JSON.stringify(controller.path)})`,
+            `export class ${controller.name} {`,
+            controller.routes
+                .map((r) =>
+                    RouteProgrammer.write(references)(r)
+                        .split("\n")
+                        .map((l) => `    ${l}`)
+                        .join("\n"),
+                )
+                .join("\n\n"),
+            `}`,
+        ].join("\n");
+
+        const typia: boolean = controller.routes.some(
+            (m) => m.response !== null,
+        );
+        const imports: string[] = [
+            ...new Set(
+                references.map(
+                    (r) =>
+                        r.$ref
+                            .replace("#/components/schemas/", "")
+                            .split(".")[0],
+                ),
+            ),
+        ].map(
+            (ref) =>
+                `import { ${ref} } from "${"../".repeat(
+                    StringUtil.split(controller.location).length - 1,
+                )}api/structures/${ref}"`,
+        );
+
+        return [
+            `import core from "@nestia/core";`,
+            `import { Controller } from "@nestjs/common";`,
+            "",
+            ...(typia ? [`import typia from "typia";`, "\n"] : []),
+            ...(imports.length ? [...imports, "\n"] : []),
+            body,
+        ].join("\n");
+    };
+}

package/src/programmers/DtoProgrammer.ts

@@ -0,0 +1,122 @@
+import { IMigrateDto } from "../structures/IMigrateDto";
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwagger } from "../structures/ISwagger";
+import { MapUtil } from "../utils/MapUtil";
+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 = (dto: IMigrateDto): string => {
+        const references: ISwaggerSchema.IReference[] = [];
+        const body: string = iterate(references)(dto);
+        const imports: string[] = [
+            ...new Set(
+                references
+                    .map(
+                        (s) =>
+                            s.$ref
+                                .replace(`#/components/schemas/`, ``)
+                                .split(".")[0],
+                    )
+                    .filter((str) => str !== dto.name),
+            ),
+        ];
+        const content: string[] = [
+            ...imports.map((i) => `import { ${i} } from "./${i}";`),
+            ...(imports.length ? [""] : []),
+            body,
+        ];
+        return content.join("\n");
+    };
+
+    const iterate =
+        (references: ISwaggerSchema.IReference[]) =>
+        (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(
+                        references,
+                    )(dto.schema)}`,
+                );
+            }
+            if (dto.children.length) {
+                content.push(
+                    `export namespace ${dto.name} {`,
+                    ...dto.children.map((c) =>
+                        iterate(references)(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;
+    }
+}

package/src/programmers/MigrateProgrammer.ts

@@ -0,0 +1,31 @@
+import { IMigrateFile } from "../structures/IMigrateFile";
+import { IMigrateProgram } from "../structures/IMigrateProgram";
+import { ISwagger } from "../structures/ISwagger";
+import { ControllerProgrammer } from "./ControllerProgrammer";
+import { DtoProgrammer } from "./DtoProgrammer";
+
+export namespace MigrateProgrammer {
+    export const analyze = (swagger: ISwagger): IMigrateProgram => {
+        const controllers = ControllerProgrammer.analyze(swagger);
+        const structures = DtoProgrammer.analyze(swagger);
+        return {
+            controllers,
+            structures,
+        };
+    };
+
+    export const write = (program: IMigrateProgram): IMigrateFile[] => {
+        return [
+            ...program.controllers.map((c) => ({
+                location: c.location,
+                file: `${c.name}.ts`,
+                content: ControllerProgrammer.write(c),
+            })),
+            ...program.structures.map((s) => ({
+                location: s.location,
+                file: `${s.name}.ts`,
+                content: DtoProgrammer.write(s),
+            })),
+        ];
+    };
+}