@nestia/sdk 3.10.0 → 3.11.0-dev.20240812

package/src/NestiaSdkApplication.ts

@@ -1,29 +1,31 @@
-import transform from "@nestia/core/lib/transform";
 import fs from "fs";
 import path from "path";
-import ts from "typescript";
+import { HashSet, Pair, TreeMap } from "tstl";
+import { IMetadataDictionary } from "typia/lib/schemas/metadata/IMetadataDictionary";
 
 import { INestiaConfig } from "./INestiaConfig";
 import { AccessorAnalyzer } from "./analyses/AccessorAnalyzer";
 import { ConfigAnalyzer } from "./analyses/ConfigAnalyzer";
+import { PathAnalyzer } from "./analyses/PathAnalyzer";
 import { ReflectControllerAnalyzer } from "./analyses/ReflectControllerAnalyzer";
-import { TypedControllerAnalyzer } from "./analyses/TypedControllerAnalyzer";
+import { TypedHttpRouteAnalyzer } from "./analyses/TypedHttpRouteAnalyzer";
+import { TypedWebSocketRouteAnalyzer } from "./analyses/TypedWebSocketRouteAnalyzer";
 import { E2eGenerator } from "./generates/E2eGenerator";
 import { OpenAiGenerator } from "./generates/OpenAiGenerator";
 import { SdkGenerator } from "./generates/SdkGenerator";
 import { SwaggerGenerator } from "./generates/SwaggerGenerator";
-import { IErrorReport } from "./structures/IErrorReport";
 import { INestiaProject } from "./structures/INestiaProject";
 import { IReflectController } from "./structures/IReflectController";
+import { IReflectOperationError } from "./structures/IReflectOperationError";
+import { ITypedApplication } from "./structures/ITypedApplication";
 import { ITypedHttpRoute } from "./structures/ITypedHttpRoute";
 import { ITypedWebSocketRoute } from "./structures/ITypedWebSocketRoute";
