@nestia/migrate 0.1.0

package/src/programmers/RouteProgrammer.ts

@@ -0,0 +1,264 @@
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { ISwagger } from "../structures/ISwagger";
+import { ISwaggerRoute } from "../structures/ISwaggerRoute";
+import { JsonTypeChecker } from "../utils/JsonTypeChecker";
+import { StringUtil } from "../utils/StringUtil";
+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?.content,
+            );
+            const response = emplaceBodySchema(
+                emplaceReference(swagger)("response"),
+            )((route.responses["200"] ?? route.responses["201"])?.content);
+            if (body === false || response === false) 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.isString(p.schema),
+                );
+                if (objects.length === 1) return objects[0];
+                else if (
+                    objects.length + primitives.length !==
+                    parameters.length
+                )
+                    throw new Error(
+                        `Error on nestia.migrate.RouteProgrammer.analze(): ${type} typed parameters must be only one object type.`,
+                    );
+
+                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,
+                                },
+                            ]),
+                        ),
+                        required: primitives
+                            .filter((p) => p.required)
+                            .map((p) => p.name),
+                    },
+                ];
+                return parameters.length === 0
+                    ? null
+                    : emplaceReference(swagger)(
+                          StringUtil.pascal(
+                              `I/Api/${StringUtil.reJoinWithoutParameters(
+                                  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(),
+                              ),
+                          ],
+                      });
+            });
+
+            return {
+                name: "@lazy",
+                path: props.path,
+                method: props.method,
+                headers,
+                parameters: route.parameters
+                    .filter((p) => p.in === "path")
+                    .map((p) => ({
+                        key: p.name,
+                        schema: {
+                            ...p.schema,
+                            description: p.schema.description ?? p.description,
+                        },
+                    })),
+                query,
+                body,
+                response,
+                description: describe(route),
+            };
+        };
+
+    const describe = (route: ISwaggerRoute): string | undefined => {
+        const content: string[] = [];
+        const add = (text: string) => {
+            if (!route.description || route.description.indexOf(text) === -1)
+                content.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("");
+        }
+        if (route.tags) route.tags.forEach((name) => add(`@tag ${name}`));
+        if (route.deprecated) add("@deprecated");
+        return content.length ? content.join("\n") : undefined;
+    };
+
+    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 emplaceBodySchema =
+        (emplacer: (schema: ISwaggerSchema) => ISwaggerSchema.IReference) =>
+        (content?: ISwaggerRoute.IContent): false | null | ISwaggerSchema => {
+            if (!content) return null;
+            else if (content["application/json"]) {
+                const schema = content["application/json"].schema;
+                return isNotObjectLiteral(schema) ? schema : emplacer(schema);
+            } else if (content["text/plain"]) return { type: "string" };
+            return false;
+        };
+
+    const emplaceReference =
+        (swagger: ISwagger) =>
+        (name: string) =>
+        (schema: ISwaggerSchema): ISwaggerSchema.IReference => {
+            swagger.components.schemas ??= {};
+            swagger.components.schemas[name] = schema;
+            return { $ref: `#/components/schemas/${name}` };
+        };
+
+    export const write =
+        (references: ISwaggerSchema.IReference[]) =>
+        (route: IMigrateRoute): string => {
+            const output: string = route.response
+                ? SchemaProgrammer.write(references)(route.response)
+                : "void";
+            const content: string[] = [
+                ...(route.description
+                    ? [
+                          "/**",
+                          ...route.description
+                              .split("\n")
+                              .map((line) => ` * ${line}`),
+                          " */",
+                      ]
+                    : []),
+                `@core.TypedRoute.${StringUtil.capitalize(route.method)}${
+                    route.path.length ? `(${JSON.stringify(route.path)})` : "()"
+                }`,
+                `public async ${route.name}(`,
+                ...route.parameters.map((p) => `    ${writeParameter(p)},`),
+                ...(route.query
+                    ? [
+                          `    @core.TypedQuery() query: ${SchemaProgrammer.write(
+                              references,
+                          )(route.query)}`,
+                      ]
+                    : []),
+                ...(route.body
+                    ? [
+                          `    @core.TypedBody() body: ${SchemaProgrammer.write(
+                              references,
+                          )(route.body)},`,
+                      ]
+                    : []),
+                `): Promise<${output}> {`,
+                ...route.parameters.map(
+                    (p) => `    ${StringUtil.normalize(p.key)};`,
+                ),
+                // ...(route.headers ? ["headers;"] : []),
+                ...(route.query ? ["    query;"] : []),
+                ...(route.body ? ["    body;"] : []),
+                ...(output !== "void"
+                    ? [`    return 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)}`;
+    };
+}

package/src/programmers/SchemaProgrammer.ts

@@ -0,0 +1,215 @@
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { ISwaggerSchema } from "../structures/ISwaggeSchema";
+import { JsonTypeChecker } from "../utils/JsonTypeChecker";
+
+export namespace SchemaProgrammer {
+    export const write =
+        (references: ISwaggerSchema.IReference[]) =>
+        (schema: ISwaggerSchema): string =>
+            writeSchema(references)(() => () => {})(schema);
+
+    type Tagger = (tag: string) => (value?: string) => void;
+    const writeSchema =
+        (references: ISwaggerSchema.IReference[]) =>
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema): string => {
+            // SPECIAL TYPES
+            if (JsonTypeChecker.isUnknown(schema)) return "any";
+            else if (JsonTypeChecker.isAnyOf(schema))
+                return schema.anyOf
+                    .map(writeSchema(references)(tagger))
+                    .join(" | ");
+            else if (JsonTypeChecker.isOneOf(schema))
+                return schema.oneOf
+                    .map(writeSchema(references)(tagger))
+                    .join(" | ");
+            // ATOMIC TYPES
+            else if (JsonTypeChecker.isBoolean(schema))
+                return writeBoolean(tagger)(schema);
+            else if (JsonTypeChecker.isInteger(schema))
+                return writeInteger(tagger)(schema);
+            else if (JsonTypeChecker.isNumber(schema))
+                return writeNumber(tagger)(schema);
+            else if (JsonTypeChecker.isString(schema))
+                return writeString(tagger)(schema);
+            // INSTANCE TYPES
+            else if (JsonTypeChecker.isArray(schema))
+                return writeArray(references)(tagger)(schema);
+            else if (JsonTypeChecker.isObject(schema))
+                return writeObject(references)(schema);
+            else if (JsonTypeChecker.isReference(schema)) {
+                references.push(schema);
+                return schema.$ref.replace(`#/components/schemas/`, ``);
+            }
+            // NOTHING
+            return "any";
+        };
+
+    const writeBoolean =
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema.IBoolean): string => {
+            if (schema.default) tagger("default")(schema.default.toString());
+            return schema.enum ? schema.enum.join(" | ") : "boolean";
+        };
+    const writeInteger =
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema.IInteger): string => {
+            tagger("type")("int");
+            return writeNumber(tagger)(schema);
+        };
+    const writeNumber =
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema.IInteger | ISwaggerSchema.INumber): string => {
+            if (schema.default) tagger("default")(schema.default.toString());
+            if (schema.enum?.length) return schema.enum.join(" | ");
+
+            if (schema.minimum !== undefined)
+                tagger(
+                    schema.exclusiveMinimum ? "exclusiveMinimum" : "minimum",
+                )(schema.minimum.toString());
+            if (schema.maximum !== undefined)
+                tagger(
+                    schema.exclusiveMaximum ? "exclusiveMaximum" : "maximum",
+                )(schema.maximum.toString());
+            if (schema.multipleOf !== undefined)
+                tagger("multipleOf")(schema.multipleOf.toString());
+            return "number";
+        };
+    const writeString =
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema.IString): string => {
+            if (schema.default) tagger("default")(schema.default);
+            if (schema.enum?.length)
+                return schema.enum
+                    .map((str) => JSON.stringify(str))
+                    .join(" | ");
+
+            if (schema.minLength !== undefined)
+                tagger("minLength")(schema.minLength.toString());
+            if (schema.maxLength !== undefined)
+                tagger("maxLength")(schema.maxLength.toString());
+            if (schema.pattern !== undefined) tagger("pattern")(schema.pattern);
+            return "string";
+        };
+
+    const writeArray =
+        (references: ISwaggerSchema.IReference[]) =>
+        (tagger: Tagger) =>
+        (schema: ISwaggerSchema.IArray): string =>
+            schema["x-typia-tuple"]
+                ? `[${schema["x-typia-tuple"].items
+                      .map(writeTupleElement(references))
+                      .join(", ")}]`
+                : `Array<${writeSchema(references)(tagger)(schema.items)}>`;
+    const writeTupleElement =
+        (references: ISwaggerSchema.IReference[]) =>
+        (schema: ISwaggerSchema): string => {
+            const name: string = writeSchema(references)(() => () => {})(
+                schema,
+            );
+            return schema["x-typia-optional"]
+                ? `${name}?`
+                : schema["x-typia-rest"]
+                ? `...${name}`
+                : name;
+        };
+
+    const writeObject =
+        (references: ISwaggerSchema.IReference[]) =>
+        (schema: ISwaggerSchema.IObject): string => {
+            const entries = Object.entries(schema.properties);
+            return typeof schema.additionalProperties === "object"
+                ? entries.length
+                    ? `${writeStaticObject(references)(
+                          schema,
+                      )} & ${writeDynamicObject(references)(
+                          schema.additionalProperties,
+                      )}`
+                    : writeDynamicObject(references)(
+                          schema.additionalProperties,
+                      )
+                : writeStaticObject(references)(schema);
+        };
+    const writeStaticObject =
+        (references: ISwaggerSchema.IReference[]) =>
+        (schema: ISwaggerSchema.IObject): string =>
+            [
+                "{",
+                ...Object.entries(schema.properties)
+                    .map(([key, value]) =>
+                        writeProperty(references)(key)(
+                            (schema.required ?? []).some((r) => r === key),
+                        )(value),
+                    )
+                    .map(tab(4)),
+                "}",
+            ].join("\n");
+    const writeDynamicObject =
+        (references: ISwaggerSchema.IReference[]) =>
+        (additional: ISwaggerSchema): string => {
+            return [
+                "{",
+                tab(4)(
+                    writeProperty(references)("[key: string]", true)(true)(
+                        additional,
+                    ),
+                ),
+                "}",
+            ].join("\n");
+        };
+
+    const writeProperty =
+        (references: ISwaggerSchema.IReference[]) =>
+        (key: string, ensureVariable: boolean = false) =>
+        (required: boolean) =>
+        (schema: ISwaggerSchema): string => {
+            const content: string[] = [];
+            const tagger = (tag: string) => (value?: string) => {
+                const exists: boolean =
+                    (!!schema.description?.length &&
+                        schema.description.includes(`@${tag}`)) ||
+                    content.some((line) => line.includes(`@${tag}`));
+                if (exists === false)
+                    if (value?.length) content.push(`@${tag} ${value}`);
+                    else content.push(`@${tag}`);
+            };
+            if (schema.description) {
+                content.push(...schema.description.split("\n"));
+                if (!schema.description.split("\n").at(-1)?.startsWith("@"))
+                    content.push("");
+            }
+
+            // STARTS FROM TITLE
+            if (schema.title) tagger("@title")(schema.title);
+
+            // GET TYPE WITH SPECIAL TAGS
+            const type: string = writeSchema(references)(tagger)(schema);
+
+            // ENDS WITH DEPRECATED TAG
+            if (schema.deprecated) tagger("@deprecated")();
+
+            const description: string =
+                content.length === 0
+                    ? ""
+                    : [
+                          "/**",
+                          ...content.map((line) => ` * ${line}`),
+                          " */",
+                          "",
+                      ].join("\n");
+            return `${description}${
+                ensureVariable === false && Escaper.variable(key) === false
+                    ? JSON.stringify(key)
+                    : key
+            }${required ? "" : "?"}: ${type};`;
+        };
+
+    const tab =
+        (size: number) =>
+        (str: string): string =>
+            str
+                .split("\n")
+                .map((l) => `${" ".repeat(size)}${l}`)
+                .join("\n");
+}

