@nestia/migrate 0.13.17 → 0.14.1

package/src/programmers/MigrateApiNamespaceProgrammer.ts

@@ -5,7 +5,6 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -14,34 +13,28 @@ import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
 export namespace MigrateApiNamespaceProgrammer {
-  export interface IProps {
-    controller: IMigrateController;
-    route: IMigrateRoute;
-    alias: string;
-  }
-
   export const write =
     (config: IMigrateProgram.IConfig) =>
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.ModuleDeclaration => {
-      const types = writeTypes(components)(importer)(props.route);
+    (route: IMigrateRoute): ts.ModuleDeclaration => {
+      const types = writeTypes(components)(importer)(route);
       return ts.factory.createModuleDeclaration(
         [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-        ts.factory.createIdentifier(props.alias),
+        ts.factory.createIdentifier(route.accessor.at(-1)!),
         ts.factory.createModuleBlock([
           ...types,
           ...(types.length ? [FilePrinter.newLine()] : []),
-          writeMetadata(components)(importer)(props),
+          writeMetadata(components)(importer)(route),
           FilePrinter.newLine(),
-          writePath(components)(importer)(props),
+          writePath(components)(importer)(route),
           ...(config.simulate
             ? [
                 MigrateApiSimulatationProgrammer.random(components)(importer)(
-                  props,
+                  route,
                 ),
                 MigrateApiSimulatationProgrammer.simulate(components)(importer)(
-                  props,
+                  route,
                 ),
               ]
             : []),
@@ -50,17 +43,13 @@ export namespace MigrateApiNamespaceProgrammer {
       );
     };
 
-  export const writePathCallExpression = (props: IProps) =>
+  export const writePathCallExpression = (route: IMigrateRoute) =>
     ts.factory.createCallExpression(
-      ts.factory.createIdentifier(`${props.alias}.path`),
+      ts.factory.createIdentifier(`${route.accessor.at(-1)!}.path`),
       undefined,
       [
-        ...props.route.parameters.map((p) =>
-          ts.factory.createIdentifier(p.key),
-        ),
-        ...(props.route.query
-          ? [ts.factory.createIdentifier(props.route.query.key)]
-          : []),
+        ...route.parameters.map((p) => ts.factory.createIdentifier(p.key)),
+        ...(route.query ? [ts.factory.createIdentifier(route.query.key)] : []),
       ],
     );
 
@@ -112,41 +101,38 @@ export namespace MigrateApiNamespaceProgrammer {
   const writeMetadata =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.VariableStatement =>
+    (route: IMigrateRoute): ts.VariableStatement =>
       constant("METADATA")(
         ts.factory.createAsExpression(
           ts.factory.createObjectLiteralExpression(
             [
               ts.factory.createPropertyAssignment(
                 "method",
-                ts.factory.createStringLiteral(
-                  props.route.method.toUpperCase(),
-                ),
+                ts.factory.createStringLiteral(route.method.toUpperCase()),
               ),
               ts.factory.createPropertyAssignment(
                 "path",
-                ts.factory.createStringLiteral(getPath(props)),
+                ts.factory.createStringLiteral(getPath(route)),
               ),
               ts.factory.createPropertyAssignment(
                 "request",
-                props.route.body
+                route.body
                   ? LiteralFactory.generate({
-                      type: props.route.body.type,
-                      encrypted: !!props.route.body["x-nestia-encrypted"],
+                      type: route.body.type,
+                      encrypted: !!route.body["x-nestia-encrypted"],
                     })
                   : ts.factory.createNull(),
               ),
               ts.factory.createPropertyAssignment(
                 "response",
-                props.route.method.toUpperCase() !== "HEAD"
+                route.method.toUpperCase() !== "HEAD"
                   ? LiteralFactory.generate({
-                      type: props.route.success?.type ?? "application/json",
-                      encrypted: !!props.route.success?.["x-nestia-encrypted"],
+                      type: route.success?.type ?? "application/json",
+                      encrypted: !!route.success?.["x-nestia-encrypted"],
                     })
                   : ts.factory.createNull(),
               ),
-              ...(props.route.success?.type ===
-              "application/x-www-form-urlencoded"
+              ...(route.success?.type === "application/x-www-form-urlencoded"
                 ? [
                     ts.factory.createPropertyAssignment(
                       "parseQuery",
@@ -160,7 +146,7 @@ export namespace MigrateApiNamespaceProgrammer {
                         ),
                         [
                           MigrateSchemaProgrammer.write(components)(importer)(
-                            props.route.success.schema,
+                            route.success.schema,
                           ),
                         ],
                         undefined,
@@ -180,25 +166,25 @@ export namespace MigrateApiNamespaceProgrammer {
   const writePath =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.VariableStatement => {
+    (route: IMigrateRoute): ts.VariableStatement => {
       const out = (body: ts.ConciseBody) =>
         constant("path")(
           ts.factory.createArrowFunction(
             [],
             [],
             [
-              ...props.route.parameters.map((p) =>
+              ...route.parameters.map((p) =>
                 IdentifierFactory.parameter(
                   p.key,
                   MigrateSchemaProgrammer.write(components)(importer)(p.schema),
                 ),
               ),
-              ...(props.route.query
+              ...(route.query
                 ? [
                     IdentifierFactory.parameter(
-                      props.route.query.key,
+                      route.query.key,
                       ts.factory.createTypeReferenceNode(
-                        `${props.alias}.Query`,
+                        `${route.accessor.at(-1)!}.Query`,
                       ),
                     ),
                   ]
@@ -210,7 +196,7 @@ export namespace MigrateApiNamespaceProgrammer {
           ),
         );
       const template = () => {
-        const path: string = getPath(props);
+        const path: string = getPath(route);
         const splitted: string[] = path.split(":");
         if (splitted.length === 1) return ts.factory.createStringLiteral(path);
         return ts.factory.createTemplateExpression(
@@ -224,7 +210,7 @@ export namespace MigrateApiNamespaceProgrammer {
                 [
                   ts.factory.createBinaryExpression(
                     ts.factory.createIdentifier(
-                      props.route.parameters.find((p) => p.name === name)!.key,
+                      route.parameters.find((p) => p.name === name)!.key,
                     ),
                     ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
                     ts.factory.createStringLiteral("null"),
@@ -238,10 +224,10 @@ export namespace MigrateApiNamespaceProgrammer {
           }),
         );
       };
-      if (!props.route.query) return out(template());
+      if (!route.query) return out(template());
 
       const computeName = (str: string): string =>
-        props.route.parameters.find((p) => p.key === str) !== undefined
+        route.parameters.find((p) => p.key === str) !== undefined
           ? computeName("_" + str)
           : str;
       const variables: string = computeName("variables");
@@ -286,7 +272,7 @@ export namespace MigrateApiNamespaceProgrammer {
                 undefined,
                 [
                   ts.factory.createAsExpression(
-                    ts.factory.createIdentifier(props.route.query.key),
+                    ts.factory.createIdentifier(route.query.key),
                     TypeFactory.keyword("any"),
                   ),
                 ],
@@ -409,11 +395,7 @@ const constant = (name: string) => (expression: ts.Expression) =>
       ts.NodeFlags.Const,
     ),
   );
-const getPath = (props: MigrateApiNamespaceProgrammer.IProps) =>
-  "/" +
-  [...props.controller.path.split("/"), ...props.route.path.split("/")]
-    .filter((str) => !!str.length)
-    .join("/");
+const getPath = (route: IMigrateRoute) => "/" + route.emendedPath;
 const local = (name: string) => (type: string) => (expression: ts.Expression) =>
   ts.factory.createVariableStatement(
     [],

package/src/programmers/MigrateApiProgrammer.ts

@@ -1,56 +1,42 @@
-import { HashMap, IPointer, hash } from "tstl";
+import { HashMap, hash } from "tstl";
 import ts from "typescript";
-import { Escaper } from "typia/lib/utils/Escaper";
 
-import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
-import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { FilePrinter } from "../utils/FilePrinter";
-import { StringUtil } from "../utils/StringUtil";
 import { MigrateApiFileProgrammer } from "./MigrateApiFileProgrammer";
 import { MigrateDtoProgrammer } from "./MigrateDtoProgrammer";
 import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
 export namespace MigrateApiProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] => {
-    // GROUP BY NAMESPACES
-    const dict: HashMap<string[], MigrateApiFileProgrammer.IProps> = collect(
-      ({ controller, route }) =>
-        [...controller.path.split("/"), ...route.path.split("/")]
-          .filter((str) => !!str.length && str[0] !== ":")
-          .map(StringUtil.normalize)
-          .map((str) => (Escaper.variable(str) ? str : `_${str}`)),
-    )(program);
-
-    // EMEND NAMES
-    for (const { second: props } of dict)
-      props.entries.forEach((entry, i) => {
-        entry.alias = StringUtil.escapeDuplicate([
-          ...props.children,
-          ...props.entries.filter((_, j) => i !== j).map((e) => e.alias),
-        ])(entry.alias);
-        entry.route.accessor = [...props.namespace, entry.alias];
-
-        const parameters: { name: string; key: string }[] = [
-          ...entry.route.parameters,
-          ...(entry.route.body ? [entry.route.body] : []),
-          ...(entry.route.headers ? [entry.route.headers] : []),
-          ...(entry.route.query ? [entry.route.query] : []),
-        ];
-        parameters.forEach(
-          (p, i) =>
-            (p.key = StringUtil.escapeDuplicate([
-              "connection",
-              entry.alias,
-              ...parameters.filter((_, j) => i !== j).map((y) => y.key),
-            ])(p.key)),
+    const dict: HashMap<string[], MigrateApiFileProgrammer.IProps> =
+      new HashMap(
+        (x) => hash(x.join(".")),
+        (x, y) => x.length === y.length && x.join(".") === y.join("."),
+      );
+    for (const route of program.routes) {
+      const namespace: string[] = route.accessor.slice(0, -1);
+      let last: MigrateApiFileProgrammer.IProps = dict.take(namespace, () => ({
+        namespace,
+        routes: [],
+        children: new Set(),
+      }));
+      last.routes.push(route);
+      namespace.forEach((_s, i, array) => {
+        const partial: string[] = namespace.slice(0, array.length - i - 1);
+        const props: MigrateApiFileProgrammer.IProps = dict.take(
+          partial,
+          () => ({
+            namespace: partial,
+            children: new Set(),
+            routes: [],
+          }),
         );
+        props.children.add(last.namespace.at(-1)!);
+        last = props;
       });
-
-    // // GROUP BY NAMESPACES AGAIN
-    // const refined: HashMap<string[], MigrateApiFileProgrammer.IProps> =
-    //   collect(({ route }) => route.accessor.slice(0, -1))(program);
+    }
 
     // DO GENERATE
     const output: IMigrateFile[] = [...dict].map(({ second: props }) => ({
@@ -114,59 +100,4 @@ export namespace MigrateApiProgrammer {
       }
       return output;
     };
-
-  const collect =
-    (
-      getter: (props: {
-        controller: IMigrateController;
-        route: IMigrateRoute;
-      }) => string[],
-    ) =>
-    (
-      program: IMigrateProgram,
-    ): HashMap<string[], MigrateApiFileProgrammer.IProps> => {
-      const dict: HashMap<string[], MigrateApiFileProgrammer.IProps> =
-        new HashMap(Functional.hashCode, Functional.equals);
-      for (const controller of program.controllers)
-        for (const route of controller.routes) {
-          const namespace: string[] = getter({ controller, route });
-          const last: IPointer<MigrateApiFileProgrammer.IProps> = {
-            value: dict.take(namespace, () => ({
-              namespace,
-              children: new Set(),
-              entries: [],
-            })),
-          };
-          last.value.entries.push({
-            controller,
-            route,
-            alias: route.name,
-          });
-          namespace.slice(0, -1).forEach((_i, i, array) => {
-            const partial: string[] = namespace.slice(0, array.length - i);
-            const props: MigrateApiFileProgrammer.IProps = dict.take(
-              partial,
-              () => ({
-                namespace: partial,
-                children: new Set(),
-                entries: [],
-              }),
-            );
-            props.children.add(last.value.namespace.at(-1)!);
-            last.value = props;
-          });
-          const top = dict.take([], () => ({
-            namespace: [],
-            children: new Set(),
-            entries: [],
-          }));
-          if (namespace.length) top.children.add(namespace[0]);
-        }
-      return dict;
-    };
 }
-
-const Functional = {
-  hashCode: (x: string[]) => hash(x.join(".")),
-  equals: (a: string[], b: string[]) => a.join(".") === b.join("."),
-};

package/src/programmers/MigrateApiSimulatationProgrammer.ts

@@ -4,7 +4,6 @@ import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 import { StatementFactory } from "typia/lib/factories/StatementFactory";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { MigrateApiFunctionProgrammer } from "./MigrateApiFunctionProgrammer";
 import { MigrateApiNamespaceProgrammer } from "./MigrateApiNamespaceProgrammer";
@@ -12,18 +11,13 @@ import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
 export namespace MigrateApiSimulatationProgrammer {
-  export interface IProps {
-    controller: IMigrateController;
-    route: IMigrateRoute;
-    alias: string;
-  }
   export const random =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps) => {
-      const output = props.route.success
+    (route: IMigrateRoute) => {
+      const output = route.success
         ? MigrateSchemaProgrammer.write(components)(importer)(
-            props.route.success.schema,
+            route.success.schema,
           )
         : TypeFactory.keyword("void");
       return constant("random")(
@@ -72,7 +66,7 @@ export namespace MigrateApiSimulatationProgrammer {
   export const simulate =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.VariableStatement => {
+    (route: IMigrateRoute): ts.VariableStatement => {
       const caller = () =>
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("random"),
@@ -104,14 +98,12 @@ export namespace MigrateApiSimulatationProgrammer {
           undefined,
           MigrateApiFunctionProgrammer.writeParameterDeclarations(components)(
             importer,
-          )(props),
-          ts.factory.createTypeReferenceNode(
-            props.route.success ? "Output" : "void",
-          ),
+          )(route),
+          ts.factory.createTypeReferenceNode(route.success ? "Output" : "void"),
           undefined,
           ts.factory.createBlock(
             [
-              ...assert(components)(importer)(props),
+              ...assert(components)(importer)(route),
               ts.factory.createReturnStatement(caller()),
             ],
             true,
@@ -123,31 +115,31 @@ export namespace MigrateApiSimulatationProgrammer {
   const assert =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.Statement[] => {
+    (route: IMigrateRoute): ts.Statement[] => {
       const parameters = [
-        ...props.route.parameters.map((p) => ({
+        ...route.parameters.map((p) => ({
           category: "param",
           name: p.key,
           schema: MigrateSchemaProgrammer.write(components)(importer)(p.schema),
         })),
-        ...(props.route.query
+        ...(route.query
           ? [
               {
                 category: "query",
-                name: props.route.query.key,
+                name: route.query.key,
                 schema: MigrateSchemaProgrammer.write(components)(importer)(
-                  props.route.query.schema,
+                  route.query.schema,
                 ),
               },
             ]
           : []),
-        ...(props.route.body
+        ...(route.body
           ? [
               {
                 category: "body",
-                name: props.route.body.key,
+                name: route.body.key,
                 schema: MigrateSchemaProgrammer.write(components)(importer)(
-                  props.route.body.schema,
+                  route.body.schema,
                 ),
               },
             ]
@@ -181,12 +173,12 @@ export namespace MigrateApiSimulatationProgrammer {
                 ),
                 ts.factory.createPropertyAssignment(
                   "path",
-                  MigrateApiNamespaceProgrammer.writePathCallExpression(props),
+                  MigrateApiNamespaceProgrammer.writePathCallExpression(route),
                 ),
                 ts.factory.createPropertyAssignment(
                   "contentType",
                   ts.factory.createStringLiteral(
-                    props.route.success?.type ?? "application/json",
+                    route.success?.type ?? "application/json",
                   ),
                 ),
               ],

package/src/programmers/MigrateApiStartProgrammer.ts

@@ -15,7 +15,7 @@ export namespace MigrateApiStartProgrammer {
     const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
     const main: ts.VariableStatement = writeMain(program)(program.document)(
       importer,
-    )(pick(program.controllers.map((c) => c.routes).flat()));
+    )(pick(program.routes));
     const statements: ts.Statement[] = [
       ...importer.toStatements(
         (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,

package/src/programmers/MigrateE2eProgrammer.ts

@@ -10,9 +10,7 @@ import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 
 export namespace MigrateE2eProgrammer {
   export const write = (program: IMigrateProgram): IMigrateFile[] =>
-    program.controllers
-      .map((c) => c.routes.map(writeFile(program.document.components)))
-      .flat();
+    program.routes.map(writeFile(program.document.components));
 
   const writeFile =
     (components: OpenApi.IComponents) =>

package/src/programmers/MigrateNestMethodProgrammer.ts

@@ -28,7 +28,7 @@ export namespace MigrateNestMethodProgrammer {
           ts.factory.createToken(ts.SyntaxKind.AsyncKeyword),
         ],
         undefined,
-        route.name,
+        route.accessor.at(-1)!,
         undefined,
         undefined,
         writeParameters(components)(importer)(route),
@@ -36,7 +36,7 @@ export namespace MigrateNestMethodProgrammer {
         ts.factory.createBlock(
           [
             ...[
-              ...route.parameters.map((p) => StringUtil.normalize(p.key)),
+              ...route.parameters.map((p) => p.key),
               ...(route.headers ? ["headers"] : []),
               ...(route.query ? ["query"] : []),
               ...(route.body ? ["body"] : []),
@@ -174,7 +174,7 @@ export namespace MigrateNestMethodProgrammer {
             ),
           ],
           undefined,
-          StringUtil.normalize(key),
+          key,
           undefined,
           MigrateSchemaProgrammer.write(components)(importer)(value),
         ),
@@ -241,7 +241,7 @@ export namespace MigrateNestMethodProgrammer {
           ),
         ],
         undefined,
-        StringUtil.normalize(accessor.variable),
+        accessor.variable,
         undefined,
         MigrateSchemaProgrammer.write(components)(importer)(schema),
       );

package/src/programmers/MigrateNestProgrammer.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { MigrateControllerAnalyzer } from "../analyzers/MigrateControllerAnalyzer";
+import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -9,14 +11,17 @@ import { MigrateNestControllerProgrammer } from "./MigrateNestControllerProgramm
 import { MigrateNestModuleProgrammer } from "./MigrateNestModuleProgrammer";
 
 export namespace MigrateNestProgrammer {
-  export const write = (program: IMigrateProgram): IMigrateFile[] =>
-    [
+  export const write = (program: IMigrateProgram): IMigrateFile[] => {
+    const controllers: IMigrateController[] = MigrateControllerAnalyzer.analyze(
+      program.routes,
+    );
+    return [
       {
         location: "src",
         file: "MyModule.ts",
-        statements: MigrateNestModuleProgrammer.write(program.controllers),
+        statements: MigrateNestModuleProgrammer.write(controllers),
       },
-      ...program.controllers.map((c) => ({
+      ...controllers.map((c) => ({
         location: c.location,
         file: `${c.name}.ts`,
         statements: MigrateNestControllerProgrammer.write(
@@ -35,6 +40,7 @@ export namespace MigrateNestProgrammer {
       file: o.file,
       content: FilePrinter.write({ statements: o.statements }),
     }));
+  };
 
   const writeDtoFile = (
     key: string,

package/src/structures/IMigrateProgram.ts

@@ -1,27 +1,27 @@
 import { OpenApi } from "@samchon/openapi";
 
-import { IMigrateController } from "./IMigrateController";
 import { IMigrateRoute } from "./IMigrateRoute";
 
 export interface IMigrateProgram extends IMigrateProgram.IProps {
-  controllers: IMigrateController[];
+  routes: IMigrateRoute[];
+  errors: IMigrateProgram.IError[];
 }
 export namespace IMigrateProgram {
-  export type Dictionary = Map<OpenApi.IOperation, IEntry>;
-  export interface IEntry {
-    controller: IMigrateController;
-    route: IMigrateRoute;
-  }
   export interface IProps {
     mode: "nest" | "sdk";
     simulate: boolean;
     e2e: boolean;
     document: OpenApi.IDocument;
-    dictionary: Dictionary;
   }
   export interface IConfig {
     mode: "nest" | "sdk";
     simulate: boolean;
     e2e: boolean;
   }
+  export interface IError {
+    method: string;
+    path: string;
+    operation: () => OpenApi.IOperation;
+    messages: string[];
+  }
 }

package/src/structures/IMigrateRoute.ts

@@ -1,51 +1 @@
-import { OpenApi } from "@samchon/openapi";
-
-export interface IMigrateRoute {
-  name: string;
-  originalPath: string;
-  path: string;
-  method: string;
-  accessor: string[];
-  parameters: IMigrateRoute.IParameter[];
-  headers: IMigrateRoute.IHeaders | null;
-  query: IMigrateRoute.IQuery | null;
-  body: IMigrateRoute.IBody | null;
-  success: IMigrateRoute.IBody | null;
-  exceptions: Record<string, IMigrateRoute.IException>;
-  comment: () => string;
-  tags: string[];
-  deprecated: boolean;
-}
-export namespace IMigrateRoute {
-  export interface IParameter {
-    name: string;
-    key: string;
-    schema: OpenApi.IJsonSchema;
-    description?: string;
-  }
-  export interface IHeaders {
-    name: string;
-    key: string;
-    schema: OpenApi.IJsonSchema;
-  }
-  export interface IQuery {
-    name: string;
-    key: string;
-    schema: OpenApi.IJsonSchema;
-  }
-  export interface IBody {
-    name: string;
-    key: string;
-    type:
-      | "text/plain"
-      | "application/json"
-      | "application/x-www-form-urlencoded"
-      | "multipart/form-data";
-    schema: OpenApi.IJsonSchema;
-    "x-nestia-encrypted"?: boolean;
-  }
-  export interface IException {
-    description?: string;
-    schema: OpenApi.IJsonSchema;
-  }
-}
+export { IMigrateRoute } from "@samchon/openapi";