@nestia/migrate 0.5.1 → 0.6.1

package/src/programmers/ControllerProgrammer.ts

@@ -1,157 +0,0 @@
-import { IMigrateController } from "../structures/IMigrateController";
-import { IMigrateRoute } from "../structures/IMigrateRoute";
-import { ISwaggerSchema } from "../structures/ISwaggeSchema";
-import { ISwagger } from "../structures/ISwagger";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { MapUtil } from "../utils/MapUtil";
-import { StringUtil } from "../utils/StringUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-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.splitWithNormalization(path)
-                .filter((str) => str[0] !== "{" && 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.reJoinWithDecimalParameters(
-                        r.path.replace(prefix, ""),
-                    );
-                const controller: IMigrateController = {
-                    name: StringUtil.pascal(location) + "Controller",
-                    path: StringUtil.reJoinWithDecimalParameters(prefix),
-                    location: "src/controllers/" + location,
-                    routes,
-                };
-                if (controller.name === "Controller")
-                    controller.name = "__Controller";
-                naming(controller);
-                return controller;
-            });
-    };
-
-    const sequence = (location: string): string[] =>
-        StringUtil.splitWithNormalization(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.splitWithNormalization(
-                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 =
-        (components: ISwaggerComponents) =>
-        (controller: IMigrateController): string => {
-            const importer: ImportProgrammer = new ImportProgrammer(null);
-            const references: ISwaggerSchema.IReference[] = [];
-            const body: string = [
-                `@${importer.external({
-                    library: "@nestjs/common",
-                    instance: "Controller",
-                })}(${JSON.stringify(controller.path)})`,
-                `export class ${controller.name} {`,
-                controller.routes
-                    .map((r) =>
-                        RouteProgrammer.write(components)(references)(importer)(
-                            r,
-                        )
-                            .split("\n")
-                            .map((l) => `    ${l}`)
-                            .join("\n"),
-                    )
-                    .join("\n\n"),
-                `}`,
-            ].join("\n");
-            return [
-                ...importer.toScript(
-                    (ref) =>
-                        `${"../".repeat(
-                            StringUtil.splitWithNormalization(
-                                controller.location,
-                            ).length - 1,
-                        )}api/structures/${ref}`,
-                ),
-                ...(importer.empty() ? [] : [""]),
-                body,
-            ].join("\n");
-        };
-}

package/src/programmers/MigrateProgrammer.ts

@@ -1,62 +0,0 @@
-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");