-import { MapUtil } from "./utils/MapUtil";
+import { IOperationMetadata } from "./transformers/IOperationMetadata";
+import { StringUtil } from "./utils/StringUtil";
+import { VersioningStrategy } from "./utils/VersioningStrategy";
 
 export class NestiaSdkApplication {
-  public constructor(
-    private readonly config: INestiaConfig,
-    private readonly compilerOptions: ts.CompilerOptions,
-  ) {}
+  public constructor(private readonly config: INestiaConfig) {}
 
   public async e2e(): Promise<void> {
     if (!this.config.output)
@@ -49,11 +51,11 @@ export class NestiaSdkApplication {
     await validate("e2e")(this.config.e2e);
 
     print_title("Nestia E2E Generator");
-    await this.generate((project) => async (routes) => {
-      await SdkGenerator.generate(project)(routes);
-      await E2eGenerator.generate(project)(
-        routes.filter((r) => r.protocol === "http") as ITypedHttpRoute[],
-      );
+    await this.generate({
+      generate: async (app) => {
+        await SdkGenerator.generate(app);
+        await E2eGenerator.generate(app);
+      },
     });
   }
 
@@ -71,7 +73,10 @@ export class NestiaSdkApplication {
       );
 
     print_title("Nestia SDK Generator");
-    await this.generate(SdkGenerator.generate);
+    await this.generate({
+      generate: SdkGenerator.generate,
+      validate: SdkGenerator.validate,
+    });
   }
 
   public async swagger(): Promise<void> {
@@ -91,7 +96,9 @@ export class NestiaSdkApplication {
       );
 
     print_title("Nestia Swagger Generator");
-    await this.generate(SwaggerGenerator.generate);
+    await this.generate({
+      generate: SwaggerGenerator.generate,
+    });
   }
 
   public async openai(): Promise<void> {
@@ -111,21 +118,19 @@ export class NestiaSdkApplication {
       );
 
     print_title("Nestia OpenAI Function Calling Schema Generator");
-    await this.generate(OpenAiGenerator.generate);
+    await this.generate({
+      generate: OpenAiGenerator.generate,
+    });
   }
 
-  private async generate(
-    archiver: (
-      project: INestiaProject,
-    ) => (
-      routes: Array<ITypedHttpRoute | ITypedWebSocketRoute>,
-    ) => Promise<void>,
-  ): Promise<void> {
+  private async generate(props: {
+    generate: (app: ITypedApplication) => Promise<void>;
+    validate?: (app: ITypedApplication) => IReflectOperationError[];
+  }): Promise<void> {
     //----
     // ANALYZE REFLECTS
     //----
     const unique: WeakSet<any> = new WeakSet();
-    const controllers: IReflectController[] = [];
     const project: INestiaProject = {
       config: this.config,
       input: await ConfigAnalyzer.input(this.config),
@@ -135,28 +140,36 @@ export class NestiaSdkApplication {
     };
 
     console.log("Analyzing reflections");
-    await turnTransformError(false);
-    for (const include of (await ConfigAnalyzer.input(this.config)).include)
-      controllers.push(
-        ...(await ReflectControllerAnalyzer.analyze(project)(
-          unique,
-          include.file,
-          include.paths,
-          include.controller,
-        )),
-      );
-    await turnTransformError(true);
+    const controllers: IReflectController[] = project.input.controllers
+      .map((c) =>
+        ReflectControllerAnalyzer.analyze({ project, controller: c, unique }),
+      )
+      .filter((c): c is IReflectController => c !== null);
+
+    if (project.warnings.length)
+      report({
+        type: "warning",
+        errors: project.warnings,
+      });
+    if (project.errors.length)
+      return report({
+        type: "error",
+        errors: project.errors,
+      });
 
     const agg: number = (() => {
-      const set: Set<string> = new Set();
-      for (const c of controllers)
-        for (const cPath of c.paths)
-          for (const op of c.operations)
-            for (const fPath of op.paths)
-              set.add(
-                `${op.protocol === "http" ? `${op.method}::` : ""}${cPath}/${fPath}`,
+      const set: HashSet<Pair<string, string>> = new HashSet();
+      for (const controller of controllers)
+        for (const controllerPath of controller.paths)
+          for (const operation of controller.operations)
+            for (const operationPath of operation.paths)
+              set.insert(
+                new Pair(
+                  `${controllerPath}/${operationPath}`,
+                  operation.protocol === "http" ? operation.method : "",
+                ),
               );
-      return set.size;
+      return set.size();
     })();
 
     console.log(`  - controllers: #${controllers.length}`);
@@ -174,82 +187,64 @@ export class NestiaSdkApplication {
     //----
     // ANALYZE TYPESCRIPT CODE
     //----
-    console.log("Analyzing source codes");
-
-    const program: ts.Program = ts.createProgram(
-      controllers.map((c) => c.file),
-      this.compilerOptions,
-    );
-    project.checker = program.getTypeChecker();
-
-    const diagnostics: ts.Diagnostic[] = [];
-    ts.transform(
-      program
-        .getSourceFiles()
-        .filter((file) => false === file.isDeclarationFile),
-      [
-        transform(
-          program,
-          ((this.compilerOptions.plugins as any) ?? []).find(
-            (p: any) => p.transform === "@nestia/core/lib/transform",
-          ) ?? {},
-          {
-            addDiagnostic: (diag) => diagnostics.push(diag),
-          },
-        ),
-      ],
-      program.getCompilerOptions(),
-    );
-
-    const routeList: Array<ITypedHttpRoute | ITypedWebSocketRoute> = [];
-    for (const c of controllers) {
-      const file: ts.SourceFile | undefined = program.getSourceFile(c.file);
-      if (file === undefined) continue;
-      routeList.push(
-        ...(await TypedControllerAnalyzer.analyze(project)(file, c)),
-      );
-    }
-
-    // TRACE ERRORS
-    for (const diag of diagnostics) {
-      const file: string = diag.file
-        ? path.relative(diag.file.fileName, process.cwd())
-        : "(unknown file)";
-      const category: string =
-        diag.category === ts.DiagnosticCategory.Warning
-          ? "warning"
-          : diag.category === ts.DiagnosticCategory.Error
-            ? "error"
-            : diag.category === ts.DiagnosticCategory.Suggestion
-              ? "suggestion"
-              : diag.category === ts.DiagnosticCategory.Message
-                ? "message"
-                : "unkown";
-      const [line, pos] = diag.file
-        ? (() => {
-            const lines: string[] = diag
-              .file!.text.substring(0, diag.start)
-              .split("\n");
-            if (lines.length === 0) return [0, 0];
-            return [lines.length, lines.at(-1)!.length + 1];
-          })()
-        : [0, 0];
-      console.error(
-        `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
-      );
-    }
-    if (diagnostics.length) process.exit(-1);
-
-    // REPORT ERRORS
-    if (project.errors.length) {
-      report_errors("error")(project.errors);
-      process.exit(-1);
-    }
-    if (project.warnings.length) report_errors("warning")(project.warnings);
-
-    // DO GENERATE
-    AccessorAnalyzer.analyze(routeList);
-    await archiver(project)(routeList);
+    console.log("Analyzing soure codes");
+
+    // METADATA COMPONENTS
+    const collection: IMetadataDictionary =
+      TypedHttpRouteAnalyzer.dictionary(controllers);
+
+    // CONVERT TO TYPED OPERATIONS
+    const globalPrefix: string = project.input.globalPrefix?.prefix ?? "";
+    const routes: Array<ITypedHttpRoute | ITypedWebSocketRoute> = [];
+    for (const c of controllers)
+      for (const o of c.operations) {
+        const pathList: Set<string> = new Set();
+        const versions: string[] = VersioningStrategy.merge(project)([
+          ...(c.versions ?? []),
+          ...(o.versions ?? []),
+        ]);
+        for (const v of versions)
+          for (const prefix of wrapPaths(c.prefixes))
+            for (const cPath of wrapPaths(c.paths))
+              for (const filePath of wrapPaths(o.paths))
+                pathList.add(
+                  PathAnalyzer.join(globalPrefix, v, prefix, cPath, filePath),
+                );
+        if (o.protocol === "http")
+          routes.push(
+            ...TypedHttpRouteAnalyzer.analyze({
+              controller: c,
+              errors: project.errors,
+              dictionary: collection,
+              operation: o,
+              paths: Array.from(pathList),
+            }),
+          );
+        else if (o.protocol === "websocket")
+          routes.push(
+            ...TypedWebSocketRouteAnalyzer.analyze({
+              controller: c,
+              operation: o,
+              paths: Array.from(pathList),
+            }),
+          );
+      }
+    AccessorAnalyzer.analyze(routes);
+
+    if (props.validate !== undefined)
+      props.validate({
+        project,
+        routes,
+      });
+    if (project.errors.length)
+      return report({
+        type: "error",
+        errors: project.errors,
+      });
+    await props.generate({
+      project,
+      routes,
+    });
   }
 }
 
@@ -275,44 +270,62 @@ const print_title = (str: string): void => {
 //   return true;
 // };
 
-const report_errors =
-  (type: "error" | "warning") =>
-  (errors: IErrorReport[]): void => {
-    // key: file
-    // key: controller
-    // key: function
-    // value: message
-    const map: Map<string, Map<string, Map<string, Set<string>>>> = new Map();
-    for (const e of errors) {
-      const file = MapUtil.take(map, e.file, () => new Map());
-      const controller = MapUtil.take(file, e.controller, () => new Map());
-      const func = MapUtil.take(controller, e.function, () => new Set());
-      func.add(e.message);
-    }
-
-    console.log("");
-    print_title(`Nestia ${type[0].toUpperCase()}${type.slice(1)} Report`);
-    for (const [file, cMap] of map) {
-      for (const [controller, fMap] of cMap)
-        for (const [func, messages] of fMap) {
-          const location: string = path.relative(process.cwd(), file);
-          console.log(
-            `${location} - ${
-              func !== null ? `${controller}.${func}()` : controller
-            }`,
-          );
-          for (const msg of messages) console.log(`  - ${msg}`);
-          console.log("");
-        }
-    }
-  };
-
-// const VARIABLE = /[a-zA-Z_$0-9]/;
-const turnTransformError = async (flag: boolean): Promise<void> => {
-  try {
-    const modulo = await import(
-      "@nestia/core/lib/decorators/internal/NoTransformConfigureError" as string
-    );
-    modulo.NoTransformConfigureError.throws = flag;
-  } catch {}
+const report = (props: {
+  type: "error" | "warning";
+  errors: IReflectOperationError[];
+}): void => {
+  const map: TreeMap<
+    IReflectOperationError.Key,
+    Array<string | IOperationMetadata.IError>
+  > = new TreeMap();
+  for (const e of props.errors)
+    map.take(new IReflectOperationError.Key(e), () => []).push(...e.contents);
+
+  console.log("");
+  print_title(`Nestia ${StringUtil.capitalize(props.type)} Report`);
+
+  for (const {
+    first: { error },
+    second: contents,
+  } of map) {
+    if (error.contents.length === 0) continue;
+    const location: string = path.relative(process.cwd(), error.file);
+    const message: string = [
+      `${location} - `,
+      error.class,
+      ...(error.function !== null ? [`.${error.function}()`] : [""]),
+      ...(error.from !== null ? [` from ${error.from}`] : [""]),
+      ":\n",
+      contents
+        .map((c) => {
+          if (typeof c === "string") return `  - ${c}`;
+          else
+            return [
+              c.accessor
+                ? `  - ${c.name}: `
+                : `  - ${c.name} (${c.accessor}): `,
+              ...c.messages.map((msg) => `    - ${msg}`),
+            ].join("\n");
+        })
+        .join("\n"),
+    ].join("");
+    console.log(message);
+  }
+
+  // for (const [file, cMap] of map) {
+  //   for (const [controller, fMap] of cMap)
+  //     for (const [func, messages] of fMap) {
+  //       const location: string = path.relative(process.cwd(), file);
+  //       console.log(
+  //         `${location} - ${
+  //           func !== null ? `${controller}.${func}()` : controller
+  //         }`,
+  //       );
+  //       for (const msg of messages) console.log(`  - ${msg}`);
+  //       console.log("");
+  //     }
+  // }
 };
+
+const wrapPaths = (paths: string[]): string[] =>
+  paths.length === 0 ? [""] : paths;

package/src/analyses/ConfigAnalyzer.ts

@@ -1,44 +1,43 @@
 /// <reference path="../typings/get-function-location.d.ts" />
+import { DynamicModule } from "@nestia/core";
 import { INestApplication, VersioningType } from "@nestjs/common";
 import { MODULE_PATH } from "@nestjs/common/constants";
-import { NestContainer } from "@nestjs/core";
+import { NestContainer, NestFactory } from "@nestjs/core";
 import { Module } from "@nestjs/core/injector/module";
-import fs from "fs";
 import getFunctionLocation from "get-function-location";
-import path from "path";
-import { HashMap, Pair, Singleton } from "tstl";
+import { HashMap } from "tstl";
 
 import { INestiaConfig } from "../INestiaConfig";
-import { SdkGenerator } from "../generates/SdkGenerator";
-import { INormalizedInput } from "../structures/INormalizedInput";
-import { ArrayUtil } from "../utils/ArrayUtil";
+import { INestiaSdkInput } from "../structures/INestiaSdkInput";
 import { MapUtil } from "../utils/MapUtil";
-import { SourceFinder } from "../utils/SourceFinder";
 
 export namespace ConfigAnalyzer {
-  export const input = (config: INestiaConfig): Promise<INormalizedInput> =>
-    MapUtil.take(memory, config, async () => {
-      const input = config.input;
-      if (Array.isArray(input)) return transform_input(config)(input);
-      else if (typeof input === "function")
-        return analyze_application(await input());
-      else if (typeof input === "object")
-        if (input === null)
-          throw new Error("Invalid input config. It can't be null.");
-        else return transform_input(config)(input.include, input.exclude);
-      else if (typeof input === "string")
-        return transform_input(config)([input]);
-      else throw new Error("Invalid input config.");
+  export const input = async (
+    config: INestiaConfig,
+  ): Promise<INestiaSdkInput> => {
+    return MapUtil.take(memory, config, async () => {
+      const app: INestApplication =
+        typeof config.input === "function"
+          ? await config.input()
+          : await NestFactory.create(
+              await DynamicModule.mount(config.input, {}, true as any),
+              {
+                logger: false,
+              },
+            );
+      return analyze_application(app);
     });
+  };
 
   const analyze_application = async (
     app: INestApplication,
-  ): Promise<INormalizedInput> => {
-    const files: HashMap<Pair<Function, string>, Set<string>> = new HashMap();
+  ): Promise<INestiaSdkInput> => {
     const container: NestContainer = (app as any).container as NestContainer;
     const modules: Module[] = [...container.getModules().values()].filter(
       (m) => !!m.controllers.size,
     );
+    const unique: HashMap<Function, Set<string>> = new HashMap();
+
     for (const m of modules) {
       const path: string =
         Reflect.getMetadata(
@@ -47,29 +46,28 @@ export namespace ConfigAnalyzer {
         ) ??
         Reflect.getMetadata(MODULE_PATH, m.metatype) ??
         "";
-      for (const controller of [...m.controllers.keys()]) {
-        const file: string | null =
-          (await getFunctionLocation(controller))?.source ?? null;
-        if (file === null) continue;
-
-        const location: string = normalize_file(file);
-        if (location.length === 0) continue;
-
-        const key: Pair<Function, string> = new Pair(
-          controller as Function,
-          location,
-        );
-        files.take(key, () => new Set([])).add(path);
-      }
+      for (const controller of [...m.controllers.keys()])
+        if (typeof controller === "function")
+          unique.take(controller, () => new Set()).add(path);
+    }
+    const controllers: INestiaSdkInput.IController[] = [];
+    for (const it of unique) {
+      const file: string | null =
+        (await getFunctionLocation(it.first))?.source ?? null;
+      if (file === null) continue;
+      const location: string = normalize_file(file);
+      if (location.length === 0) continue;
+      controllers.push({
+        class: it.first,
+        prefixes: Array.from(it.second),
+        location,
+      });
     }
 
     const versioning = (app as any).config?.versioningOptions;
     return {
-      include: files.toJSON().map((pair) => ({
-        controller: pair.first.first,
-        file: decodeURIComponent(pair.first.second),
-        paths: [...pair.second.values()],
-      })),
+      application: app,
+      controllers,
       globalPrefix:
         typeof (app as any).config?.globalPrefix === "string"
           ? {
@@ -89,61 +87,15 @@ export namespace ConfigAnalyzer {
             },
     };
   };
-
-  const normalize_file = (str: string) =>
-    str.substring(
-      str.startsWith("file:///")
-        ? process.cwd()[0] === "/"
-          ? 7
-          : 8
-        : str.startsWith("file://")
-          ? 7
-          : 0,
-    );
-
-  const transform_input =
-    (config: INestiaConfig) =>
-    async (include: string[], exclude?: string[]) => ({
-      include: (
-        await SourceFinder.find({
-          include,
-          exclude,
-          filter: filter(config),
-        })
-      ).map((file) => ({
-        paths: [""],
-        file,
-      })),
-    });
-
-  const filter =
-    (config: INestiaConfig) =>
-    async (location: string): Promise<boolean> =>
-      location.endsWith(".ts") &&
-      !location.endsWith(".d.ts") &&
-      (config.output === undefined ||
-        (location.indexOf(path.join(config.output, "functional")) === -1 &&
-          (await (
-            await bundler.get(config.output)
-          )(location))) === false);
 }
-
-const memory = new Map<INestiaConfig, Promise<INormalizedInput>>();
-const bundler = new Singleton(async (output: string) => {
-  const assets: string[] = await fs.promises.readdir(SdkGenerator.BUNDLE_PATH);
-  const tuples: Pair<string, boolean>[] = await ArrayUtil.asyncMap(
-    assets,
-    async (file) => {
-      const relative: string = path.join(output, file);
-      const location: string = path.join(SdkGenerator.BUNDLE_PATH, file);
-      const stats: fs.Stats = await fs.promises.stat(location);
-      return new Pair(relative, stats.isDirectory());
-    },
+const memory = new Map<INestiaConfig, Promise<INestiaSdkInput>>();
+const normalize_file = (str: string) =>
+  str.substring(
+    str.startsWith("file:///")
+      ? process.cwd()[0] === "/"
+        ? 7
+        : 8
+      : str.startsWith("file://")
+        ? 7
+        : 0,
   );
-  return async (file: string): Promise<boolean> => {
-    for (const it of tuples)
-      if (it.second === false && file === it.first) return true;
-      else if (it.second === true && file.indexOf(it.first) === 0) return true;
-    return false;
-  };
-});