@nestia/migrate 6.0.5 → 7.0.0-dev.20250605

package/src/programmers/MigrateApiSimulationProgrammer.ts

@@ -1,324 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-import { TypeFactory } from "typia/lib/factories/TypeFactory";
-
-import { IHttpMigrateRoute } from "../structures/IHttpMigrateRoute";
-import { MigrateApiFunctionProgrammer } from "./MigrateApiFunctionProgrammer";
-import { MigrateApiNamespaceProgrammer } from "./MigrateApiNamespaceProgrammer";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
-
-export namespace MigrateApiSimulationProgrammer {
-  export const random =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute) => {
-      const output = route.success
-        ? MigrateSchemaProgrammer.write(components)(importer)(
-            route.success.schema,
-          )
-        : TypeFactory.keyword("void");
-      return constant("random")(
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [
-            ts.factory.createParameterDeclaration(
-              undefined,
-              undefined,
-              "g",
-              ts.factory.createToken(ts.SyntaxKind.QuestionToken),
-              ts.factory.createTypeReferenceNode(
-                ts.factory.createIdentifier("Partial"),
-                [
-                  ts.factory.createTypeReferenceNode(
-                    `${importer.external({
-                      type: "default",
-                      library: "typia",
-                      name: "typia",
-                    })}.IRandomGenerator`,
-                  ),
-                ],
-              ),
-            ),
-          ],
-          output,
-          undefined,
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              ts.factory.createIdentifier(
-                importer.external({
-                  type: "default",
-                  library: "typia",
-                  name: "typia",
-                }),
-              ),
-              "random",
-            ),
-            [output],
-            [ts.factory.createIdentifier("g")],
-          ),
-        ),
-      );
-    };
-
-  export const simulate =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.VariableStatement => {
-      const caller = () =>
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("random"),
-          undefined,
-          [
-            ts.factory.createConditionalExpression(
-              ts.factory.createLogicalAnd(
-                ts.factory.createStrictEquality(
-                  ts.factory.createStringLiteral("object"),
-                  ts.factory.createTypeOfExpression(
-                    ts.factory.createIdentifier("connection.simulate"),
-                  ),
-                ),
-                ts.factory.createStrictInequality(
-                  ts.factory.createNull(),
-                  ts.factory.createIdentifier("connection.simulate"),
-                ),
-              ),
-              undefined,
-              ts.factory.createIdentifier("connection.simulate"),
-              undefined,
-              ts.factory.createIdentifier("undefined"),
-            ),
-          ],
-        );
-      return constant("simulate")(
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          MigrateApiFunctionProgrammer.writeParameterDeclarations(components)(
-            importer,
-          )(route),
-          ts.factory.createTypeReferenceNode(route.success ? "Output" : "void"),
-          undefined,
-          ts.factory.createBlock(
-            [
-              ...assert(components)(importer)(route),
-              ts.factory.createReturnStatement(caller()),
-            ],
-            true,
-          ),
-        ),
-      );
-    };
-
-  const assert =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.Statement[] => {
-      const parameters = [
-        ...route.parameters.map((p) => ({
-          category: "param",
-          name: p.key,
-          schema: MigrateSchemaProgrammer.write(components)(importer)(p.schema),
-        })),
-        ...(route.query
-          ? [
-              {
-                category: "query",
-                name: route.query.key,
-                schema: MigrateSchemaProgrammer.write(components)(importer)(
-                  route.query.schema,
-                ),
-              },
-            ]
-          : []),
-        ...(route.body
-          ? [
-              {
-                category: "body",
-                name: route.body.key,
-                schema: MigrateSchemaProgrammer.write(components)(importer)(
-                  route.body.schema,
-                ),
-              },
-            ]
-          : []),
-      ];
-      if (parameters.length === 0) return [];
-
-      const validator = StatementFactory.constant({
-        name: "assert",
-        value: ts.factory.createCallExpression(
-          IdentifierFactory.access(
-            ts.factory.createIdentifier(
-              importer.external({
-                type: "instance",
-                library: `@nestia/fetcher/lib/NestiaSimulator`,
-                name: "NestiaSimulator",
-              }),
-            ),
-            "assert",
-          ),
-          undefined,
-          [
-            ts.factory.createObjectLiteralExpression(
-              [
-                ts.factory.createPropertyAssignment(
-                  "method",
-                  ts.factory.createIdentifier("METADATA.method"),
-                ),
-                ts.factory.createPropertyAssignment(
-                  "host",
-                  ts.factory.createIdentifier("connection.host"),
-                ),
-                ts.factory.createPropertyAssignment(
-                  "path",
-                  MigrateApiNamespaceProgrammer.writePathCallExpression(route),
-                ),
-                ts.factory.createPropertyAssignment(
-                  "contentType",
-                  ts.factory.createStringLiteral(
-                    route.success?.type ?? "application/json",
-                  ),
-                ),
-              ],
-              true,
-            ),
-          ],
-        ),
-      });
-      const individual = parameters
-        .map((p) =>
-          ts.factory.createCallExpression(
-            (() => {
-              const base = IdentifierFactory.access(
-                ts.factory.createIdentifier("assert"),
-                p.category,
-              );
-              if (p.category !== "param") return base;
-              return ts.factory.createCallExpression(base, undefined, [
-                ts.factory.createStringLiteral(p.name),
-              ]);
-            })(),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [],
-                undefined,
-                undefined,
-                ts.factory.createCallExpression(
-                  IdentifierFactory.access(
-                    ts.factory.createIdentifier(
-                      importer.external({
-                        type: "default",
-                        library: "typia",
-                        name: "typia",
-                      }),
-                    ),
-                    "assert",
-                  ),
-                  undefined,
-                  [
-                    ts.factory.createIdentifier(
-                      p.category === "headers" ? "connection.headers" : p.name,
-                    ),
-                  ],
-                ),
-              ),
-            ],
-          ),
-        )
-        .map(ts.factory.createExpressionStatement);
-      return [validator, tryAndCatch(importer)(individual)];
-    };
-
-  const tryAndCatch =
-    (importer: MigrateImportProgrammer) => (individual: ts.Statement[]) =>
-      ts.factory.createTryStatement(
-        ts.factory.createBlock(individual, true),
-        ts.factory.createCatchClause(
-          "exp",
-          ts.factory.createBlock(
-            [
-              ts.factory.createIfStatement(
-                ts.factory.createLogicalNot(
-                  ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                      ts.factory.createIdentifier(
-                        importer.external({
-                          type: "default",
-                          library: "typia",
-                          name: "typia",
-                        }),
-                      ),
-                      "is",
-                    ),
-                    [
-                      ts.factory.createTypeReferenceNode(
-                        importer.external({
-                          type: "instance",
-                          library: "@nestia/fetcher",
-                          name: "HttpError",
-                        }),
-                      ),
-                    ],
-                    [ts.factory.createIdentifier("exp")],
-                  ),
-                ),
-                ts.factory.createThrowStatement(
-                  ts.factory.createIdentifier("exp"),
-                ),
-              ),
-              ts.factory.createReturnStatement(
-                ts.factory.createAsExpression(
-                  ts.factory.createObjectLiteralExpression(
-                    [
-                      ts.factory.createPropertyAssignment(
-                        "success",
-                        ts.factory.createFalse(),
-                      ),
-                      ts.factory.createPropertyAssignment(
-                        "status",
-                        ts.factory.createIdentifier("exp.status"),
-                      ),
-                      ts.factory.createPropertyAssignment(
-                        "headers",
-                        ts.factory.createIdentifier("exp.headers"),
-                      ),
-                      ts.factory.createPropertyAssignment(
-                        "data",
-                        ts.factory.createIdentifier("exp.toJSON().message"),
-                      ),
-                    ],
-                    true,
-                  ),
-                  TypeFactory.keyword("any"),
-                ),
-              ),
-            ],
-            true,
-          ),
-        ),
-        undefined,
-      );
-}
-
-const constant = (name: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          ts.factory.createIdentifier(name),
-          undefined,
-          undefined,
-          expression,
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  );

