@nestia/migrate 0.1.11 → 0.2.1-dev.20230802

package/src/programmers/DtoProgrammer.ts

@@ -1,6 +1,7 @@
 import { IMigrateDto } from "../structures/IMigrateDto";
 import { ISwaggerSchema } from "../structures/ISwaggeSchema";
 import { ISwagger } from "../structures/ISwagger";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { MapUtil } from "../utils/MapUtil";
 import { SchemaProgrammer } from "./SchemaProgrammer";
 
@@ -25,30 +26,33 @@ export namespace DtoProgrammer {
         return modulo;
     };
 
-    export const write = (dto: IMigrateDto): string => {
-        const references: ISwaggerSchema.IReference[] = [];
-        const body: string = iterate(references)(dto);
-        const imports: string[] = [
-            ...new Set(
-                references
-                    .map(
-                        (s) =>
-                            s.$ref
-                                .replace(`#/components/schemas/`, ``)
-                                .split(".")[0],
-                    )
-                    .filter((str) => str !== dto.name),
-            ),
-        ];
-        const content: string[] = [
-            ...imports.map((i) => `import { ${i} } from "./${i}";`),
-            ...(imports.length ? [""] : []),
-            body,
-        ];
-        return content.join("\n");
-    };
+    export const write =
+        (components: ISwaggerComponents) =>
+        (dto: IMigrateDto): string => {
+            const references: ISwaggerSchema.IReference[] = [];
+            const body: string = iterate(components)(references)(dto);
+            const imports: string[] = [
+                ...new Set(
+                    references
+                        .map(
+                            (s) =>
+                                s.$ref
+                                    .replace(`#/components/schemas/`, ``)
+                                    .split(".")[0],
+                        )
+                        .filter((str) => str !== dto.name),
+                ),
+            ];
+            const content: string[] = [
+                ...imports.map((i) => `import { ${i} } from "./${i}";`),
+                ...(imports.length ? [""] : []),
+                body,
+            ];
+            return content.join("\n");
+        };
 
     const iterate =
