@nestia/migrate 0.5.0 → 0.6.0

package/src/programmers/RouteProgrammer.ts

@@ -1,3 +1,7 @@
+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 { IMigrateRoute } from "../structures/IMigrateRoute";
@@ -5,502 +9,518 @@ import { ISwaggerSchema } from "../structures/ISwaggeSchema";
 import { ISwagger } from "../structures/ISwagger";
 import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { ISwaggerRoute } from "../structures/ISwaggerRoute";
-import { JsonTypeChecker } from "../utils/JsonTypeChecker";
+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 {
-    export const analyze =
-        (swagger: ISwagger) =>
-        (props: { path: string; method: string }) =>
-        (route: ISwaggerRoute): IMigrateRoute | null => {
-            const body = emplaceBodySchema(emplaceReference(swagger)("body"))(
-                route.requestBody,
-            );
-            const success = emplaceBodySchema(
-                emplaceReference(swagger)("response"),
-            )(route.responses?.["201"] ?? route.responses?.["200"]);
-            if (body === false || success === false) {
-                console.log(
-                    `Failed to migrate ${props.method.toUpperCase()} ${
-                        props.path
-                    }: @nestia/migrate supports only application/json, application/x-www-form-urlencoded or text/plain format yet.`,
-                );
-                return null;
-            } else if (
-                SUPPORTED_METHODS.has(props.method.toUpperCase()) === false
-            ) {
-                console.log(
-                    `Failed to migrate ${props.method.toUpperCase()} ${
-                        props.path
-                    }: @nestia/migrate does not support ${props.method.toUpperCase()} method.`,
-                );
-                return null;
-            }
+  /* -----------------------------------------------------------
+    ANALYZERS
+  ----------------------------------------------------------- */
+  export const analyze =
+    (swagger: ISwagger) =>
+    (props: { path: string; method: string }) =>
+    (route: ISwaggerRoute): IMigrateRoute | null => {
+      const body = emplaceBodySchema(emplaceReference(swagger)("body"))(
+        route.requestBody,
+      );
+      const success = emplaceBodySchema(emplaceReference(swagger)("response"))(
+        route.responses?.["201"] ?? route.responses?.["200"],
+      );
+      if (body === false || success === false) {
+        console.log(
+          `Failed to migrate ${props.method.toUpperCase()} ${
+            props.path
+          }: @nestia/migrate supports only application/json, application/x-www-form-urlencoded or text/plain format yet.`,
+        );
+        return null;
+      } else if (SUPPORTED_METHODS.has(props.method.toUpperCase()) === false) {
+        console.log(
+          `Failed to migrate ${props.method.toUpperCase()} ${
+            props.path
+          }: @nestia/migrate does not support ${props.method.toUpperCase()} method.`,
+        );
+        return null;
+      }
 
-            const [headers, query] = ["header", "query"].map((type) => {
-                const parameters = (route.parameters ?? []).filter(
-                    (p) => p.in === type,
-                );
-                if (parameters.length === 0) return null;
+      const [headers, query] = ["header", "query"].map((type) => {
+        const parameters = (route.parameters ?? []).filter(
+          (p) => p.in === type,
+        );
+        if (parameters.length === 0) return null;
 
-                const objects = parameters
-                    .map((p) =>
-                        JsonTypeChecker.isObject(p.schema)
-                            ? p.schema
-                            : JsonTypeChecker.isReference(p.schema) &&
-                              JsonTypeChecker.isObject(
-                                  (swagger.components.schemas ?? {})[
-                                      p.schema.$ref.replace(
-                                          `#/components/schemas/`,
-                                          ``,
-                                      )
-                                  ] ?? {},
-                              )
-                            ? p.schema
-                            : null!,
-                    )
-                    .filter((s) => !!s);
-                const primitives = parameters.filter(
-                    (p) =>
-                        JsonTypeChecker.isBoolean(p.schema) ||
-                        JsonTypeChecker.isNumber(p.schema) ||
-                        JsonTypeChecker.isInteger(p.schema) ||
-                        JsonTypeChecker.isString(p.schema) ||
-                        JsonTypeChecker.isArray(p.schema),
-                );
-                if (objects.length === 1 && primitives.length === 0)
-                    return objects[0];
-                else if (objects.length > 1)
-                    throw new Error(
-                        `Error on nestia.migrate.RouteProgrammer.analze(): ${type} typed parameters must be only one object type - ${StringUtil.capitalize(
-                            props.method,
-                        )} "${props.path}".`,
-                    );
-
-                const dto: ISwaggerSchema.IObject | null = objects[0]
-                    ? JsonTypeChecker.isObject(objects[0])
-                        ? objects[0]
-                        : ((swagger.components.schemas ?? {})[
-                              (
-                                  objects[0] as ISwaggerSchema.IReference
-                              ).$ref.replace(`#/components/schemas/`, ``)
-                          ] as ISwaggerSchema.IObject)
-                    : null;
-                const entire: ISwaggerSchema.IObject[] = [
-                    ...objects.map((o) =>
-                        JsonTypeChecker.isObject(o)
-                            ? o
-                            : (swagger.components.schemas?.[
-                                  o.$ref.replace(`#/components/schemas/`, ``)
-                              ]! as ISwaggerSchema.IObject),
-                    ),
-                    {
-                        type: "object",
-                        properties: Object.fromEntries([
-                            ...primitives.map((p) => [
-                                p.name,
-                                {
-                                    ...p.schema,
-                                    description:
-                                        p.schema.description ?? p.description,
-                                },
-                            ]),
-                            ...(dto
-                                ? Object.entries(dto.properties ?? {})
-                                : []),
-                        ]),
-                        required: [
-                            ...primitives
-                                .filter((p) => p.required)
-                                .map((p) => p.name!),
-                            ...(dto ? dto.required ?? [] : []),
-                        ],
-                    },
-                ];
-                return parameters.length === 0
-                    ? null
-                    : emplaceReference(swagger)(
-                          StringUtil.pascal(`I/Api/${props.path}`) +
-                              "." +
-                              StringUtil.pascal(`${props.method}/${type}`),
-                      )({
-                          type: "object",
-                          properties: Object.fromEntries([
-                              ...new Map<string, ISwaggerSchema>(
-                                  entire
-                                      .map((o) =>
-                                          Object.entries(
-                                              o.properties ?? {},
-                                          ).map(
-                                              ([name, schema]) =>
-                                                  [
-                                                      name,
-                                                      {
-                                                          ...schema,
-                                                          description:
-                                                              schema.description ??
-                                                              schema.description,
-                                                      } as ISwaggerSchema,
-                                                  ] as const,
-                                          ),
-                                      )
-                                      .flat(),
-                              ),
-                          ]),
-                          required: [
-                              ...new Set(
-                                  entire.map((o) => o.required ?? []).flat(),
-                              ),
-                          ],
-                      });
-            });
-
-            const parameterNames: string[] = StringUtil.splitWithNormalization(
-                props.path,
-            )
-                .filter((str) => str[0] === "{" || str[0] === ":")
-                .map((str) =>
-                    str[0] === "{"
-                        ? str.substring(1, str.length - 1)
-                        : str.substring(1),
-                );
-            if (
-                parameterNames.length !==
-                (route.parameters ?? []).filter((p) => p.in === "path").length
-            ) {
-                console.log(
-                    `Failed to migrate ${props.method.toUpperCase()} ${
-                        props.path
-                    }: number of path parameters are not matched with its full path.`,
-                );
-                return null;
-            }
-            return {
-                name: "@lazy",
-                path: props.path,
-                method: props.method,
-                headers,
-                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;
+        const objects = parameters
+          .map((p) =>
+            SwaggerTypeChecker.isObject(p.schema)
+              ? p.schema
+              : SwaggerTypeChecker.isReference(p.schema) &&
+                  SwaggerTypeChecker.isObject(
+                    (swagger.components.schemas ?? {})[
+                      p.schema.$ref.replace(`#/components/schemas/`, ``)
+                    ] ?? {},
+                  )
+                ? p.schema
+                : null!,
+          )
+          .filter((s) => !!s);
+        const primitives = parameters.filter(
+          (p) =>
+            SwaggerTypeChecker.isBoolean(p.schema) ||
+            SwaggerTypeChecker.isNumber(p.schema) ||
+            SwaggerTypeChecker.isInteger(p.schema) ||
+            SwaggerTypeChecker.isString(p.schema) ||
+            SwaggerTypeChecker.isArray(p.schema),
+        );
+        if (objects.length === 1 && primitives.length === 0) return objects[0];
+        else if (objects.length > 1)
+          throw new Error(
+            `Error on nestia.migrate.RouteProgrammer.analze(): ${type} typed parameters must be only one object type - ${StringUtil.capitalize(
+              props.method,
+            )} "${props.path}".`,
+          );
 
-                            while (true) {
-                                key = "_" + key;
-                                if (!parameterNames.some((s) => s === key))
-                                    return key;
-                            }
-                        })(),
-                        schema: {
-                            ...p.schema,
-                            description: p.schema.description ?? p.description,
-                        },
-                    })),
-                query,
-                body,
-                success,
-                exceptions: Object.fromEntries(
-                    Object.entries(route.responses ?? {})
-                        .filter(
-                            ([key, value]) =>
-                                key !== "200" &&
-                                key !== "201" &&
-                                !!value.content?.["application/json"],
-                        )
-                        .map(([key, value]) => [
-                            key,
+        const dto: ISwaggerSchema.IObject | null = objects[0]
+          ? SwaggerTypeChecker.isObject(objects[0])
+            ? objects[0]
+            : ((swagger.components.schemas ?? {})[
+                (objects[0] as ISwaggerSchema.IReference).$ref.replace(
+                  `#/components/schemas/`,
+                  ``,
+                )
+              ] as ISwaggerSchema.IObject)
+          : null;
+        const entire: ISwaggerSchema.IObject[] = [
+          ...objects.map((o) =>
+            SwaggerTypeChecker.isObject(o)
+              ? o
+              : (swagger.components.schemas?.[
+                  o.$ref.replace(`#/components/schemas/`, ``)
+                ]! as ISwaggerSchema.IObject),
+          ),
+          {
+            type: "object",
+            properties: Object.fromEntries([
+              ...primitives.map((p) => [
+                p.name,
+                {
+                  ...p.schema,
+                  description: p.schema.description ?? p.description,
+                },
+              ]),
+              ...(dto ? Object.entries(dto.properties ?? {}) : []),
+            ]),
+            required: [
+              ...primitives.filter((p) => p.required).map((p) => p.name!),
+              ...(dto ? dto.required ?? [] : []),
+            ],
+          },
+        ];
+        return parameters.length === 0
+          ? null
+          : emplaceReference(swagger)(
+              StringUtil.pascal(`I/Api/${props.path}`) +
+                "." +
+                StringUtil.pascal(`${props.method}/${type}`),
+            )({
+              type: "object",
+              properties: Object.fromEntries([
+                ...new Map<string, ISwaggerSchema>(
+                  entire
+                    .map((o) =>
+                      Object.entries(o.properties ?? {}).map(
+                        ([name, schema]) =>
+                          [
+                            name,
                             {
-                                description: value.description,
-                                schema:
-                                    value.content?.["application/json"]
-                                        ?.schema ?? {},
-                            },
-                        ]),
+                              ...schema,
+                              description:
+                                schema.description ?? schema.description,
+                            } as ISwaggerSchema,
+                          ] as const,
+                      ),
+                    )
+                    .flat(),
                 ),
-                description: describe(route),
-                "x-nestia-jsDocTags": route["x-nestia-jsDocTags"],
-            };
-        };
+              ]),
+              required: [
+                ...new Set(entire.map((o) => o.required ?? []).flat()),
+              ],
+            });
+      });
 
