@nestia/migrate 6.0.5 → 7.0.0-dev.20250605

package/src/programmers/MigrateApiNamespaceProgrammer.ts

@@ -1,418 +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 { IHttpMigrateProgram } from "../structures/IHttpMigrateProgram";
-import { IHttpMigrateRoute } from "../structures/IHttpMigrateRoute";
-import { FilePrinter } from "../utils/FilePrinter";
-import { MigrateApiSimulationProgrammer } from "./MigrateApiSimulationProgrammer";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-import { MigrateSchemaProgrammer } from "./MigrateSchemaProgrammer";
-
-export namespace MigrateApiNamespaceProgrammer {
-  export const write =
-    (config: IHttpMigrateProgram.IConfig) =>
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.ModuleDeclaration => {
-      const types = writeTypes(components)(importer)(route);
-      return ts.factory.createModuleDeclaration(
-        [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
-        ts.factory.createIdentifier(route.accessor.at(-1)!),
-        ts.factory.createModuleBlock([
-          ...types,
-          ...(types.length ? [FilePrinter.newLine()] : []),
-          writeMetadata(components)(importer)(route),
-          FilePrinter.newLine(),
-          writePath(components)(importer)(route),
-          ...(config.simulate
-            ? [
-                MigrateApiSimulationProgrammer.random(components)(importer)(
-                  route,
-                ),
-                MigrateApiSimulationProgrammer.simulate(components)(importer)(
-                  route,
-                ),
-              ]
-            : []),
-        ]),
-        ts.NodeFlags.Namespace,
-      );
-    };
-
-  export const writePathCallExpression = (route: IHttpMigrateRoute) =>
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier(`${route.accessor.at(-1)!}.path`),
-      undefined,
-      [
-        ...route.parameters.map((p) => ts.factory.createIdentifier(p.key)),
-        ...(route.query ? [ts.factory.createIdentifier(route.query.key)] : []),
-      ],
-    );
-
-  const writeTypes =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.TypeAliasDeclaration[] => {
-      const array: ts.TypeAliasDeclaration[] = [];
-      const declare = (name: string, type: ts.TypeNode) =>
-        array.push(
-          ts.factory.createTypeAliasDeclaration(
-            [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            name,
-            undefined,
-            type,
-          ),
-        );
-      if (route.headers)
-        declare(
-          "Headers",
-          MigrateSchemaProgrammer.write(components)(importer)(
-            route.headers.schema,
-          ),
-        );
-      if (route.query)
-        declare(
-          "Query",
-          MigrateSchemaProgrammer.write(components)(importer)(
-            route.query.schema,
-          ),
-        );
-      if (route.body)
-        declare(
-          "Input",
-          MigrateSchemaProgrammer.write(components)(importer)(
-            route.body.schema,
-          ),
-        );
-      if (route.success)
-        declare(
-          "Output",
-          MigrateSchemaProgrammer.write(components)(importer)(
-            route.success.schema,
-          ),
-        );
-      return array;
-    };
-
-  const writeMetadata =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.VariableStatement =>
-      constant("METADATA")(
-        ts.factory.createAsExpression(
-          ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createPropertyAssignment(
-                "method",
-                ts.factory.createStringLiteral(route.method.toUpperCase()),
-              ),
-              ts.factory.createPropertyAssignment(
-                "path",
-                ts.factory.createStringLiteral(getPath(route)),
-              ),
-              ts.factory.createPropertyAssignment(
-                "request",
-                route.body
-                  ? LiteralFactory.write({
-                      type: route.body.type,
-                      encrypted: !!route.body["x-nestia-encrypted"],
-                    })
-                  : ts.factory.createNull(),
-              ),
-              ts.factory.createPropertyAssignment(
-                "response",
-                route.method.toUpperCase() !== "HEAD"
-                  ? LiteralFactory.write({
-                      type: route.success?.type ?? "application/json",
-                      encrypted: !!route.success?.["x-nestia-encrypted"],
-                    })
-                  : ts.factory.createNull(),
-              ),
-              ...(route.success?.type === "application/x-www-form-urlencoded"
-                ? [
-                    ts.factory.createPropertyAssignment(
-                      "parseQuery",
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(
-                          `${importer.external({
-                            type: "default",
-                            library: "typia",
-                            name: "typia",
-                          })}.http.createAssertQuery`,
-                        ),
-                        [
-                          MigrateSchemaProgrammer.write(components)(importer)(
-                            route.success.schema,
-                          ),
-                        ],
-                        undefined,
-                      ),
-                    ),
-                  ]
-                : []),
-            ],
-            true,
-          ),
-          ts.factory.createTypeReferenceNode(
-            ts.factory.createIdentifier("const"),
-          ),
-        ),
-      );
-
-  const writePath =
-    (components: OpenApi.IComponents) =>
-    (importer: MigrateImportProgrammer) =>
-    (route: IHttpMigrateRoute): ts.VariableStatement => {
-      const out = (body: ts.ConciseBody) =>
-        constant("path")(
-          ts.factory.createArrowFunction(
-            [],
-            [],
-            [
-              ...route.parameters.map((p) =>
-                IdentifierFactory.parameter(
-                  p.key,
-                  MigrateSchemaProgrammer.write(components)(importer)(p.schema),
-                ),
-              ),
-              ...(route.query
-                ? [
-                    IdentifierFactory.parameter(
-                      route.query.key,
-                      ts.factory.createTypeReferenceNode(
-                        `${route.accessor.at(-1)!}.Query`,
-                      ),
-                    ),
-                  ]
-                : []),
-            ],
-            undefined,
-            undefined,
-            body,
-          ),
-        );
-      const template = () => {
-        const path: string = getPath(route);
-        const split: string[] = path.split(":");
-        if (split.length === 1) return ts.factory.createStringLiteral(path);
-        return ts.factory.createTemplateExpression(
-          ts.factory.createTemplateHead(split[0]),
-          split.slice(1).map((s, i, arr) => {
-            const name: string = s.split("/")[0];
-            return ts.factory.createTemplateSpan(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("encodeURIComponent"),
-                undefined,
-                [
-                  ts.factory.createBinaryExpression(
-                    ts.factory.createIdentifier(
-                      route.parameters.find((p) => p.name === name)!.key,
-                    ),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-                    ts.factory.createStringLiteral("null"),
-                  ),
-                ],
-              ),
-              (i !== arr.length - 1
-                ? ts.factory.createTemplateMiddle
-                : ts.factory.createTemplateTail)(s.substring(name.length)),
-            );
-          }),
-        );
-      };
-      if (!route.query) return out(template());
-
-      const computeName = (str: string): string =>
-        route.parameters.find((p) => p.key === str) !== undefined
-          ? computeName("_" + str)
-          : str;
-      const variables: string = computeName("variables");
-      return out(
-        ts.factory.createBlock(
-          [
-            local(variables)("URLSearchParams")(
-              ts.factory.createNewExpression(
-                ts.factory.createIdentifier("URLSearchParams"),
-                [],
-                [],
-              ),
-            ),
-            ts.factory.createForOfStatement(
-              undefined,
-              ts.factory.createVariableDeclarationList(
-                [
-                  ts.factory.createVariableDeclaration(
-                    ts.factory.createArrayBindingPattern([
-                      ts.factory.createBindingElement(
-                        undefined,
-                        undefined,
-                        ts.factory.createIdentifier("key"),
-                        undefined,
-                      ),
-                      ts.factory.createBindingElement(
-                        undefined,
-                        undefined,
-                        ts.factory.createIdentifier("value"),
-                        undefined,
-                      ),
-                    ]),
-                    undefined,
-                    undefined,
-                    undefined,
-                  ),
-                ],
-                ts.NodeFlags.Const,
-              ),
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.entries"),
-                undefined,
-                [
-                  ts.factory.createAsExpression(
-                    ts.factory.createIdentifier(route.query.key),
-                    TypeFactory.keyword("any"),
-                  ),
-                ],
-              ),
-              ts.factory.createIfStatement(
-                ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("undefined"),
-                  ts.factory.createIdentifier("value"),
-                ),
-                ts.factory.createContinueStatement(),
-                ts.factory.createIfStatement(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Array.isArray"),
-                    undefined,
-                    [ts.factory.createIdentifier("value")],
-                  ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("value"),
-                        ts.factory.createIdentifier("forEach"),
-                      ),
-                      undefined,
-                      [
-                        ts.factory.createArrowFunction(
-                          undefined,
-                          undefined,
-                          [IdentifierFactory.parameter("elem")],
-                          undefined,
-                          undefined,
-                          ts.factory.createCallExpression(
-                            IdentifierFactory.access(
-                              ts.factory.createIdentifier(variables),
-                              "append",
-                            ),
-                            undefined,
-                            [
-                              ts.factory.createIdentifier("key"),
-                              ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("String"),
-                                undefined,
-                                [ts.factory.createIdentifier("elem")],
-                              ),
-                            ],
-                          ),
-                        ),
-                      ],
-                    ),
-                  ),
-                  ts.factory.createExpressionStatement(
-                    ts.factory.createCallExpression(
-                      IdentifierFactory.access(
-                        ts.factory.createIdentifier(variables),
-                        "set",
-                      ),
-                      undefined,
-                      [
-                        ts.factory.createIdentifier("key"),
-                        ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("String"),
-                          undefined,
-                          [ts.factory.createIdentifier("value")],
-                        ),
-                      ],
-                    ),
-                  ),
-                ),
-              ),
-            ),
-            local("location")("string")(template()),
-            ts.factory.createReturnStatement(
-              ts.factory.createConditionalExpression(
-                ts.factory.createStrictEquality(
-                  ExpressionFactory.number(0),
-                  IdentifierFactory.access(
-                    ts.factory.createIdentifier(variables),
-                    "size",
-                  ),
-                ),
-                undefined,
-                ts.factory.createIdentifier("location"),
-                undefined,
-                ts.factory.createTemplateExpression(
-                  ts.factory.createTemplateHead(""),
-                  [
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createIdentifier("location"),
-                      ts.factory.createTemplateMiddle("?"),
-                    ),
-                    ts.factory.createTemplateSpan(
-                      ts.factory.createCallExpression(
-                        IdentifierFactory.access(
-                          ts.factory.createIdentifier(variables),
-                          "toString",
-                        ),
-                        undefined,
-                        undefined,
-                      ),
-                      ts.factory.createTemplateTail(""),
-                    ),
-                  ],
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-}
-
-const constant = (name: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          name,
-          undefined,
-          undefined,
-          expression,
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  );
-const getPath = (route: IHttpMigrateRoute) =>
-  (route.emendedPath.startsWith("/") ? "" : "/") + route.emendedPath;
-const local = (name: string) => (type: string) => (expression: ts.Expression) =>
-  ts.factory.createVariableStatement(
-    [],
-    ts.factory.createVariableDeclarationList(
-      [
-        ts.factory.createVariableDeclaration(
-          name,
-          undefined,
-          ts.factory.createTypeReferenceNode(type),
-          expression,
-        ),
-      ],
-      ts.NodeFlags.Const,
-    ),
-  );

package/src/programmers/MigrateApiProgrammer.ts

@@ -1,104 +0,0 @@
-import { HashMap, hash } from "tstl";
-import ts from "typescript";
-
-import { IHttpMigrateFile } from "../structures/IHttpMigrateFile";
-import { IHttpMigrateProgram } from "../structures/IHttpMigrateProgram";
-import { FilePrinter } from "../utils/FilePrinter";
-import { MigrateApiFileProgrammer } from "./MigrateApiFileProgrammer";
-import { MigrateDtoProgrammer } from "./MigrateDtoProgrammer";
-import { MigrateImportProgrammer } from "./MigrateImportProgrammer";
-
-export namespace MigrateApiProgrammer {
-  export const write = (program: IHttpMigrateProgram): IHttpMigrateFile[] => {
-    const dict: HashMap<string[], MigrateApiFileProgrammer.IProps> =
-      new HashMap(
-        (x) => hash(x.join(".")),
-        (x, y) => x.length === y.length && x.join(".") === y.join("."),
-      );
-    for (const route of program.routes) {
-      const namespace: string[] = route.accessor.slice(0, -1);
-      let last: MigrateApiFileProgrammer.IProps = dict.take(namespace, () => ({
-        namespace,
-        routes: [],
-        children: new Set(),
-      }));
-      last.routes.push(route);
-      namespace.forEach((_s, i, array) => {
-        const partial: string[] = namespace.slice(0, array.length - i - 1);
-        const props: MigrateApiFileProgrammer.IProps = dict.take(
-          partial,
-          () => ({
-            namespace: partial,
-            children: new Set(),
-            routes: [],
-          }),
-        );
-        props.children.add(last.namespace.at(-1)!);
-        last = props;
-      });
-    }
-
-    // DO GENERATE
-    const output: IHttpMigrateFile[] = [...dict].map(({ second: props }) => ({
-      location: `src/${program.mode === "nest" ? "api/" : ""}functional/${props.namespace.join("/")}`,
-      file: "index.ts",
-      content: FilePrinter.write({
-        statements: MigrateApiFileProgrammer.write(program)(
-          program.document.components,
-        )(props),
-      }),
-    }));
-    if (program.mode === "sdk")
-      output.push(
-        ...[
-          ...MigrateDtoProgrammer.compose(
-            program.document.components,
-          ).entries(),
-        ].map(([key, value]) => ({
-          location: "src/structures",
-          file: `${key}.ts`,
-          content: FilePrinter.write({
-            statements: writeDtoFile(key, value),
-          }),
-        })),
-      );
-    return output;
-  };
-
-  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 !== 0) {
-        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;
-    };
-}