@nestia/migrate 6.0.6 → 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/MigrateE2eFileProgrammer.ts

@@ -1,117 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
-
-import { IHttpMigrateRoute } from "../structures/IHttpMigrateRoute";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
-
-export namespace MigrateE2eFunctionProgrammer {
-  export const write =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.FunctionDeclaration =>
-      ts.factory.createFunctionDeclaration(
-        [
-          ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-          ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
-        ],
-        undefined,
-        ["test", "api", ...route.accessor].join("_"),
-        undefined,
-        [
-          IdentifierFactory.parameter(
-            "connection",
-            ts.factory.createTypeReferenceNode(
-              ts.factory.createQualifiedName(
-                ts.factory.createIdentifier(
-                  importer.external({
-                    type: "default",
-                    library: "@ORGANIZATION/PROJECT-api",
-                    name: "api",
-                  }),
-                ),
-                ts.factory.createIdentifier("IConnection"),
-              ),
-            ),
-          ),
-        ],
-        undefined,
-        ts.factory.createBlock(writeBody(components)(importer)(route), true),
-      );
-
-  export const writeBody =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.Statement[] => [
-      ts.factory.createVariableStatement(
-        [],
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              "output",
-              undefined,
-              route.success
-                ? MigrateSchemaProgrammer.write(components)(importer)(
-                    route.success.schema,
-                  )
-                : undefined,
-              ts.factory.createAwaitExpression(
-                writeCallExpressionn(components)(importer)(route),
-              ),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      ),
-      ts.factory.createExpressionStatement(
-        ts.factory.createCallExpression(
-          ts.factory.createPropertyAccessExpression(
-            ts.factory.createIdentifier(
-              importer.external({
-                type: "default",
-                library: "typia",
-                name: "typia",
-              }),
-            ),
-            "assert",
-          ),
-          undefined,
-          [ts.factory.createIdentifier("output")],
-        ),
-      ),
-    ];
-
-  const writeCallExpressionn =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.CallExpression =>
-      ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier("api.functional"),
-          ts.factory.createIdentifier(route.accessor.join(".")),
-        ),
-        undefined,
-        [
-          ts.factory.createIdentifier("connection"),
-          ...[...route.parameters, route.query!, route.body!]
-            .filter((p) => !!p)
-            .map((p) =>
-              ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier(
-                    importer.external({
-                      type: "default",
-                      library: "typia",
-                      name: "typia",
-                    }),
-                  ),
-                  "random",
-                ),
-                [MigrateSchemaProgrammer.write(components)(importer)(p.schema)],
-                undefined,
-              ),
-            ),
-        ],
-      );
-}

package/src/programmers/MigrateE2eProgrammer.ts

@@ -1,34 +0,0 @@
-import { OpenApi } from "@samchon/openapi";
-import ts from "typescript";
-
-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 MigrateE2eProgrammer {
-  export const write = (program: IHttpMigrateProgram): IHttpMigrateFile[] =>
-    program.routes.map(writeFile(program.document.components));
-
-  const writeFile =
-    (components: OpenApi.IComponents) =>
-    (route: IHttpMigrateRoute): IHttpMigrateFile => {
-      const importer: MigrateImportProgrammer = new MigrateImportProgrammer();
-      const func: ts.FunctionDeclaration =
-        MigrateE2eFunctionProgrammer.write(components)(importer)(route);
-      const statements: ts.Statement[] = [
-        ...importer.toStatements(
-          (name) => `@ORGANIZATION/PROJECT-api/lib/structures/${name}`,
-        ),
-        FilePrinter.newLine(),
-        func,
-      ];
-      return {
-        location: `test/features/api`,
-        file: `${["test", "api", ...route.accessor].join("_")}.ts`,
-        content: FilePrinter.write({ statements }),
-      };
-    };
-}