@nestia/migrate 6.0.6 → 7.0.0-dev.20250605

package/src/programmers/MigrateNestControllerProgrammer.ts

@@ -1,57 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-
-import { MigrateApplication } from "../MigrateApplication";
-import { IHttpMigrateController } from "../structures/IHttpMigrateController";
-import { FilePrinter } from "../utils/FilePrinter";
-import { StringUtil } from "../utils/StringUtil";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateNestMethodProgrammer } from "./MigrateNestMethodProgrammer";
-
-export namespace MigrateNestControllerProgrammer {
-  export const write =
-    (config: MigrateApplication.IConfig) =>
-    (components: OpenApi.IComponents) =>
-    (controller: IHttpMigrateController): ts.Statement[] => {
-      const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
-      const $class = ts.factory.createClassDeclaration(
-        [
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                importer.external({
-                  type: "instance",
-                  library: "@nestjs/common",
-                  name: "Controller",
-                }),
-              ),
-              [],
-              [ts.factory.createStringLiteral(controller.path)],
-            ),
-          ),
-          ts.factory.createToken(ts.SyntaxKind.ExportKeyword),
-        ],
-        controller.name,
-        [],
-        [],
-        controller.routes
-          .map((route, index) => [
-            ...(index !== 0 ? [FilePrinter.newLine() as any] : []),
-            MigrateNestMethodProgrammer.write(config)(components)(importer)(
-              controller,
-            )(route),
-          ])
-          .flat(),
-      );
-      return [
-        ...importer.toStatements(
-          (ref) =>
-            `${"../".repeat(
-              StringUtil.splitWithNormalization(controller.location).length - 1,
-            )}api/structures/${ref}`,
-        ),
-        ...(importer.empty() ? [] : [FilePrinter.newLine()]),
-        $class,
-      ];
-    };
-}

package/src/programmers/MigrateNestMethodProgrammer.ts