package/src/structures/IMigrateController.ts

@@ -0,0 +1,8 @@
+import { IMigrateRoute } from "./IMigrateRoute";
+
+export interface IMigrateController {
+    name: string;
+    path: string;
+    location: string;
+    routes: IMigrateRoute[];
+}

package/src/structures/IMigrateDto.ts

@@ -0,0 +1,8 @@
+import { ISwaggerSchema } from "./ISwaggeSchema";
+
+export interface IMigrateDto {
+    name: string;
+    location: string;
+    schema: ISwaggerSchema | null;
+    children: IMigrateDto[];
+}

package/src/structures/IMigrateFile.ts

@@ -0,0 +1,5 @@
+export interface IMigrateFile {
+    location: string;
+    file: string;
+    content: string;
+}

package/src/structures/IMigrateProgram.ts

@@ -0,0 +1,7 @@
+import { IMigrateController } from "./IMigrateController";
+import { IMigrateDto } from "./IMigrateDto";
+
+export interface IMigrateProgram {
+    controllers: IMigrateController[];
+    structures: IMigrateDto[];
+}

package/src/structures/IMigrateRoute.ts

@@ -0,0 +1,20 @@
+import { ISwaggerSchema } from "./ISwaggeSchema";
+
+export interface IMigrateRoute {
+    name: string;
+    path: string;
+    method: string;
+    parameters: IMigrateRoute.IParameter[];
+    headers: ISwaggerSchema | null;
+    query: ISwaggerSchema | null;
+    body: ISwaggerSchema | null;
+    response: ISwaggerSchema | null;
+    description?: string;
+}
+export namespace IMigrateRoute {
+    export interface IParameter {
+        key: string;
+        schema: ISwaggerSchema;
+        description?: string;
+    }
+}

