@nestia/migrate 0.13.16 → 0.14.0

package/src/programmers/MigrateApiFunctionProgrammer.ts

@@ -2,7 +2,6 @@ import { OpenApi } from "@samchon/openapi";
 import ts from "typescript";
 import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
 
-import { IMigrateController } from "../structures/IMigrateController";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { FilePrinter } from "../utils/FilePrinter";
@@ -10,17 +9,11 @@ import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
 import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
 
 export namespace MigrateApiFunctionProgrammer {
-  export interface IProps {
-    controller: IMigrateController;
-    route: IMigrateRoute;
-    alias: string;
-  }
-
   export const write =
     (config: IMigrateProgram.IConfig) =>
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.FunctionDeclaration =>
+    (route: IMigrateRoute): ts.FunctionDeclaration =>
       FilePrinter.description(
         ts.factory.createFunctionDeclaration(
           [
@@ -28,23 +21,25 @@ export namespace MigrateApiFunctionProgrammer {
             ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
           ],
           undefined,
-          props.alias,
+          route.accessor.at(-1)!,
           undefined,
-          writeParameterDeclarations(components)(importer)(props),
+          writeParameterDeclarations(components)(importer)(route),
           ts.factory.createTypeReferenceNode("Promise", [
             ts.factory.createTypeReferenceNode(
-              props.route.success === null ? "void" : `${props.alias}.Output`,
+              route.success === null
+                ? "void"
+                : `${route.accessor.at(-1)!}.Output`,
             ),
           ]),
-          ts.factory.createBlock(writeBody(config)(importer)(props), true),
+          ts.factory.createBlock(writeBody(config)(importer)(route), true),
         ),
-        writeDescription(props),
+        writeDescription(route),
       );
 
   export const writeParameterDeclarations =
     (components: OpenApi.IComponents) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.ParameterDeclaration[] => [
+    (route: IMigrateRoute): ts.ParameterDeclaration[] => [
       IdentifierFactory.parameter(
         "connection",
         ts.factory.createTypeReferenceNode(
@@ -53,49 +48,56 @@ export namespace MigrateApiFunctionProgrammer {
             library: "@nestia/fetcher",
             name: "IConnection",
           }),
-          props.route.headers
-            ? [ts.factory.createTypeReferenceNode(`${props.alias}.Headers`)]
+          route.headers
+            ? [
+                ts.factory.createTypeReferenceNode(
+                  `${route.accessor.at(-1)!}.Headers`,
+                ),
+              ]
             : undefined,
         ),
       ),
-      ...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,
-              ts.factory.createTypeReferenceNode(`${props.alias}.Query`),
+              route.query.key,
+              ts.factory.createTypeReferenceNode(
+                `${route.accessor.at(-1)!}.Query`,
+              ),
             ),
           ]
         : []),
-      ...(props.route.body
+      ...(route.body
         ? [
             IdentifierFactory.parameter(
-              props.route.body.key,
-              ts.factory.createTypeReferenceNode(`${props.alias}.Input`),
+              route.body.key,
+              ts.factory.createTypeReferenceNode(
+                `${route.accessor.at(-1)!}.Input`,
+              ),
             ),
           ]
         : []),
     ];
 
-  const writeDescription = (props: IProps): string =>
+  const writeDescription = (route: IMigrateRoute): string =>
     [
-      props.route.comment(),
-      `@controller ${props.controller.name}`,
-      `@path ${props.route.path}`,
+      route.comment(),
+      `@path ${route.emendedPath}`,
       "@nestia Generated by Nestia - https://github.com/samchon/nestia",
     ].join("\n");
 
   const writeBody =
     (config: IMigrateProgram.IConfig) =>
     (importer: MigrateImportProgrammer) =>
-    (props: IProps): ts.Statement[] => {
-      const encrypted: boolean = !!props.route.success?.["x-nestia-encrypted"];
-      const contentType: string = props.route.body?.type ?? "application/json";
+    (route: IMigrateRoute): ts.Statement[] => {
+      const encrypted: boolean = !!route.success?.["x-nestia-encrypted"];
+      const contentType: string = route.body?.type ?? "application/json";
 
       const caller = () =>
         ts.factory.createCallExpression(
@@ -141,22 +143,22 @@ export namespace MigrateApiFunctionProgrammer {
               [
                 ts.factory.createSpreadAssignment(
                   IdentifierFactory.access(
-                    ts.factory.createIdentifier(props.alias),
+                    ts.factory.createIdentifier(route.accessor.at(-1)!),
                   )("METADATA"),
                 ),
                 ts.factory.createPropertyAssignment(
                   "path",
                   ts.factory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createIdentifier(props.alias),
+                      ts.factory.createIdentifier(route.accessor.at(-1)!),
                     )("path"),
                     undefined,
                     [
-                      ...props.route.parameters.map((p) =>
+                      ...route.parameters.map((p) =>
                         ts.factory.createIdentifier(p.key),
                       ),
-                      ...(props.route.query
-                        ? [ts.factory.createIdentifier(props.route.query.key)]
+                      ...(route.query
+                        ? [ts.factory.createIdentifier(route.query.key)]
                         : []),
                     ],
                   ),
@@ -168,8 +170,8 @@ export namespace MigrateApiFunctionProgrammer {
               ],
               true,
             ),
-            ...(props.route.body
-              ? [ts.factory.createIdentifier(props.route.body.key)]
+            ...(route.body
+              ? [ts.factory.createIdentifier(route.body.key)]
               : []),
           ],
         );
@@ -181,13 +183,13 @@ export namespace MigrateApiFunctionProgrammer {
             ts.factory.createIdentifier("!!connection.simulate"),
             undefined,
             ts.factory.createCallExpression(
-              ts.factory.createIdentifier(`${props.alias}.simulate`),
+              ts.factory.createIdentifier(`${route.accessor.at(-1)!}.simulate`),
               [],
               [
                 "connection",
-                ...props.route.parameters.map((p) => p.key),
-                ...(props.route.query ? [props.route.query.key] : []),
-                ...(props.route.body ? [props.route.body.key] : []),
+                ...route.parameters.map((p) => p.key),
+                ...(route.query ? [route.query.key] : []),
+                ...(route.body ? [route.body.key] : []),
               ].map((key) => ts.factory.createIdentifier(key)),
             ),
             undefined,

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}`,