-    const describe = (route: ISwaggerRoute): string | undefined => {
-        const commentTags: string[] = [];
-        const add = (text: string) => {
-            if (commentTags.every((line) => line !== text))
-                commentTags.push(text);
-        };
+      const parameterNames: string[] = StringUtil.splitWithNormalization(
+        props.path,
+      )
+        .filter((str) => str[0] === "{" || str[0] === ":")
+        .map((str) =>
+          str[0] === "{" ? str.substring(1, str.length - 1) : str.substring(1),
+        );
+      if (
+        parameterNames.length !==
+        (route.parameters ?? []).filter((p) => p.in === "path").length
+      ) {
+        console.log(
+          `Failed to migrate ${props.method.toUpperCase()} ${
+            props.path
+          }: number of path parameters are not matched with its full path.`,
+        );
+        return null;
+      }
+      return {
+        name: "@lazy",
+        path: props.path,
+        method: props.method,
+        headers,
+        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;
 
-        let description: string | undefined = route.description;
-        if (route.summary) {
-            const emended: string = route.summary.endsWith(".")
-                ? route.summary
-                : route.summary + ".";
-            if (
-                description !== undefined &&
-                !description?.startsWith(route.summary) &&
-                !route["x-nestia-jsDocTags"]?.some((t) => t.name === "summary")
+              while (true) {
+                key = "_" + key;
+                if (!parameterNames.some((s) => s === key)) return key;
+              }
+            })(),
+            schema: {
+              ...p.schema,
+              description: p.schema.description ?? p.description,
+            },
+          })),
+        query,
+        body,
+        success,
+        exceptions: Object.fromEntries(
+          Object.entries(route.responses ?? {})
+            .filter(
+              ([key, value]) =>
+                key !== "200" &&
+                key !== "201" &&
+                !!value.content?.["application/json"],
             )
-                description = `${emended}\n${description}`;
-        }
-        if (route.tags) route.tags.forEach((name) => add(`@tag ${name}`));
-        if (route.deprecated) add("@deprecated");
-        for (const security of route.security ?? [])
-            for (const [name, scopes] of Object.entries(security))
-                add(`@security ${[name, ...scopes].join("")}`);
-        for (const jsDocTag of route["x-nestia-jsDocTags"] ?? [])
-            if (jsDocTag.text?.length)
-                add(
-                    `@${jsDocTag.name} ${jsDocTag.text
-                        .map((text) => text.text)
-                        .join("")}`,
-                );
-            else add(`@${jsDocTag.name}`);
-        return description?.length
-            ? commentTags.length
-                ? `${description}\n\n${commentTags.join("\n")}`
-                : description
-            : commentTags.join("\n");
+            .map(([key, value]) => [
+              key,
+              {
+                description: value.description,
+                schema: value.content?.["application/json"]?.schema ?? {},
+              },
+            ]),
+        ),
+        description: describe(route),
+        "x-nestia-jsDocTags": route["x-nestia-jsDocTags"],
+      };
     };
 
