@nestia/migrate 0.6.0 → 0.6.2

package/src/{programmers/ControllerProgrammer.ts → analyzers/ControllerAnalyzer.ts}

@@ -1,155 +1,123 @@
-import ts from "typescript";
-
-import { IMigrateController } from "../structures/IMigrateController";
-import { IMigrateRoute } from "../structures/IMigrateRoute";
-import { ISwagger } from "../structures/ISwagger";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
-import { FilePrinter } from "../utils/FilePrinter";
-import { MapUtil } from "../utils/MapUtil";
-import { StringUtil } from "../utils/StringUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { RouteProgrammer } from "./RouteProgrammer";
-
-export namespace ControllerProgrammer {
-  /* -----------------------------------------------------------
-    ANALYZERS
-  ----------------------------------------------------------- */
-  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/")}`);
-      }
-    }
-  };
-
-  /* -----------------------------------------------------------
-    WRITERS
-  ----------------------------------------------------------- */
-  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({
-                  library: "@nestjs/common",
-                  instance: "Controller",
-                }),
-              ),
-              [],
-              [ts.factory.createStringLiteral(controller.path)],
-            ),
-          ),
-          ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
-        ],
-        controller.name,
-        [],
-        [],
-        controller.routes.map(RouteProgrammer.write(components)(importer)),
-      );
-      return [
-        ...importer.toStatements(
-          (ref) =>
-            `${"../".repeat(
-              StringUtil.splitWithNormalization(controller.location).length - 1,
-            )}api/structures/${ref}`,
-        ),
-        ...(importer.empty() ? [] : [FilePrinter.enter()]),
-        $class,
-      ];
-    };
-}
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { ISwagger } from "../module";
+import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { MapUtil } from "../utils/MapUtil";
+import { StringUtil } from "../utils/StringUtil";
+import { MethodAnalzyer } from "./MethodAnalyzer";
+
+export namespace ControllerAnalyzer {
+  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 = MethodAnalzyer.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";
+        emend(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 emend = (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/")}`);
+      }
+    }
+    for (const method of controller.routes) {
+      if (Escaper.variable(method.name) === false)
+        method.name = "_" + method.name;
+      for (const spec of [method.headers, method.query, method.body])
+        if (spec)
+          spec.key = StringUtil.escapeDuplicate(
+            method.parameters.map((p) => p.key),
+          )(spec.key);
+    }
+    controller.routes.forEach(
+      (r, i) =>
+        (r.name = StringUtil.escapeDuplicate(
+          controller.routes.filter((_r, j) => i !== j).map((x) => x.name),
+        )(r.name)),
+    );
+  };
+}

package/src/{programmers/RouteProgrammer.ts → analyzers/MethodAnalyzer.ts}

@@ -1,24 +1,13 @@
-import ts from "typescript";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
 import { Escaper } from "typia/lib/utils/Escaper";
 
+import { ISwagger } from "../module";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerSchema } from "../structures/ISwaggeSchema";
-import { ISwagger } from "../structures/ISwagger";
-import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { ISwaggerRoute } from "../structures/ISwaggerRoute";
-import { FilePrinter } from "../utils/FilePrinter";
 import { SwaggerTypeChecker } from "../utils/JsonTypeChecker";
 import { StringUtil } from "../utils/StringUtil";
-import { ImportProgrammer } from "./ImportProgrammer";
-import { SchemaProgrammer } from "./SchemaProgrammer";
 
