@nestia/sdk 3.0.0-dev.20231209 → 3.0.0-dev.20240412

package/src/generates/internal/SdkRouteProgrammer.ts

@@ -0,0 +1,83 @@
+import ts from "typescript";
+import { IJsDocTagInfo } from "typia";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { FilePrinter } from "./FilePrinter";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkFunctionProgrammer } from "./SdkFunctionProgrammer";
+import { SdkNamespaceProgrammer } from "./SdkNamespaceProgrammer";
+
+export namespace SdkRouteProgrammer {
+  export const generate =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.Statement[] => {
+      const props = {
+        headers: route.parameters.find(
+          (p) => p.category === "headers" && p.field === undefined,
+        ),
+        query: route.parameters.find(
+          (p) => p.category === "query" && p.field === undefined,
+        ),
+        input: route.parameters.find((p) => p.category === "body"),
+      };
+      return [
+        FilePrinter.description(
+          SdkFunctionProgrammer.write(config)(importer)(route, props),
+          describe(route),
+        ),
+        SdkNamespaceProgrammer.write(checker)(config)(importer)(route, props),
+      ];
+    };
+
+  const describe = (route: IRoute): string => {
+    // MAIN DESCRIPTION
+    const comments: string[] = route.description
+      ? route.description.split("\n")
+      : [];
+
+    // COMMENT TAGS
+    const tags: IJsDocTagInfo[] = route.jsDocTags.filter(
+      (tag) =>
+        tag.name !== "param" ||
+        route.parameters
+          .filter((p) => p.category !== "headers")
+          .some((p) => p.name === tag.text?.[0]?.text),
+    );
+    if (tags.length !== 0) {
+      const content: string[] = tags.map((t) =>
+        t.text?.length
+          ? `@${t.name} ${t.text.map((e) => e.text).join("")}`
+          : `@${t.name}`,
+      );
+      comments.push("", ...new Set(content));
+    }
+
+    // EXCEPTIONS
+    for (const [key, value] of Object.entries(route.exceptions)) {
+      if (
+        comments.some(
+          (str) =>
+            str.startsWith(`@throw ${key}`) || str.startsWith(`@throws ${key}`),
+        )
+      )
+        continue;
+      comments.push(
+        value.description?.length
+          ? `@throws ${key} ${value.description.split("\n")[0]}`
+          : `@throws ${key}`,
+      );
+    }
+
+    // POSTFIX
+    if (!!comments.length) comments.push("");
+    comments.push(
+      `@controller ${route.target.class.name}.${route.target.function.name}`,
+      `@path ${route.method} ${route.path}`,
+      `@nestia Generated by Nestia - https://github.com/samchon/nestia`,
+    );
+    return comments.join("\n");
+  };
+}

package/src/generates/internal/SdkSimulationProgrammer.ts