-    const isNotObjectLiteral = (schema: ISwaggerSchema): boolean =>
-        JsonTypeChecker.isReference(schema) ||
-        JsonTypeChecker.isBoolean(schema) ||
-        JsonTypeChecker.isNumber(schema) ||
-        JsonTypeChecker.isString(schema) ||
-        JsonTypeChecker.isUnknown(schema) ||
-        (JsonTypeChecker.isAnyOf(schema) &&
-            schema.anyOf.every(isNotObjectLiteral)) ||
-        (JsonTypeChecker.isOneOf(schema) &&
-            schema.oneOf.every(isNotObjectLiteral)) ||
-        (JsonTypeChecker.isArray(schema) && isNotObjectLiteral(schema.items));
+  const describe = (route: ISwaggerRoute): string | undefined => {
+    const commentTags: string[] = [];
+    const add = (text: string) => {
+      if (commentTags.every((line) => line !== text)) commentTags.push(text);
+    };
 
-    const emplaceBodySchema =
-        (emplacer: (schema: ISwaggerSchema) => ISwaggerSchema.IReference) =>
-        (meta?: {
-            description?: string;
-            content?: ISwaggerRoute.IContent;
-            "x-nestia-encrypted"?: boolean;
-        }): false | null | IMigrateRoute.IBody => {
-            if (!meta?.content) return null;
+    let description: string | undefined = route.description;
+    if (route.summary) {
+      const emended: string = route.summary.endsWith(".")
+        ? route.summary
+        : route.summary + ".";
+      if (
+        description !== undefined &&
+        !description?.startsWith(route.summary) &&
+        !route["x-nestia-jsDocTags"]?.some((t) => t.name === "summary")
+      )
+        description = `${emended}\n${description}`;
+    }
+    if (route.tags) route.tags.forEach((name) => add(`@tag ${name}`));
+    if (route.deprecated) add("@deprecated");
+    for (const security of route.security ?? [])
+      for (const [name, scopes] of Object.entries(security))
+        add(`@security ${[name, ...scopes].join("")}`);
+    for (const jsDocTag of route["x-nestia-jsDocTags"] ?? [])
+      if (jsDocTag.text?.length)
+        add(
+          `@${jsDocTag.name} ${jsDocTag.text
+            .map((text) => text.text)
+            .join("")}`,
+        );
+      else add(`@${jsDocTag.name}`);
+    return description?.length
+      ? commentTags.length
+        ? `${description}\n\n${commentTags.join("\n")}`
+        : description
+      : commentTags.join("\n");
+  };
 
-            const entries: [string, { schema: ISwaggerSchema }][] =
-                Object.entries(meta.content);
-            const json = entries.find((e) =>
-                meta["x-nestia-encrypted"] === true
-                    ? e[0].includes("text/plain") ||
-                      e[0].includes("application/json")
-                    : e[0].includes("application/json") || e[0].includes("*/*"),
-            );
-            if (json) {
-                const { schema } = json[1];
-                return {
-                    type: "application/json",
-                    schema: isNotObjectLiteral(schema)
-                        ? schema
-                        : emplacer(schema),
-                    "x-nestia-encrypted": meta["x-nestia-encrypted"],
-                };
-            }
+  const isNotObjectLiteral = (schema: ISwaggerSchema): boolean =>
+    SwaggerTypeChecker.isReference(schema) ||
+    SwaggerTypeChecker.isBoolean(schema) ||
+    SwaggerTypeChecker.isNumber(schema) ||
+    SwaggerTypeChecker.isString(schema) ||
+    SwaggerTypeChecker.isUnknown(schema) ||
+    (SwaggerTypeChecker.isAnyOf(schema) &&
+      schema.anyOf.every(isNotObjectLiteral)) ||
+    (SwaggerTypeChecker.isOneOf(schema) &&
+      schema.oneOf.every(isNotObjectLiteral)) ||
+    (SwaggerTypeChecker.isArray(schema) && isNotObjectLiteral(schema.items));
 
-            const query = entries.find((e) =>
-                e[0].includes("application/x-www-form-urlencoded"),
-            );
-            if (query) {
-                const { schema } = query[1];
-                return {
-                    type: "application/x-www-form-urlencoded",
-                    schema: isNotObjectLiteral(schema)
-                        ? schema
-                        : emplacer(schema),
-                };
-            }
+  const emplaceBodySchema =
+    (emplacer: (schema: ISwaggerSchema) => ISwaggerSchema.IReference) =>
+    (meta?: {
+      description?: string;
+      content?: ISwaggerRoute.IContent;
+      "x-nestia-encrypted"?: boolean;
+    }): false | null | IMigrateRoute.IBody => {
+      if (!meta?.content) return null;
 
-            const text = entries.find((e) => e[0].includes("text/plain"));
-            if (text) return { type: "text/plain", schema: { type: "string" } };
-            return false;
+      const entries: [string, { schema: ISwaggerSchema }][] = Object.entries(
+        meta.content,
+      );
+      const json = entries.find((e) =>
+        meta["x-nestia-encrypted"] === true
+          ? e[0].includes("text/plain") || e[0].includes("application/json")
+          : e[0].includes("application/json") || e[0].includes("*/*"),
+      );
+      if (json) {
+        const { schema } = json[1];
+        return {
+          type: "application/json",
+          schema: isNotObjectLiteral(schema) ? schema : emplacer(schema),
+          "x-nestia-encrypted": meta["x-nestia-encrypted"],
         };
+      }
 
-    const emplaceReference =
-        (swagger: ISwagger) =>
-        (name: string) =>
-        (schema: ISwaggerSchema): ISwaggerSchema.IReference => {
-            swagger.components.schemas ??= {};
-            swagger.components.schemas[name] = schema;
-            return { $ref: `#/components/schemas/${name}` };
+      const query = entries.find((e) =>
+        e[0].includes("application/x-www-form-urlencoded"),
+      );
+      if (query) {
+        const { schema } = query[1];
+        return {
+          type: "application/x-www-form-urlencoded",
+          schema: isNotObjectLiteral(schema) ? schema : emplacer(schema),
         };
+      }
 
-    export const write =
-        (components: ISwaggerComponents) =>
-        (references: ISwaggerSchema.IReference[]) =>
-        (importer: ImportProgrammer) =>
-        (route: IMigrateRoute): string => {
-            const output: string = route.success
-                ? SchemaProgrammer.write(components)(references)(importer)(
-                      route.success.schema,
-                  )
-                : "void";
+      const text = entries.find((e) => e[0].includes("text/plain"));
+      if (text) return { type: "text/plain", schema: { type: "string" } };
+      return false;
+    };
 
-            const methoder = (composer: (name: string) => string) =>
-                `${composer(
-                    StringUtil.capitalize(route.method),
-                )}(${JSON.stringify(route.path)})`;
-            const external = (lib: string) => (instance: string) =>
-                importer.external({ library: lib, instance });
+  const emplaceReference =
+    (swagger: ISwagger) =>
+    (name: string) =>
+    (schema: ISwaggerSchema): ISwaggerSchema.IReference => {
+      swagger.components.schemas ??= {};
+      swagger.components.schemas[name] = schema;
+      return { $ref: `#/components/schemas/${name}` };
+    };
 
-            const decorator: string[] =
-                route.success?.["x-nestia-encrypted"] === true
-                    ? [
-                          `@${external("@nestia/core")(
-                              "EncryptedRoute",
-                          )}.${methoder((str) => str)}`,
-                      ]
-                    : route.success?.type === "text/plain"
-                    ? [
-                          `@${external("@nestjs/common")(
-                              "Header",
-                          )}("Content-Type", "text/plain")`,
-                          `@${methoder((str) =>
-                              external("@nestjs/common")(str),
-                          )}`,
-                      ]
-                    : route.success?.type ===
-                      "application/x-www-form-urlencoded"
-                    ? [
-                          `@${external("@nestia/core")(
-                              "TypedQuery",
-                          )}.${methoder((str) => str)}`,
-                      ]
-                    : route.method === "head"
-                    ? [
-                          `@${external("@nestjs/common")("Head")}${methoder(
-                              () => "",
-                          )}`,
-                      ]
-                    : [
-                          `@${external("@nestia/core")(
-                              "TypedRoute",
-                          )}.${methoder((str) => str)}`,
-                      ];
-            for (const [key, value] of Object.entries(route.exceptions ?? {}))
-                decorator.push(
-                    `@${external("@nestia/core")(
-                        "TypedException",
-                    )}<${SchemaProgrammer.write(components)(references)(
-                        importer,
-                    )(value.schema)}>(${
-                        isNaN(Number(key)) ? JSON.stringify(key) : key
-                    }, ${JSON.stringify(value.description)})`,
-                );
+  /* -----------------------------------------------------------
+    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 content: string[] = [
-                ...(route.description
-                    ? [
-                          "/**",
-                          ...route.description
-                              .split("\n")
-                              .map((line) => ` * ${line}`),
-                          " */",
-                      ]
-                    : []),
-                ...decorator,
-                `public async ${route.name}(`,
-                ...route.parameters.map(
-                    (param) =>
-                        `    ${writeParameter(components)(importer)(param)},`,
+      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",
+                  }),
                 ),