+        (components: ISwaggerComponents) =>
         (references: ISwaggerSchema.IReference[]) =>
         (dto: IMigrateDto): string => {
             const content: string[] = [];
@@ -63,15 +67,15 @@ export namespace DtoProgrammer {
                           ]
                         : []),
                     `export type ${dto.name} = ${SchemaProgrammer.write(
-                        references,
-                    )(dto.schema)}`,
+                        components,
+                    )(references)(dto.schema)}`,
                 );
             }
             if (dto.children.length) {
                 content.push(
                     `export namespace ${dto.name} {`,
                     ...dto.children.map((c) =>
-                        iterate(references)(c)
+                        iterate(components)(references)(c)
                             .split("\n")
                             .map((l) => `    ${l}`)
                             .join("\n"),

package/src/programmers/ImportProgrammer.ts

@@ -0,0 +1,29 @@
+import { MapUtil } from "../utils/MapUtil";
+
+export class ImportProgrammer {
+    private dict: Map<string, Set<string>> = new Map();
+
+    public add(props: ImportProgrammer.IProps): string {
+        MapUtil.take(this.dict)(props.library)(() => new Set()).add(
+            props.instance,
+        );
+        return props.instance;
+    }
+
+    public toScript(): string {
+        return [...this.dict.entries()]
+            .map(
+                ([library, properties]) =>
+                    `import { ${[...properties].join(
+                        ", ",
+                    )} } from "${library}";`,
+            )
+            .join("\n");
+    }
+}
+export namespace ImportProgrammer {
+    export interface IProps {
+        library: string;
+        instance: string;
+    }
+}

package/src/programmers/MigrateProgrammer.ts

@@ -1,6 +1,7 @@
 import { IMigrateFile } from "../structures/IMigrateFile";
 import { IMigrateProgram } from "../structures/IMigrateProgram";
 import { ISwagger } from "../structures/ISwagger";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { ControllerProgrammer } from "./ControllerProgrammer";
 import { DtoProgrammer } from "./DtoProgrammer";
 
@@ -14,18 +15,20 @@ export namespace MigrateProgrammer {
         };
     };
 
-    export const write = (program: IMigrateProgram): IMigrateFile[] => {
-        return [
-            ...program.controllers.map((c) => ({
-                location: c.location,
-                file: `${c.name}.ts`,
-                content: ControllerProgrammer.write(c),
-            })),
-            ...program.structures.map((s) => ({
-                location: s.location,
-                file: `${s.name}.ts`,
-                content: DtoProgrammer.write(s),
-            })),
-        ];
-    };
+    export const write =
+        (components: ISwaggerComponents) =>
+        (program: IMigrateProgram): IMigrateFile[] => {
+            return [
+                ...program.controllers.map((c) => ({
+                    location: c.location,
+                    file: `${c.name}.ts`,
+                    content: ControllerProgrammer.write(components)(c),
+                })),
+                ...program.structures.map((s) => ({
+                    location: s.location,
+                    file: `${s.name}.ts`,
+                    content: DtoProgrammer.write(components)(s),
+                })),
+            ];
+        };
 }

package/src/programmers/RouteProgrammer.ts

@@ -3,6 +3,7 @@ import { Escaper } from "typia/lib/utils/Escaper";
 import { IMigrateRoute } from "../structures/IMigrateRoute";
 import { ISwaggerSchema } from "../structures/ISwaggeSchema";
 import { ISwagger } from "../structures/ISwagger";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
 import { ISwaggerRoute } from "../structures/ISwaggerRoute";
 import { JsonTypeChecker } from "../utils/JsonTypeChecker";
 import { StringUtil } from "../utils/StringUtil";
@@ -14,11 +15,11 @@ export namespace RouteProgrammer {
         (props: { path: string; method: string }) =>
         (route: ISwaggerRoute): IMigrateRoute | null => {
             const body = emplaceBodySchema(emplaceReference(swagger)("body"))(
-                route.requestBody?.content,
+                route.requestBody,
             );
             const response = emplaceBodySchema(
                 emplaceReference(swagger)("response"),
-            )((route.responses?.["200"] ?? route.responses?.["201"])?.content);
+            )(route.responses?.["201"] ?? route.responses?.["200"]);
             if (body === false || response === false) {
                 console.log(
                     `Failed to migrate ${props.method.toUpperCase()} ${
@@ -26,6 +27,15 @@ export namespace RouteProgrammer {
                     }: @nestia/migrate supports only application/json 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) => {
@@ -193,32 +203,47 @@ export namespace RouteProgrammer {
                 body,
                 response,
                 description: describe(route),
+                "x-nestia-jsDocTags": route["x-nestia-jsDocTags"],
             };
         };
 
     const describe = (route: ISwaggerRoute): string | undefined => {
-        const content: string[] = [];
+        const commentTags: string[] = [];
         const add = (text: string) => {
-            if (!route.description || route.description.indexOf(text) === -1)
-                content.push(text);
+            if (commentTags.every((line) => line !== text))
+                commentTags.push(text);
         };
-        if (route.summary)
-            add(
-                (route.summary.endsWith(".")
-                    ? route.summary
-                    : route.summary + ".") + "\n",
-            );
-        if (route.description) {
-            content.push(...route.description.split("\n"));
-            if (!route.description.split("\n").at(-1)?.startsWith("@"))
-                content.push("");
+
+        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("")}`);
-        return content.length ? content.join("\n") : undefined;
+        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 isNotObjectLiteral = (schema: ISwaggerSchema): boolean =>
@@ -235,14 +260,21 @@ export namespace RouteProgrammer {
 
     const emplaceBodySchema =
         (emplacer: (schema: ISwaggerSchema) => ISwaggerSchema.IReference) =>
-        (
-            content?: ISwaggerRoute.IContent,
-        ): false | null | IMigrateRoute.IBody => {
-            if (!content) return null;
+        (meta?: {
+            description?: string;
+            content?: ISwaggerRoute.IContent;
+            "x-nestia-encrypted"?: boolean;
+        }): false | null | IMigrateRoute.IBody => {
+            if (!meta?.content) return null;
 
             const entries: [string, { schema: ISwaggerSchema }][] =
-                Object.entries(content);
-            const json = entries.find((e) => e[0].includes("application/json"));
+                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"),
+            );
 
             if (json) {
                 const { schema } = json[1];
@@ -251,6 +283,7 @@ export namespace RouteProgrammer {
                     schema: isNotObjectLiteral(schema)
                         ? schema
                         : emplacer(schema),
+                    "x-nestia-encrypted": meta["x-nestia-encrypted"],
                 };
             }
 
@@ -269,15 +302,47 @@ export namespace RouteProgrammer {
         };
 
     export const write =
+        (importer: (module: string) => (instance: string) => string) =>
+        (components: ISwaggerComponents) =>
         (references: ISwaggerSchema.IReference[]) =>
         (route: IMigrateRoute): string => {
             const output: string = route.response
-                ? SchemaProgrammer.write(references)(route.response.schema)
+                ? SchemaProgrammer.write(components)(references)(
+                      route.response.schema,
+                  )
                 : "void";
-            const decorator: string =
-                route.body?.type === "text/plain"
-                    ? [`@Header("Content-Type", "text/plain")`, `@`].join("\n")
-                    : "@core.TypedRoute.";
+
+            const methoder = (composer: (name: string) => string) =>
+                `${composer(
+                    StringUtil.capitalize(route.method),
+                )}(${JSON.stringify(route.path)})`;
+            const decorator: string[] =
+                route.response?.["x-nestia-encrypted"] === true
+                    ? [
+                          `@${importer("@nestia/core")(
+                              "EncryptedRoute",
+                          )}.${methoder((str) => str)}`,
+                      ]
+                    : route.response?.type === "text/plain"
+                    ? [
+                          `@${importer("@nestjs/common")(
+                              "Header",
+                          )}("Content-Type", "text/plain")`,
+                          `@${methoder((str) =>
+                              importer("@nestjs/common")(str),
+                          )}`,
+                      ]
+                    : route.method === "head"
+                    ? [
+                          `@${importer("@nestjs/common")("Head")}${methoder(
+                              () => "",
+                          )}`,
+                      ]
+                    : [
+                          `@${importer("@nestia/core")(
+                              "TypedRoute",
+                          )}.${methoder((str) => str)}`,
+                      ];
             const content: string[] = [
                 ...(route.description
                     ? [
@@ -288,54 +353,95 @@ export namespace RouteProgrammer {
                           " */",
                       ]
                     : []),
-                `${decorator}${StringUtil.capitalize(route.method)}${
-                    route.path.length ? `(${JSON.stringify(route.path)})` : "()"
-                }`,
+                ...decorator,
                 `public async ${route.name}(`,
-                ...route.parameters.map((p) => `    ${writeParameter(p)},`),
+                ...route.parameters.map(
+                    (param) =>
+                        `    ${writeParameter(components)(importer)(param)},`,
+                ),
+                ...(route.headers
+                    ? [
+                          `    @${importer("@nestia/core")(
+                              "TypedHeaders",
+                          )}() headers: ${SchemaProgrammer.write(components)(
+                              references,
+                          )(route.headers)},`,
+                      ]
+                    : []),
                 ...(route.query
                     ? [
-                          `    @core.TypedQuery() query: ${SchemaProgrammer.write(
+                          `    @${importer("@nestia/core")(
+                              "TypedQuery",
+                          )}() query: ${SchemaProgrammer.write(components)(
                               references,
-                          )(route.query)}`,
+                          )(route.query)},`,
                       ]
                     : []),
                 ...(route.body
-                    ? route.body.type === "application/json"
+                    ? route.body["x-nestia-encrypted"] === true
                         ? [
-                              `    @core.TypedBody() body: ${SchemaProgrammer.write(
+                              `    @${importer("@nestia/core")(
+                                  "EncryptedBody",
+                              )}() body: ${SchemaProgrammer.write(components)(
                                   references,
                               )(route.body.schema)},`,
                           ]
-                        : [`    @core.PlainBody() body: string,`]
+                        : route.body.type === "application/json"
+                        ? [
+                              `    @${importer("@nestia/core")(
+                                  "TypedBody",
+                              )}() body: ${SchemaProgrammer.write(components)(
+                                  references,
+                              )(route.body.schema)},`,
+                          ]
+                        : [
+                              `    @${importer("@nestia/core")(
+                                  "PlainBody",
+                              )}() body: string,`,
+                          ]
                     : []),
                 `): Promise<${output}> {`,
                 ...route.parameters.map(
                     (p) => `    ${StringUtil.normalize(p.key)};`,
                 ),
-                // ...(route.headers ? ["headers;"] : []),
+                ...(route.headers ? ["    headers;"] : []),
                 ...(route.query ? ["    query;"] : []),
                 ...(route.body ? ["    body;"] : []),
                 ...(output !== "void"
-                    ? [`    return typia.random<${output}>();`]
+                    ? [
+                          `    return ${importer("typia")(
+                              "random",
+                          )}<${output}>();`,
+                      ]
                     : []),
                 `}`,
             ];
             return content.join("\n");
         };
 
-    const writeParameter = ({
-        key,
-        schema,
-    }: IMigrateRoute.IParameter): string => {
-        const variable = StringUtil.normalize(key);
-        const format =
-            JsonTypeChecker.isString(schema) &&
-            (schema.format === "uuid" || schema.format === "date")
-                ? schema.format
-                : null;
-        return `@core.TypedParam(${JSON.stringify(key)}${
-            format ? `, ${JSON.stringify(format)}` : ""
-        }) ${variable}: ${SchemaProgrammer.write([])(schema)}`;
-    };
+    const writeParameter =
+        (components: ISwaggerComponents) =>
+        (importer: (library: string) => (instance: string) => string) =>
+        ({ key, schema }: IMigrateRoute.IParameter): string => {
+            const variable = StringUtil.normalize(key);
+            const format =
+                JsonTypeChecker.isString(schema) &&
+                (schema.format === "uuid" || schema.format === "date")
+                    ? schema.format
+                    : null;
+            return `@${importer("@nestia/core")("TypedParam")}(${JSON.stringify(
+                key,
+            )}${
+                format ? `, ${JSON.stringify(format)}` : ""
+            }) ${variable}: ${SchemaProgrammer.write(components)([])(schema)}`;
+        };
 }
+
+const SUPPORTED_METHODS: Set<string> = new Set([
+    "GET",
+    "POST",
+    "PUT",
+    "PATCH",
+    "DELETE",
+    "HEAD",
+]);