-export namespace RouteProgrammer {
-  /* -----------------------------------------------------------
-    ANALYZERS
-  ----------------------------------------------------------- */
+export namespace MethodAnalzyer {
   export const analyze =
     (swagger: ISwagger) =>
     (props: { path: string; method: string }) =>
@@ -172,14 +161,18 @@ export namespace RouteProgrammer {
         name: "@lazy",
         path: props.path,
         method: props.method,
-        headers,
+        headers: headers
+          ? {
+              key: "headers",
+              schema: headers,
+            }
+          : null,
         parameters: (route.parameters ?? [])
           .filter((p) => p.in === "path")
           .map((p, i) => ({
             key: (() => {
               let key: string = StringUtil.normalize(parameterNames[i]);
               if (Escaper.variable(key)) return key;
-
               while (true) {
                 key = "_" + key;
                 if (!parameterNames.some((s) => s === key)) return key;
@@ -190,7 +183,12 @@ export namespace RouteProgrammer {
               description: p.schema.description ?? p.description,
             },
           })),
-        query,
+        query: query
+          ? {
+              key: "query",
+              schema: query,
+            }
+          : null,
         body,
         success,
         exceptions: Object.fromEntries(
@@ -209,8 +207,9 @@ export namespace RouteProgrammer {
               },
             ]),
         ),
+        deprecated: route.deprecated ?? false,
         description: describe(route),
-        "x-nestia-jsDocTags": route["x-nestia-jsDocTags"],
+        tags: route.tags ?? [],
       };
     };
 
@@ -285,6 +284,7 @@ export namespace RouteProgrammer {
         const { schema } = json[1];
         return {
           type: "application/json",
+          key: "body",
           schema: isNotObjectLiteral(schema) ? schema : emplacer(schema),
           "x-nestia-encrypted": meta["x-nestia-encrypted"],
         };
@@ -297,12 +297,14 @@ export namespace RouteProgrammer {
         const { schema } = query[1];
         return {
           type: "application/x-www-form-urlencoded",
+          key: "body",
           schema: isNotObjectLiteral(schema) ? schema : emplacer(schema),
         };
       }
 
       const text = entries.find((e) => e[0].includes("text/plain"));
-      if (text) return { type: "text/plain", schema: { type: "string" } };
+      if (text)
+        return { type: "text/plain", key: "body", schema: { type: "string" } };
       return false;
     };
 
@@ -314,206 +316,6 @@ export namespace RouteProgrammer {
       swagger.components.schemas[name] = schema;
       return { $ref: `#/components/schemas/${name}` };
     };
-
-  /* -----------------------------------------------------------
-    WRITERS
-  ----------------------------------------------------------- */
-  export const write =
-    (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
-    (route: IMigrateRoute): ts.MethodDeclaration => {
-      const output: ts.TypeNode = route.success
-        ? SchemaProgrammer.write(importer)(components)(route.success.schema)
-        : TypeFactory.keyword("void");
-
-      const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
-        [
-          ...writeMethodDecorators(components)(importer)(route),
-          ts.factory.createToken(ts.SyntaxKind.PublicKeyword),
-          ts.factory.createToken(ts.SyntaxKind.AsyncKeyword),
-        ],
-        undefined,
-        route.name,
-        undefined,
-        undefined,
-        writeParameters(importer)(components)(route),
-        ts.factory.createTypeReferenceNode("Promise", [output]),
-        ts.factory.createBlock(
-          [
-            ...[
-              ...route.parameters.map((p) => StringUtil.normalize(p.key)),
-              ...(route.headers ? ["headers"] : []),
-              ...(route.query ? ["query"] : []),
-              ...(route.body ? ["body"] : []),
-            ].map((str) =>
-              ts.factory.createExpressionStatement(
-                ts.factory.createIdentifier(str),
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                  importer.external({
-                    library: "typia",
-                    instance: "random",
-                  }),
-                ),
-                [output],
-                undefined,
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-      return FilePrinter.description(method, route.description ?? "");
-    };
-
-  const writeMethodDecorators =
-    (components: ISwaggerComponents) =>
-    (importer: ImportProgrammer) =>
-    (route: IMigrateRoute): ts.Decorator[] => {
-      const external =
-        (lib: string) =>
-        (instance: string): ts.Identifier =>
-          ts.factory.createIdentifier(
-            importer.external({ library: lib, instance }),
-          );
-      const router = (instance: string) =>
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(external("@nestia/core")(instance))(
-              StringUtil.capitalize(route.method),
-            ),
-            [],
-            [ts.factory.createStringLiteral(route.path)],
-          ),
-        );
-
-      const decorators: ts.Decorator[] = [];
-      if (route.success?.["x-nestia-encrypted"])
-        decorators.push(router("EncryptedRoute"));
-      else if (route.success?.type === "text/plain")
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestjs/common")(StringUtil.capitalize(route.method)),
-              [],
-              [ts.factory.createStringLiteral(route.path)],
-            ),
-          ),
-        );
-      else if (route.success?.type === "application/x-www-form-urlencoded")
-        decorators.push(router("TypedQuery"));
-      else if (route.success?.type === "application/json")
-        decorators.push(router("TypedRoute"));
-      else if (route.method === "head")
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestjs/common")("Head"),
-              [],
-              [ts.factory.createStringLiteral(route.path)],
-            ),
-          ),
-        );
-      for (const [key, value] of Object.entries(route.exceptions ?? {}))
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestia/core")("TypedException"),
-              [SchemaProgrammer.write(importer)(components)(value.schema)],
-              [
-                isNaN(Number(key))
-                  ? ts.factory.createStringLiteral(key)
-                  : ExpressionFactory.number(Number(key)),
-                ...(value.description?.length
-                  ? [ts.factory.createStringLiteral(value.description)]
-                  : []),
-              ],
-            ),
-          ),
-        );
-      return decorators;
-    };
-
-  const writeParameters =
-    (importer: ImportProgrammer) =>
-    (components: ISwaggerComponents) =>
-    (route: IMigrateRoute): ts.ParameterDeclaration[] => [
-      ...route.parameters.map(({ key, schema: value }) =>
-        ts.factory.createParameterDeclaration(
-          [
-            ts.factory.createDecorator(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                  importer.external({
-                    library: "@nestia/core",
-                    instance: "TypedParam",
-                  }),
-                ),
-                undefined,
-                [ts.factory.createStringLiteral(key)],
-              ),
-            ),
-          ],
-          undefined,
-          StringUtil.normalize(key),
-          undefined,
-          SchemaProgrammer.write(importer)(components)(value),
-        ),
-      ),
-      ...(route.headers
-        ? [
-            writeDtoParameter({ method: "TypedHeaders", variable: "headers" })(
-              importer,
-            )(components)(route.headers),
-          ]
-        : []),
-      ...(route.query
-        ? [
-            writeDtoParameter({ method: "TypedQuery", variable: "query" })(
-              importer,
-            )(components)(route.query),
-          ]
-        : []),
-      ...(route.body
-        ? [
-            writeDtoParameter({
-              method: route.body?.["x-nestia-encrypted"]
-                ? "EncryptedBody"
-                : "TypedBody",
-              variable: "body",
-            })(importer)(components)(route.body.schema),
-          ]
-        : []),
-    ];
-
-  const writeDtoParameter =
-    (accessor: { method: string; variable: string }) =>
-    (importer: ImportProgrammer) =>
-    (components: ISwaggerComponents) =>
-    (schema: ISwaggerSchema): ts.ParameterDeclaration =>
-      ts.factory.createParameterDeclaration(
-        [
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                importer.external({
-                  library: "@nestia/core",
-                  instance: accessor.method,
-                }),
-              ),
-              undefined,
-              undefined,
-            ),
-          ),
-        ],
-        undefined,
-        StringUtil.normalize(accessor.variable),
-        undefined,
-        SchemaProgrammer.write(importer)(components)(schema),
-      );
 }
 
 const SUPPORTED_METHODS: Set<string> = new Set([

package/src/analyzers/MigrateAnalyzer.ts

@@ -0,0 +1,9 @@
+import { IMigrateProgram, ISwagger } from "../module";
+import { ControllerAnalyzer } from "./ControllerAnalyzer";
+
+export namespace MigrateAnalyzer {
+  export const analyze = (swagger: ISwagger): IMigrateProgram => ({
+    swagger,
+    controllers: ControllerAnalyzer.analyze(swagger),
+  });
+}

package/src/archivers/FileArchiver.ts

@@ -2,18 +2,21 @@ import { IMigrateFile } from "../structures/IMigrateFile";
 
 export namespace FileArchiver {
   export interface IOperator {
-    mkdir(path: string): void;
-    writeFile(path: string, content: string): void;
+    mkdir(path: string): Promise<void>;
+    writeFile(path: string, content: string): Promise<void>;
   }
 
   export const archive =
     (operator: IOperator) =>
     (output: string) =>
-    (files: IMigrateFile[]): void => {
+    async (files: IMigrateFile[]): Promise<void> => {
       const visited: Set<string> = new Set();
       for (const f of files) {
-        mkdir(operator.mkdir)(output)(visited)(f.location);
-        operator.writeFile([output, f.location, f.file].join("/"), f.content);
+        await mkdir(operator.mkdir)(output)(visited)(f.location);
+        await operator.writeFile(
+          [output, f.location, f.file].join("/"),
+          f.content,
+        );
       }
     };
 
@@ -21,14 +24,14 @@ export namespace FileArchiver {
     (creator: (path: string) => void) =>
     (output: string) =>
     (visited: Set<string>) =>
-    (path: string): void => {
+    async (path: string): Promise<void> => {
       const sequence: string[] = path
         .split("/")
         .map((_str, i, entire) => entire.slice(0, i + 1).join("/"));
       for (const s of sequence)
         if (visited.has(s) === false)
           try {
-            creator([output, s].join("/"));
+            await creator([output, s].join("/"));
             visited.add(s);
           } catch {}
     };

package/src/executable/migrate.ts

@@ -2,7 +2,7 @@
 import fs from "fs";
 import path from "path";
 
-import { NestiaMigrateApplication } from "../NestiaMigrateApplication";
+import { MigrateApplication } from "../MigrateApplication";
 import { ISwagger } from "../structures/ISwagger";
 import { SetupWizard } from "../utils/SetupWizard";
 
@@ -18,7 +18,7 @@ function halt(desc: string): never {
   process.exit(-1);
 }
 
-const main = (argv: string[]) => {
+const main = async (argv: string[]): Promise<void> => {
   const resolve = (str: string | undefined) =>
     str ? path.resolve(str).split("\\").join("/") : undefined;
   const input: string | undefined = resolve(argv[0]);
@@ -47,13 +47,13 @@ const main = (argv: string[]) => {
   })();
 
   // DO GENERATE
-  const app = new NestiaMigrateApplication(swagger);
-  app.generate({
-    mkdir: fs.mkdirSync,
-    writeFile: (path, content) => fs.writeFileSync(path, content, "utf8"),
-  })(output);
+  const app: MigrateApplication = new MigrateApplication(swagger);
+  await app.generate(output);
 
   // RUN SCRIPTS
   SetupWizard.setup(output);
 };
-main(process.argv.slice(2));
+main(process.argv.slice(2)).catch((exp) => {
+  console.error(exp);
+  process.exit(-1);
+});