@@ -1,397 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-import { ExpressionFactory } from "typia/lib/factories/ExpressionFactory";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
-
-import { MigrateApplication } from "../MigrateApplication";
-import { IHttpMigrateController } from "../structures/IHttpMigrateController";
-import { IHttpMigrateRoute } from "../structures/IHttpMigrateRoute";
-import { FilePrinter } from "../utils/FilePrinter";
-import { StringUtil } from "../utils/StringUtil";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
-
-export namespace MigrateNestMethodProgrammer {
-  export const write =
-    (config: MigrateApplication.IConfig) =>
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (controller: IHttpMigrateController) =>
-    (route: IHttpMigrateRoute): ts.MethodDeclaration => {
-      const output: ts.TypeNode = route.success
-        ? MigrateSchemaProgrammer.write(components)(importer)(
-            route.success.schema,
-          )
-        : TypeFactory.keyword("void");
-
-      const method: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
-        [
-          ...writeMethodDecorators(components)(importer)(controller)(route),
-          ts.factory.createToken(ts.SyntaxKind.PublicKeyword),
-          ts.factory.createToken(ts.SyntaxKind.AsyncKeyword),
-        ],
-        undefined,
-        route.accessor.at(-1)!,
-        undefined,
-        undefined,
-        writeParameters(components)(importer)(route),
-        ts.factory.createTypeReferenceNode("Promise", [output]),
-        ts.factory.createBlock(
-          [
-            ...[
-              ...route.parameters.map((p) => 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(
-                IdentifierFactory.access(
-                  ts.factory.createIdentifier(
-                    importer.external({
-                      type: "default",
-                      library: "typia",
-                      name: "typia",
-                    }),
-                  ),
-                  "random",
-                ),
-                [output],
-                undefined,
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-      return FilePrinter.description(method, writeDescription(config)(route));
-    };
-
-  const writeDescription =
-    (config: MigrateApplication.IConfig) =>
-    (method: IHttpMigrateRoute): string =>
-      [
-        method.comment(),
-        `@${config.author?.tag ?? "nestia"} ${config.author?.value ?? "Generated by Nestia - https://github.com/samchon/nestia"}`,
-      ].join("\n");
-
-  const writeMethodDecorators =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (controller: IHttpMigrateController) =>
-    (route: IHttpMigrateRoute): ts.Decorator[] => {
-      const external =
-        (lib: string) =>
-        (instance: string): ts.Identifier =>
-          ts.factory.createIdentifier(
-            importer.external({
-              type: "instance",
-              library: lib,
-              name: instance,
-            }),
-          );
-
-      // EXAMPLES
-      const decorators: ts.Decorator[] = [];
-      if (route.success)
-        decorators.push(
-          ...writeExampleDecorators("Response")(importer)(
-            route.success.media(),
-          ),
-        );
-
-      // HUMAN-ONLY
-      if (route.operation()["x-samchon-human"] === true)
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestia/core")("HumanRoute"),
-              undefined,
-              undefined,
-            ),
-          ),
-        );
-
-      // ROUTER
-      const localPath: string = route.emendedPath
-        .slice(controller.path.length)
-        .split("/")
-        .filter((str) => !!str.length)
-        .join("/");
-      const router = (instance: string) =>
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              external("@nestia/core")(instance),
-              StringUtil.capitalize(route.method),
-            ),
-            [],
-            localPath.length
-              ? [ts.factory.createStringLiteral(localPath)]
-              : undefined,
-          ),
-        );
-      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.method === "head")
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestjs/common")("Head"),
-              [],
-              [ts.factory.createStringLiteral(route.path)],
-            ),
-          ),
-        );
-      else if (
-        route.success === null ||
-        route.success?.type === "application/json"
-      )
-        decorators.push(router("TypedRoute"));
-      for (const [key, value] of Object.entries(route.exceptions ?? {}))
-        decorators.push(
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              external("@nestia/core")("TypedException"),
-              [
-                MigrateSchemaProgrammer.write(components)(importer)(
-                  value.schema,
-                ),
-              ],
-              [
-                isNaN(Number(key))
-                  ? ts.factory.createStringLiteral(key)
-                  : ExpressionFactory.number(Number(key)),
-                ...(value.response().description?.length
-                  ? [
-                      ts.factory.createStringLiteral(
-                        value.response().description!,
-                      ),
-                    ]
-                  : []),
-              ],
-            ),
-          ),
-        );
-      return decorators;
-    };
-
-  const writeParameters =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.ParameterDeclaration[] => [
-      ...route.parameters.map((p) =>
-        ts.factory.createParameterDeclaration(
-          [
-            ...writeExampleDecorators("Parameter")(importer)(p.parameter()),
-            ts.factory.createDecorator(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                  importer.external({
-                    type: "instance",
-                    library: "@nestia/core",
-                    name: "TypedParam",
-                  }),
-                ),
-                undefined,
-                [ts.factory.createStringLiteral(p.key)],
-              ),
-            ),
-          ],
-          undefined,
-          p.key,
-          undefined,
-          MigrateSchemaProgrammer.write(components)(importer)(p.schema),
-        ),
-      ),
-      ...(route.headers
-        ? [
-            writeDtoParameter({
-              method: "TypedHeaders",
-              variable: "headers",
-              arguments: [],
-            })(components)(importer)({
-              required: true,
-              schema: route.headers.schema,
-              example: route.headers.example(),
-              examples: route.headers.examples(),
-            }),
-          ]
-        : []),
-      ...(route.query
-        ? [
-            writeDtoParameter({
-              method: "TypedQuery",
-              variable: "query",
-              arguments: [],
-            })(components)(importer)({
-              required: true,
-              schema: route.query.schema,
-              example: route.query.example(),
-              examples: route.query.examples(),
-            }),
-          ]
-        : []),
-      ...(route.body
-        ? [
-            writeDtoParameter({
-              method: route.body["x-nestia-encrypted"]
-                ? "EncryptedBody"
-                : route.body.type === "application/json"
-                  ? "TypedBody"
-                  : route.body.type === "application/x-www-form-urlencoded"
-                    ? ["TypedQuery", "Body"]
-                    : route.body.type === "text/plain"
-                      ? "PlainBody"
-                      : route.body.type === "multipart/form-data"
-                        ? ["TypedFormData", "Body"]
-                        : "TypedBody",
-              variable: "body",
-              arguments:
-                route.body.type === "multipart/form-data"
-                  ? [
-                      ts.factory.createArrowFunction(
-                        undefined,
-                        undefined,
-                        [],
-                        undefined,
-                        undefined,
-                        ts.factory.createCallExpression(
-                          ts.factory.createIdentifier(
-                            importer.external({
-                              type: "default",
-                              library: "multer",
-                              name: "Multer",
-                            }),
-                          ),
-                          undefined,
-                          undefined,
-                        ),
-                      ),
-                    ]
-                  : [],
-            })(components)(importer)({
-              schema: route.body.schema,
-              required: !(
-                (route.body.type === "application/json" ||
-                  route.body.type === "text/plain") &&
-                route.operation().requestBody?.required === false
-              ),
-              example: route.body.media().example,
-              examples: route.body.media().examples,
-            }),
-          ]
-        : []),
-    ];
-
-  const writeDtoParameter =
-    (accessor: {
-      method: string | [string, string];
-      variable: string;
-      arguments: ts.Expression[];
-    }) =>
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (props: {
-      schema: OpenApi.IJsonSchema;
-      required: boolean;
-      example?: any;
-      examples?: Record<string, any>;
-    }): ts.ParameterDeclaration => {
-      const instance = ts.factory.createIdentifier(
-        importer.external({
-          type: "instance",
-          library: "@nestia/core",
-          name:
-            typeof accessor.method === "string"
-              ? accessor.method
-              : accessor.method[0],
-        }),
-      );
-      return ts.factory.createParameterDeclaration(
-        [
-          ...writeExampleDecorators("Parameter")(importer)(props),
-          ts.factory.createDecorator(
-            ts.factory.createCallExpression(
-              typeof accessor.method === "string"
-                ? instance
-                : IdentifierFactory.access(instance, accessor.method[1]),
-              undefined,
-              accessor.arguments,
-            ),
-          ),
-        ],
-        undefined,
-        accessor.variable,
-        props.required === false
-          ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-          : undefined,
-        MigrateSchemaProgrammer.write(components)(importer)(props.schema),
-      );
-    };
-
-  const writeExampleDecorators =
-    (kind: "Response" | "Parameter") =>
-    (importer: MigrateImportProgrammer) =>
-    (media: {
-      example?: any;
-      examples?: Record<string, any>;
-    }): ts.Decorator[] => [
-      ...(media.example !== undefined
-        ? [
-            ts.factory.createDecorator(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createIdentifier(
-                    importer.external({
-                      type: "instance",
-                      library: "@nestia/core",
-                      name: "SwaggerExample",
-                    }),
-                  ),
-                  kind,
-                ),
-                [],
-                [LiteralFactory.write(media.example)],
-              ),
-            ),
-          ]
-        : []),
-      ...Object.entries(media.examples ?? {}).map(([key, value]) =>
-        ts.factory.createDecorator(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              ts.factory.createIdentifier(
-                importer.external({
-                  type: "instance",
-                  library: "@nestia/core",
-                  name: "SwaggerExample",
-                }),
-              ),
-              kind,
-            ),
-            [],
-            [ts.factory.createStringLiteral(key), LiteralFactory.write(value)],
-          ),
-        ),
-      ),
-    ];
-}