package/src/programmers/MigrateApiStartProgrammer.ts

@@ -1,194 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-import { StatementFactory } from "typia/lib/factories/StatementFactory";
-
-import { IHttpMigrateFile } from "../structures/IHttpMigrateFile";
-import { IHttpMigrateProgram } from "../structures/IHttpMigrateProgram";
-import { IHttpMigrateRoute } from "../structures/IHttpMigrateRoute";
-import { FilePrinter } from "../utils/FilePrinter";
-import { MigrateE2eFunctionProgrammer } from "./MigrateE2eFileProgrammer";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-
-export namespace MigrateApiStartProgrammer {
-  export const write = (program: IHttpMigrateProgram): IHttpMigrateFile => {
-    const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
-    const main: ts.VariableStatement = writeMain(program)(program.document)(
-      importer,
-    )(pick(program.routes));
-    const statements: ts.Statement[] = [
-      ...importer.toStatements(
-        (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,
-      ),
-      FilePrinter.newLine(),
-      ts.factory.createImportDeclaration(
-        undefined,
-        ts.factory.createImportClause(
-          false,
-          undefined,
-          ts.factory.createNamedImports([
-            ts.factory.createImportSpecifier(
-              false,
-              undefined,
-              ts.factory.createIdentifier("TestGlobal"),
-            ),
-          ]),
-        ),
-        ts.factory.createStringLiteral("./TestGlobal"),
-        undefined,
-      ),
-      FilePrinter.newLine(),
-      main,
-      ts.factory.createExpressionStatement(writeStarter()),
-    ];
-    return {
-      location: `test`,
-      file: "start.ts",
-      content: FilePrinter.write({ statements }),
-    };
-  };
-
-  const writeMain =
-    (config: IHttpMigrateProgram.IConfig) =>
-    (document: OpenApi.IDocument) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.VariableStatement =>
-      StatementFactory.constant({
-        name: "main",
-        value: ts.factory.createArrowFunction(
-          [ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)],
-          undefined,
-          [],
-          undefined,
-          undefined,
-          ts.factory.createBlock(
-            [
-              writeConnection(config)(document)(importer),
-              ...MigrateE2eFunctionProgrammer.writeBody(document.components)(
-                importer,
-              )(route),
-            ],
-            true,
-          ),
-        ),
-      });
-
-  const writeConnection =
-    (config: IHttpMigrateProgram.IConfig) =>
-    (document: OpenApi.IDocument) =>
-    (importer: MigrateImportProgrammer): ts.VariableStatement =>
-      ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              "connection",
-              undefined,
-              ts.factory.createTypeReferenceNode(
-                ts.factory.createQualifiedName(
-                  ts.factory.createIdentifier(
-                    importer.external({
-                      type: "default",
-                      library: "@ORGANIZATION/PROJECT-api",
-                      name: "api",
-                    }),
-                  ),
-                  ts.factory.createIdentifier("IConnection"),
-                ),
-              ),
-              ts.factory.createObjectLiteralExpression(
-                [
-                  ts.factory.createSpreadAssignment(
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("TestGlobal"),
-                        "connection",
-                      ),
-                      undefined,
-                      undefined,
-                    ),
-                  ),
-                  ...(document.servers?.[0]?.url?.length
-                    ? [
-                        ts.factory.createPropertyAssignment(
-                          "host",
-                          ts.factory.createStringLiteral(
-                            document.servers[0].url,
-                          ),
-                        ),
-                      ]
-                    : []),
-                  ...(config.simulate === true
-                    ? [
-                        ts.factory.createPropertyAssignment(
-                          "simulate",
-                          ts.factory.createTrue(),
-                        ),
-                      ]
-                    : []),
-                ],
-                true,
-              ),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-
-  const writeStarter = (): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("main"),
-          undefined,
-          undefined,
-        ),
-        "catch",
-      ),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [IdentifierFactory.parameter("exp")],
-          undefined,
-          undefined,
-          ts.factory.createBlock(
-            [
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("console"),
-                    "log",
-                  ),
-                  undefined,
-                  [ts.factory.createIdentifier("exp")],
-                ),
-              ),
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("process"),
-                    "exit",
-                  ),
-                  undefined,
-                  [
-                    ts.factory.createPrefixMinus(
-                      ts.factory.createNumericLiteral("1"),
-                    ),
-                  ],
-                ),
-              ),
-            ],
-            true,
-          ),
-        ),
-      ],
-    );
-}
-
-const pick = <T>(array: T[]): T => {
-  const rand: number = Math.random() * array.length;
-  const index: number = Math.min(array.length - 1, Math.floor(rand));
-  return array[index];
-};

