@nestia/migrate 0.6.0 → 0.6.2

package/src/module.ts

@@ -1,4 +1,4 @@
-export * from "./NestiaMigrateApplication";
+export * from "./MigrateApplication";
 
 export * from "./structures/ISwagger";
 export * from "./structures/IMigrateProgram";

package/src/programmers/ApiFileProgrammer.ts

@@ -0,0 +1,51 @@
+import ts from "typescript";
+
+import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { ApiFunctionProgrammer } from "./ApiFunctionProgrammer";
+import { ApiNamespaceProgrammer } from "./ApiNamespaceProgrammer";
+import { ImportProgrammer } from "./ImportProgrammer";
+
+export namespace ApiFileProgrammer {
+  export interface IProps {
+    namespace: string[];
+    entries: IEntry[];
+    children: Set<string>;
+  }
+  export interface IEntry {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+    alias: string;
+  }
+
+  export const write =
+    (components: ISwaggerComponents) =>
+    (props: IProps): ts.Statement[] => {
+      const importer: ImportProgrammer = new ImportProgrammer();
+      const statements: ts.Statement[] = props.entries
+        .map((p) => [
+          ApiFunctionProgrammer.write(components)(importer)(p),
+          ApiNamespaceProgrammer.write(components)(importer)(p),
+        ])
+        .flat();
+      return [
+        ...importer.toStatements(
+          (ref) =>
+            `../${"../".repeat(props.namespace.length)}structures/${ref}`,
+        ),
+        ...[...props.children].map((child) =>
+          ts.factory.createExportDeclaration(
+            undefined,
+            false,
+            ts.factory.createNamespaceExport(
+              ts.factory.createIdentifier(child),
+            ),
+            ts.factory.createStringLiteral(`./${child}`),
+            undefined,
+          ),
+        ),
+        ...statements,
+      ];
+    };
+}

package/src/programmers/ApiFunctionProgrammer.ts

@@ -0,0 +1,177 @@
+import ts from "typescript";
+import { IdentifierFactory } from "typia/lib/factories/IdentifierFactory";
+
+import { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { FilePrinter } from "../utils/FilePrinter";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { SchemaProgrammer } from "./SchemaProgrammer";
+
+export namespace ApiFunctionProgrammer {
+  export interface IProps {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+    alias: string;
+  }
+
+  export const write =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.FunctionDeclaration =>
+      FilePrinter.description(
+        ts.factory.createFunctionDeclaration(
+          [
+            ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+            ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+          ],
+          undefined,
+          props.alias,
+          undefined,
+          writeParameteers(components)(importer)(props),
+          ts.factory.createTypeReferenceNode("Promise", [
+            ts.factory.createTypeReferenceNode(
+              props.route.success === null ? "void" : `${props.alias}.Output`,
+            ),
+          ]),
+          ts.factory.createBlock(writeBody(importer)(props), true),
+        ),
+        writeDescription(props),
+      );
+
+  const writeDescription = (props: IProps): string =>
+    [
+      ...(props.route.description?.length
+        ? [props.route.description.length, ""]
+        : []),
+      ...(props.route.deprecated ? ["@deprecated"] : []),
+      ...props.route.tags.map((value) => `@tag ${value}`),
+      `@controller ${props.controller.name}`,
+      `@path ${props.route.path}`,
+      "@nestia Generated by Nestia - https://github.com/samchon/nestia",
+    ].join("\n");
+
+  const writeParameteers =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.ParameterDeclaration[] => [
+      IdentifierFactory.parameter(
+        "connection",
+        ts.factory.createTypeReferenceNode(
+          importer.external({
+            type: "instance",
+            library: "@nestia/Fetcher",
+            name: "IConnection",
+          }),
+          props.route.headers
+            ? [ts.factory.createTypeReferenceNode(`${props.alias}.Headers`)]
+            : undefined,
+        ),
+      ),
+      ...props.route.parameters.map((p) =>
+        IdentifierFactory.parameter(
+          p.key,
+          SchemaProgrammer.write(components)(importer)(p.schema),
+        ),
+      ),
+      ...(props.route.query
+        ? [
+            IdentifierFactory.parameter(
+              "query",
+              ts.factory.createTypeReferenceNode(`${props.alias}.Query`),
+            ),
+          ]
+        : []),
+      ...(props.route.body
+        ? [
+            IdentifierFactory.parameter(
+              "input",
+              ts.factory.createTypeReferenceNode(`${props.alias}.Input`),
+            ),
+          ]
+        : []),
+    ];
+
+  const writeBody =
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.Statement[] => {
+      const encrypted: boolean = !!props.route.success?.["x-nestia-encrypted"];
+      const contentType: string =
+        props.route.success?.type ?? "application/json";
+      const caller = () =>
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createIdentifier(
+              importer.external({
+                type: "instance",
+                library: `@nestia/fetcher/lib/${encrypted ? "EncryptedFetcher" : "PlainFetcher"}`,
+                name: encrypted ? "EncryptedFetcher" : "PlainFetcher",
+              }),
+            ),
+          )("fetch"),
+          undefined,
+          [
+            contentType
+              ? ts.factory.createObjectLiteralExpression(
+                  [
+                    ts.factory.createSpreadAssignment(
+                      ts.factory.createIdentifier("connection"),
+                    ),
+                    ts.factory.createPropertyAssignment(
+                      "headers",
+                      ts.factory.createObjectLiteralExpression(
+                        [
+                          ts.factory.createSpreadAssignment(
+                            IdentifierFactory.access(
+                              ts.factory.createIdentifier("connection"),
+                            )("headers"),
+                          ),
+                          ts.factory.createPropertyAssignment(
+                            ts.factory.createStringLiteral("Content-Type"),
+                            ts.factory.createStringLiteral(contentType),
+                          ),
+                        ],
+                        true,
+                      ),
+                    ),
+                  ],
+                  true,
+                )
+              : ts.factory.createIdentifier("connection"),
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createSpreadAssignment(
+                  IdentifierFactory.access(
+                    ts.factory.createIdentifier(props.alias),
+                  )("METADATA"),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "path",
+                  ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                      ts.factory.createIdentifier(props.alias),
+                    )("path"),
+                    undefined,
+                    [
+                      ...props.route.parameters.map((p) =>
+                        ts.factory.createIdentifier(p.key),
+                      ),
+                      ...(props.route.query
+                        ? [ts.factory.createIdentifier("query")]
+                        : []),
+                    ],
+                  ),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "status",
+                  ts.factory.createNull(),
+                ),
+              ],
+              true,
+            ),
+            ...(props.route.body ? [ts.factory.createIdentifier("input")] : []),
+          ],
+        );
+      return [ts.factory.createReturnStatement(caller())];
+    };
+}