-                ...(route.headers
-                    ? [
-                          `    @${external("@nestia/core")(
-                              "TypedHeaders",
-                          )}() headers: ${SchemaProgrammer.write(components)(
-                              references,
-                          )(importer)(route.headers)},`,
-                      ]
-                    : []),
-                ...(route.query
-                    ? [
-                          `    @${external("@nestia/core")(
-                              "TypedQuery",
-                          )}() query: ${SchemaProgrammer.write(components)(
-                              references,
-                          )(importer)(route.query)},`,
-                      ]
-                    : []),
-                ...(route.body
-                    ? route.body["x-nestia-encrypted"] === true
-                        ? [
-                              `    @${external("@nestia/core")(
-                                  "EncryptedBody",
-                              )}() body: ${SchemaProgrammer.write(components)(
-                                  references,
-                              )(importer)(route.body.schema)},`,
-                          ]
-                        : route.body.type === "application/json"
-                        ? [
-                              `    @${external("@nestia/core")(
-                                  "TypedBody",
-                              )}() body: ${SchemaProgrammer.write(components)(
-                                  references,
-                              )(importer)(route.body.schema)},`,
-                          ]
-                        : route.body.type ===
-                          "application/x-www-form-urlencoded"
-                        ? [
-                              `    @${external("@nestia/core")(
-                                  "TypedQuery",
-                              )}.Body() body: ${SchemaProgrammer.write(
-                                  components,
-                              )(references)(importer)(route.body.schema)},`,
-                          ]
-                        : [
-                              `    @${external("@nestia/core")(
-                                  "PlainBody",
-                              )}() body: string,`,
-                          ]
-                    : []),
-                `): Promise<${output}> {`,
-                ...route.parameters.map(
-                    (p) => `    ${StringUtil.normalize(p.key)};`,
+                [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",
+                  }),
                 ),
-                ...(route.headers ? ["    headers;"] : []),
-                ...(route.query ? ["    query;"] : []),
-                ...(route.body ? ["    body;"] : []),
-                ...(output !== "void"
-                    ? [
-                          `    return ${external("typia")(
-                              "random",
-                          )}<${output}>();`,
-                      ]
-                    : []),
-                `}`,
-            ];
-            return content.join("\n");
-        };
+                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 writeParameter =
-        (components: ISwaggerComponents) =>
-        (importer: ImportProgrammer) =>
-        ({ key, schema }: IMigrateRoute.IParameter): string => {
-            const variable = StringUtil.normalize(key);
-            return `@${importer.external({
-                library: "@nestia/core",
-                instance: "TypedParam",
-            })}(${JSON.stringify(key)}) ${variable}: ${SchemaProgrammer.write(
-                components,
-            )([])(importer)(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([
-    "GET",
-    "POST",
-    "PUT",
-    "PATCH",
-    "DELETE",
-    "HEAD",
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
 ]);