package/src/structures/IMigrateSchema.ts

@@ -0,0 +1,4 @@
+export interface IMigrateSchema {
+    name: string;
+    children: IMigrateSchema[];
+}

package/src/structures/ISwaggeSchema.ts

@@ -0,0 +1,85 @@
+export type ISwaggerSchema =
+    | ISwaggerSchema.IUnknown
+    | ISwaggerSchema.IAnyOf
+    | ISwaggerSchema.IOneOf
+    | ISwaggerSchema.IBoolean
+    | ISwaggerSchema.IInteger
+    | ISwaggerSchema.INumber
+    | ISwaggerSchema.IString
+    | ISwaggerSchema.IArray
+    | ISwaggerSchema.IObject
+    | ISwaggerSchema.IReference;
+export namespace ISwaggerSchema {
+    export interface IUnknown extends IAttribute {
+        type?: undefined;
+    }
+    export interface IAnyOf extends IAttribute {
+        anyOf: ISwaggerSchema[];
+    }
+    export interface IOneOf extends IAttribute {
+        oneOf: ISwaggerSchema[];
+    }
+
+    export interface IBoolean extends ISignificant<"boolean"> {
+        default?: boolean;
+        enum?: boolean[];
+    }
+    export interface IInteger extends ISignificant<"integer"> {
+        /** @type int */ default?: number;
+        /** @type int */ enum?: number[];
+        /** @type int */ minimum?: number;
+        /** @type int */ maximum?: number;
+        /** @type int */ exclusiveMinimum?: boolean;
+        /** @type int */ exclusiveMaximum?: boolean;
+        /** @type uint */ multipleOf?: number;
+    }
+    export interface INumber extends ISignificant<"number"> {
+        default?: number;
+        enum?: number[];
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: boolean;
+        exclusiveMaximum?: boolean;
+        multipleOf?: number;
+    }
+    export interface IString extends ISignificant<"string"> {
+        default?: string;
+        enum?: string[];
+        format?: string;
+        pattern?: string;
+        /** @type uint */ minLength?: number;
+        /** @type uint */ maxLength?: number;
+    }
+
+    export interface IArray extends ISignificant<"array"> {
+        items: ISwaggerSchema;
+        /** @type uint */ minItems?: number;
+        /** @type uint */ maxItems?: number;
+        "x-typia-tuple"?: ITuple;
+    }
+    export interface ITuple extends ISignificant<"array"> {
+        items: ISwaggerSchema[];
+    }
+    export interface IObject extends ISignificant<"object"> {
+        properties: Record<string, ISwaggerSchema>;
+        required?: string[];
+        additionalProperties?: ISwaggerSchema | boolean;
+        "x-typia-patternProperties"?: Record<string, ISwaggerSchema>;
+    }
+
+    export interface IReference extends IAttribute {
+        $ref: string;
+    }
+
+    interface ISignificant<Type extends string> extends IAttribute {
+        type: Type;
+        nullable?: boolean;
+    }
+    interface IAttribute {
+        title?: string;
+        description?: string;
+        deprecated?: boolean;
+        "x-typia-optional"?: boolean;
+        "x-typia-rest"?: boolean;
+    }
+}

package/src/structures/ISwagger.ts

@@ -0,0 +1,24 @@
+import { ISwaggerComponents } from "./ISwaggerComponents";
+import { ISwaggerRoute } from "./ISwaggerRoute";
+
+export interface ISwagger {
+    openapi: `3.0.${number}`;
+    info: ISwagger.IInfo;
+    servers: ISwagger.IServer[];
+
+    components: ISwaggerComponents;
+    paths: Record<string, ISwagger.IPath>;
+    security?: Record<string, string[]>[];
+}
+export namespace ISwagger {
+    export interface IServer {
+        url: string;
+        description?: string;
+    }
+    export interface IInfo {
+        version: string;
+        title: string;
+        description?: string;
+    }
+    export type IPath = Record<string, ISwaggerRoute>;
+}

package/src/structures/ISwaggerComponents.ts

@@ -0,0 +1,7 @@
+import { ISwaggerSchema } from "./ISwaggeSchema";
+import { ISwaggerSecurity } from "./ISwaggerSecurity";
+
+export interface ISwaggerComponents {
+    schemas?: Record<string, ISwaggerSchema>;
+    securitySchemes?: Record<string, ISwaggerSecurity>;
+}