package/src/programmers/ApiNamespaceProgrammer.ts

@@ -0,0 +1,395 @@
+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 { IMigrateController } from "../structures/IMigrateController";
+import { IMigrateRoute } from "../structures/IMigrateRoute";
+import { ISwaggerComponents } from "../structures/ISwaggerComponents";
+import { FilePrinter } from "../utils/FilePrinter";
+import { ImportProgrammer } from "./ImportProgrammer";
+import { SchemaProgrammer } from "./SchemaProgrammer";
+
+export namespace ApiNamespaceProgrammer {
+  export interface IProps {
+    controller: IMigrateController;
+    route: IMigrateRoute;
+    alias: string;
+  }
+
+  export const write =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.ModuleDeclaration => {
+      const types = writeTypes(components)(importer)(props.route);
+      return ts.factory.createModuleDeclaration(
+        [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createIdentifier(props.alias),
+        ts.factory.createModuleBlock([
+          ...types,
+          ...(types.length ? [FilePrinter.enter()] : []),
+          writeMetadata(components)(importer)(props),
+          FilePrinter.enter(),
+          writePath(components)(importer)(props),
+        ]),
+        ts.NodeFlags.Namespace,
+      );
+    };
+
+  const writeTypes =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (route: IMigrateRoute): 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",
+          SchemaProgrammer.write(components)(importer)(route.headers.schema),
+        );
+      if (route.query)
+        declare(
+          "Query",
+          SchemaProgrammer.write(components)(importer)(route.query.schema),
+        );
+      if (route.body)
+        declare(
+          "Input",
+          SchemaProgrammer.write(components)(importer)(route.body.schema),
+        );
+      if (route.success)
+        declare(
+          "Output",
+          SchemaProgrammer.write(components)(importer)(route.success.schema),
+        );
+      return array;
+    };
+
+  const writeMetadata =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.VariableStatement =>
+      constant("METADATA")(
+        ts.factory.createAsExpression(
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createPropertyAssignment(
+                "method",
+                ts.factory.createStringLiteral(
+                  props.route.method.toUpperCase(),
+                ),
+              ),
+              ts.factory.createPropertyAssignment(
+                "path",
+                ts.factory.createStringLiteral(getPath(props)),
+              ),
+              ts.factory.createPropertyAssignment(
+                "request",
+                props.route.body
+                  ? LiteralFactory.generate({
+                      type: "application/json",
+                      encrypted: !!props.route.body["x-nestia-encrypted"],
+                    })
+                  : ts.factory.createNull(),
+              ),
+              ts.factory.createPropertyAssignment(
+                "response",
+                props.route.method.toUpperCase() !== "HEAD"
+                  ? LiteralFactory.generate({
+                      type: props.route.success?.type ?? "application/json",
+                      encrypted: !!props.route.success?.["x-nestia-encrypted"],
+                    })
+                  : ts.factory.createNull(),
+              ),
+              ...(props.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`,
+                        ),
+                        [
+                          SchemaProgrammer.write(components)(importer)(
+                            props.route.success.schema,
+                          ),
+                        ],
+                        undefined,
+                      ),
+                    ),
+                  ]
+                : []),
+            ],
+            true,
+          ),
+          ts.factory.createTypeReferenceNode(
+            ts.factory.createIdentifier("const"),
+          ),
+        ),
+      );
+
+  const writePath =
+    (components: ISwaggerComponents) =>
+    (importer: ImportProgrammer) =>
+    (props: IProps): ts.VariableStatement => {
+      const out = (body: ts.ConciseBody) =>
+        constant("path")(
+          ts.factory.createArrowFunction(
+            [],
+            [],
+            [
+              ...props.route.parameters.map((p) =>
+                IdentifierFactory.parameter(
+                  p.key,
+                  SchemaProgrammer.write(components)(importer)(p.schema),
+                ),
+              ),
+              ...(props.route.query
+                ? [
+                    IdentifierFactory.parameter(
+                      props.route.query.key,
+                      ts.factory.createTypeReferenceNode(
+                        `${props.alias}.Query`,
+                      ),
+                    ),
+                  ]
+                : []),
+            ],
+            undefined,
+            undefined,
+            body,
+          ),
+        );
+      const template = () => {
+        const path: string = getPath(props);
+        const splitted: string[] = path.split(":");
+        if (splitted.length === 1) return ts.factory.createStringLiteral(path);
+        return ts.factory.createTemplateExpression(
+          ts.factory.createTemplateHead(splitted[0]),
+          splitted.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(
+                      props.route.parameters.find((p) => p.key === 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 (!props.route.query) return out(template());
+
+      const computeName = (str: string): string =>
+        props.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("query"),
+                    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 = (props: ApiNamespaceProgrammer.IProps) =>
+  [...props.controller.path.split("/"), ...props.route.path.split("/")]
+    .filter((str) => !!str.length)
+    .join("/");
+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/ApiProgrammer.ts

@@ -0,0 +1,68 @@
+import { HashMap, IPointer, hash } from "tstl";
+import { Escaper } from "typia/lib/utils/Escaper";
+
+import { IMigrateProgram } from "../module";
+import { IMigrateFile } from "../structures/IMigrateFile";
+import { FilePrinter } from "../utils/FilePrinter";
+import { StringUtil } from "../utils/StringUtil";
+import { ApiFileProgrammer } from "./ApiFileProgrammer";
+
+export namespace ApiProgrammer {
+  export const write = (program: IMigrateProgram): IMigrateFile[] => {
+    const dict: HashMap<string[], ApiFileProgrammer.IProps> = new HashMap(
+      (x) => hash(x.join(".")),
+      (a, b) => a.join(".") === b.join("."),
+    );
+    for (const controller of program.controllers)
+      for (const route of controller.routes) {
+        const namespace: string[] = [
+          ...controller.path.split("/"),
+          ...route.path.split("/"),
+        ]
+          .filter((str) => !!str.length && str[0] !== ":")
+          .map(StringUtil.normalize)
+          .map((str) => (Escaper.variable(str) ? str : `_${str}`));
+        const last: IPointer<ApiFileProgrammer.IProps> = {
+          value: dict.take(namespace, () => ({
+            namespace,
+            children: new Set(),
+            entries: [],
+          })),
+        };
+        last.value.entries.push({
+          controller,
+          route,
+          alias: route.name,
+        });
+        namespace.slice(0, -1).forEach((_i, i, array) => {
+          const partial: string[] = namespace.slice(0, array.length - i);
+          const props: ApiFileProgrammer.IProps = dict.take(partial, () => ({
+            namespace: partial,
+            children: new Set(),
+            entries: [],
+          }));
+          props.children.add(last.value.namespace.at(-1)!);
+          last.value = props;
+        });
+      }
+    for (const { second: props } of dict)
+      props.entries.forEach(
+        (entry, i) =>
+          (entry.alias = StringUtil.escapeDuplicate([
+            ...props.children,
+            ...entry.route.parameters.map((p) => p.key),
+            ...(entry.route.body ? [entry.route.body.key] : []),
+            ...(entry.route.query ? [entry.route.query.key] : []),
+            ...props.entries.filter((_, j) => i !== j).map((e) => e.alias),
+          ])(entry.alias)),
+      );
+
+    return [...dict].map(({ second: props }) => ({
+      location: `src/api/functional/${props.namespace.join("/")}`,
+      file: "index.ts",
+      content: FilePrinter.write({
+        statements: ApiFileProgrammer.write(program.swagger.components)(props),
+      }),
+    }));
+  };
+}