package/src/programmers/MigrateDtoProgrammer.ts

@@ -1,87 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import { IPointer } from "tstl";
-import ts from "typescript";
-
-import { FilePrinter } from "../utils/FilePrinter";
-import { MapUtil } from "../utils/MapUtil";
-import { StringUtil } from "../utils/StringUtil";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
-
-export namespace MigrateDtoProgrammer {
-  export interface IModule {
-    name: string;
-    children: Map<string, IModule>;
-    programmer:
-      | null
-      | ((importer: MigrateImportProgrammer) => ts.TypeAliasDeclaration);
-  }
-
-  export const compose = (
-    components: OpenApi.IComponents,
-  ): Map<string, IModule> => {
-    const dict: Map<string, IModule> = new Map();
-    for (const [key, value] of Object.entries(components.schemas ?? {})) {
-      const emendedKey: string = key
-        .split("/")
-        .filter((str) => str.length !== 0)
-        .map(StringUtil.escapeNonVariable)
-        .join("");
-      prepare(dict)(emendedKey)((importer) =>
-        writeAlias(components)(importer)(emendedKey, value),
-      );
-    }
-    return dict;
-  };
-
-  const prepare =
-    (dict: Map<string, IModule>) =>
-    (name: string) =>
-    (
-      programmer: (
-        importer: MigrateImportProgrammer,
-      ) => ts.TypeAliasDeclaration,
-    ) => {
-      const accessors: string[] = name.split(".");
-      const modulo: IPointer<IModule> = { value: null! };
-
-      accessors.forEach((acc, i) => {
-        modulo.value = MapUtil.take(dict)(acc)(() => ({
-          name: acc,
-          children: new Map(),
-          programmer: null,
-        }));
-        if (i === accessors.length - 1) modulo.value.programmer = programmer;
-        dict = modulo.value.children;
-      });
-      return modulo!;
-    };
-
-  const writeAlias =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (key: string, value: OpenApi.IJsonSchema) =>
-      FilePrinter.description(
-        ts.factory.createTypeAliasDeclaration(
-          [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-          key.split(".").at(-1)!,
-          [],
-          MigrateSchemaProgrammer.write(components)(importer)(value),
-        ),
-        writeComment(value),
-      );
-}
-
-const writeComment = (schema: OpenApi.IJsonSchema): string =>
-  [
-    ...(schema.description?.length ? [schema.description] : []),
-    ...(schema.description?.length &&
-    (schema.title !== undefined || schema.deprecated === true)
-      ? [""]
-      : []),
-    ...(schema.title !== undefined ? [`@title ${schema.title}`] : []),
-    ...(schema.deprecated === true ? [`@deprecated`] : []),
-  ]
-    .join("\n")
-    .split("*/")
-    .join("*\\/");