@@ -1,133 +1,365 @@
-import { INestiaConfig } from "../../INestiaConfig";
-import { IRoute } from "../../structures/IRoute";
-import { ImportDictionary } from "../../utils/ImportDictionary";
-import { SdkImportWizard } from "./SdkImportWizard";
-import { SdkTypeDefiner } from "./SdkTypeDefiner";
-
-export namespace SdkSimulationProgrammer {
-  export const generate =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): string => {
-      const output: boolean =
-        config.propagate === true || route.output.typeName !== "void";
-      const body: string[] = [
-        ...(route.parameters.filter((p) => p.category !== "headers").length !==
-        0
-          ? assert(config)(importer)(route)
-          : []),
-        ...(output ? returns(config)(route) : []),
-      ];
-      return [
-        `export const simulate = async (`,
-        `    ${
-          route.parameters.filter((p) => p.category !== "headers").length ===
-            0 && route.output.typeName === "void"
-            ? "_connection"
-            : "connection"
-        }: ${
-          route.parameters.some(
-            (p) => p.category === "headers" && p.field === undefined,
-          )
-            ? `${SdkImportWizard.IConnection(importer)}<${route.name}.Headers>`
-            : SdkImportWizard.IConnection(importer)
-        },`,
-        ...route.parameters
-          .filter((p) => p.category !== "headers")
-          .map(
-            (p) =>
-              `    ${p.name}: ${
-                p.category === "query" || p.category === "body"
-                  ? `${route.name}.${
-                      p.category === "query" ? "Query" : "Input"
-                    }`
-                  : SdkTypeDefiner.name(config)(importer)(p)
-              },`,
-          ),
-        `): Promise<${output ? "Output" : "void"}> => {`,
-        ...body.map((l) => `    ${l}`),
-        `}`,
-      ]
-        .map((line) => `    ${line}`)
-        .join("\n");
-    };
-
-  const assert =
-    (config: INestiaConfig) =>
-    (importer: ImportDictionary) =>
-    (route: IRoute): string[] => {
-      const typia = SdkImportWizard.typia(importer);
-      const func: string[] = [
-        `const assert = ${importer.internal({
-          file: `${config.output}/utils/NestiaSimulator.ts`,
-          instance: "NestiaSimulator",
-          type: false,
-        })}.assert({`,
-        `    method: METADATA.method,`,
-        `    host: connection.host,`,
-        `    path: path(${route.parameters
-          .filter((p) => p.category === "param" || p.category === "query")
-          .map((p) => p.name)
-          .join(", ")}),`,
-        `    contentType: ${JSON.stringify(route.output.contentType)},`,
-        `});`,
-      ];
-      const individual: string[] = route.parameters
-        .filter((p) => p.category !== "headers")
-        .map((p) =>
-          p.category === "body"
-            ? `assert.body(() => ${typia}.assert(${p.name}));`
-            : p.category === "query"
-            ? `assert.query(() => ${typia}.assert(${p.name}));`
-            : p.category === "headers"
-            ? `assert.headers(() => ${typia}.assert(connection.headers);`
-            : `assert.param("${p.field}")(() => ${typia}.assert(${p.name}));`,
-        );
-      if (config.propagate !== true) return [...func, ...individual];
-
-      return [
-        ...func,
-        `try {`,
-        ...individual.map((l) => `    ${l}`),
-        `} catch (exp) {`,
-        `    if (!${typia}.is<${SdkImportWizard.HttpError(
-          importer,
-        )}>(exp)) throw exp;`,
-        `    return {`,
-        `        success: false,`,
-        `        status: exp.status,`,
-        `        headers: exp.headers,`,
-        `        data: exp.toJSON().message,`,
-        `    } as any;`,
-        `}`,
-      ];
-    };
-
-  const returns =
-    (config: INestiaConfig) =>
-    (route: IRoute): string[] => {
-      const random = (prefix: string, postfix: string) =>
-        route.output.typeName === "void"
-          ? [`${prefix} undefined${postfix}`]
-          : [
-              `${prefix} random(`,
-              `    typeof connection.simulate === 'object' &&`,
-              `        connection.simulate !== null`,
-              `        ? connection.simulate`,
-              `        : undefined`,
-              `)${postfix}`,
-            ];
-      if (config.propagate !== true) return random("return", ";");
-
-      return [
-        `return {`,
-        `    success: true,`,
-        `    status: ${route.status ?? (route.method === "POST" ? 201 : 200)},`,
-        `    headers: {`,
-        `        "Content-Type": "${route.output.contentType}",`,
-        `    },`,
-        ...random("data:", ",").map((r) => `    ${r}`),
-        `}`,
-      ];
-    };
-}
+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 { StatementFactory } from "typia/lib/factories/StatementFactory";
+import { TypeFactory } from "typia/lib/factories/TypeFactory";
+
+import { INestiaConfig } from "../../INestiaConfig";
+import { IRoute } from "../../structures/IRoute";
+import { ImportDictionary } from "./ImportDictionary";
+import { SdkAliasCollection } from "./SdkAliasCollection";
+import { SdkImportWizard } from "./SdkImportWizard";
+import { SdkTypeProgrammer } from "./SdkTypeProgrammer";
+
+export namespace SdkSimulationProgrammer {
+  export const random =
+    (checker: ts.TypeChecker) =>
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.VariableStatement => {
+      const output =
+        SdkAliasCollection.responseBody(checker)(config)(importer)(route);
+      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(
+                    `${SdkImportWizard.typia(importer)}.IRandomGenerator`,
+                  ),
+                ],
+              ),
+            ),
+          ],
+          config.primitive === false
+            ? output
+            : ts.factory.createTypeReferenceNode(
+                SdkImportWizard.Resolved(importer),
+                [output],
+              ),
+          undefined,
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createIdentifier(SdkImportWizard.typia(importer)),
+            )("random"),
+            [output],
+            [ts.factory.createIdentifier("g")],
+          ),
+        ),
+      );
+    };
+
+  export const simulate =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (
+      route: IRoute,
+      props: {
+        headers: IRoute.IParameter | undefined;
+        query: IRoute.IParameter | undefined;
+        input: IRoute.IParameter | undefined;
+      },
+    ): ts.VariableStatement => {
+      const output: boolean =
+        config.propagate === true || route.output.typeName !== "void";
+      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,
+          [
+            IdentifierFactory.parameter(
+              "connection",
+              ts.factory.createTypeReferenceNode(
+                SdkImportWizard.IConnection(importer),
+                route.parameters.some(
+                  (p) => p.category === "headers" && p.field === undefined,
+                )
+                  ? [
+                      ts.factory.createTypeReferenceNode(
+                        `${route.name}.Headers`,
+                      ),
+                    ]
+                  : [],
+              ),
+            ),
+            ...route.parameters
+              .filter((p) => p.category !== "headers")
+              .map((p) =>
+                ts.factory.createParameterDeclaration(
+                  [],
+                  undefined,
+                  p.name,
+                  p.optional
+                    ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                    : undefined,
+                  config.primitive !== false &&
+                    (p === props.query || p === props.input)
+                    ? ts.factory.createTypeReferenceNode(
+                        `${route.name}.${p === props.query ? "Query" : "Input"}`,
+                      )
+                    : getTypeName(config)(importer)(p),
+                ),
+              ),
+          ],
+          ts.factory.createTypeReferenceNode(output ? "Output" : "void"),
+          undefined,
+          ts.factory.createBlock(
+            [
+              ...assert(config)(importer)(route),
+              ts.factory.createReturnStatement(
+                config.propagate
+                  ? ts.factory.createObjectLiteralExpression(
+                      [
+                        ts.factory.createPropertyAssignment(
+                          "success",
+                          ts.factory.createTrue(),
+                        ),
+                        ts.factory.createPropertyAssignment(
+                          "status",
+                          ExpressionFactory.number(
+                            route.status ??
+                              (route.method === "POST" ? 201 : 200),
+                          ),
+                        ),
+                        ts.factory.createPropertyAssignment(
+                          "headers",
+                          LiteralFactory.generate({
+                            "Content-Type": route.output.contentType,
+                          }),
+                        ),
+                        ts.factory.createPropertyAssignment("data", caller()),
+                      ],
+                      true,
+                    )
+                  : caller(),
+              ),
+            ],
+            true,
+          ),
+        ),
+      );
+    };
+
+  const assert =
+    (config: INestiaConfig) =>
+    (importer: ImportDictionary) =>
+    (route: IRoute): ts.Statement[] => {
+      const parameters = route.parameters.filter(
+        (p) => p.category !== "headers",
+      );
+      if (parameters.length === 0) return [];
+
+      const typia = SdkImportWizard.typia(importer);
+      const validator = StatementFactory.constant(
+        "assert",
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createIdentifier(
+              importer.external({
+                type: false,
+                library: `@nestia/fetcher/lib/NestiaSimulator`,
+                instance: "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",
+                  ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("path"),
+                    undefined,
+                    route.parameters
+                      .filter(
+                        (p) => p.category === "param" || p.category === "query",
+                      )
+                      .map((p) => ts.factory.createIdentifier(p.name)),
+                  ),
+                ),
+                ts.factory.createPropertyAssignment(
+                  "contentType",
+                  ts.factory.createIdentifier(
+                    JSON.stringify(route.output.contentType),
+                  ),
+                ),
+              ],
+              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(typia))(
+                    "assert",
+                  ),
+                  undefined,
+                  [
+                    ts.factory.createIdentifier(
+                      p.category === "headers" ? "connection.headers" : p.name,
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        )
+        .map(ts.factory.createExpressionStatement);
+
+      return [
+        validator,
+        ...(config.propagate !== true
+          ? individual
+          : [tryAndCatch(importer)(individual)]),
+      ];
+    };
+
+  const tryAndCatch =
+    (importer: ImportDictionary) => (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(
+                        SdkImportWizard.typia(importer),
+                      ),
+                    )("is"),
+                    [
+                      ts.factory.createTypeReferenceNode(
+                        SdkImportWizard.HttpError(importer),
+                      ),
+                    ],
+                    [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,
+    ),
+  );
+
+const getTypeName =
+  (config: INestiaConfig) =>
+  (importer: ImportDictionary) =>
+  (p: IRoute.IParameter | IRoute.IOutput) =>
+    p.metadata
+      ? SdkTypeProgrammer.write(config)(importer)(p.metadata)
+      : ts.factory.createTypeReferenceNode(p.typeName);