package/src/programmers/MigrateNestProgrammer.ts

@@ -1,84 +0,0 @@
-import ts from "typescript";
-
-import { MigrateControllerAnalyzer } from "../analyzers/MigrateControllerAnalyzer";
-import { IHttpMigrateController } from "../structures/IHttpMigrateController";
-import { IHttpMigrateFile } from "../structures/IHttpMigrateFile";
-import { IHttpMigrateProgram } from "../structures/IHttpMigrateProgram";
-import { FilePrinter } from "../utils/FilePrinter";
-import { MigrateDtoProgrammer } from "./MigrateDtoProgrammer";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateNestControllerProgrammer } from "./MigrateNestControllerProgrammer";
-import { MigrateNestModuleProgrammer } from "./MigrateNestModuleProgrammer";
-
-export namespace MigrateNestProgrammer {
-  export const write = (program: IHttpMigrateProgram): IHttpMigrateFile[] => {
-    const controllers: IHttpMigrateController[] =
-      MigrateControllerAnalyzer.analyze({
-        routes: program.routes,
-      });
-    return [
-      {
-        location: "src",
-        file: "MyModule.ts",
-        statements: MigrateNestModuleProgrammer.write(controllers),
-      },
-      ...controllers.map((c) => ({
-        location: c.location,
-        file: `${c.name}.ts`,
-        statements: MigrateNestControllerProgrammer.write(program)(
-          program.document.components,
-        )(c),
-      })),
-      ...[
-        ...MigrateDtoProgrammer.compose(program)(
-          program.document.components,
-        ).entries(),
-      ].map(([key, value]) => ({
-        location: "src/api/structures",
-        file: `${key}.ts`,
-        statements: writeDtoFile(key, value),
-      })),
-    ].map((o) => ({
-      location: o.location,
-      file: o.file,
-      content: FilePrinter.write({ statements: o.statements }),
-    }));
-  };
-
-  const writeDtoFile = (
-    key: string,
-    modulo: MigrateDtoProgrammer.IModule,
-  ): ts.Statement[] => {
-    const importer = new MigrateImportProgrammer();
-    const statements: ts.Statement[] = iterate(importer)(modulo);
-    if (statements.length === 0) return [];
-
-    return [
-      ...importer.toStatements((name) => `./${name}`, key),
-      ...(importer.empty() ? [] : [FilePrinter.newLine()]),
-      ...statements,
-    ];
-  };
-
-  const iterate =
-    (importer: MigrateImportProgrammer) =>
-    (modulo: MigrateDtoProgrammer.IModule): ts.Statement[] => {
-      const output: ts.Statement[] = [];
-      if (modulo.programmer !== null) output.push(modulo.programmer(importer));
-      if (modulo.children.size) {
-        const internal: ts.Statement[] = [];
-        for (const child of modulo.children.values())
-          internal.push(...iterate(importer)(child));
-        output.push(
-          ts.factory.createModuleDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            ts.factory.createIdentifier(modulo.name),
-            ts.factory.createModuleBlock(internal),
-            ts.NodeFlags.Namespace,
-          ),
-        );
-      }
-      output.push(FilePrinter.newLine());
-      return output;
-    };
-}