@nestia/sdk 2.5.0-dev.20240131 → 2.5.0

package/src/analyses/ConfigAnalyzer.ts

@@ -1,147 +1,147 @@
-import { INestApplication, VersioningType } from "@nestjs/common";
-import { MODULE_PATH } from "@nestjs/common/constants";
-import { NestContainer } from "@nestjs/core";
-import { Module } from "@nestjs/core/injector/module";
-import fs from "fs";
-import path from "path";
-import { HashMap, Pair, Singleton } from "tstl";
-
-import { INestiaConfig } from "../INestiaConfig";
-import { SdkGenerator } from "../generates/SdkGenerator";
-import { INormalizedInput } from "../structures/INormalizedInput";
-import { ArrayUtil } from "../utils/ArrayUtil";
-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.");
-    });
-
-  const analyze_application = async (
-    app: INestApplication,
-  ): Promise<INormalizedInput> => {
-    const files: HashMap<Pair<Function, string>, Set<string>> = new HashMap();
-    const container: NestContainer = (app as any).container as NestContainer;
-    const modules: Module[] = [...container.getModules().values()].filter(
-      (m) => !!m.controllers.size,
-    );
-    for (const m of modules) {
-      const path: string =
-        Reflect.getMetadata(
-          MODULE_PATH + container.getModules().applicationId,
-          m.metatype,
-        ) ??
-        Reflect.getMetadata(MODULE_PATH, m.metatype) ??
-        "";
-      for (const controller of [...m.controllers.keys()]) {
-        const file: string | null =
-          (await require("get-function-location")(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);
-      }
-    }
-
-    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()],
-      })),
-      globalPrefix:
-        typeof (app as any).config?.globalPrefix === "string"
-          ? {
-              prefix: (app as any).config.globalPrefix,
-              exclude: (app as any).config.globalPrefixOptions?.exclude ?? {},
-            }
-          : undefined,
-      versioning:
-        versioning === undefined || versioning.type !== VersioningType.URI
-          ? undefined
-          : {
-              prefix:
-                versioning.prefix === undefined || versioning.prefix === false
-                  ? "v"
-                  : versioning.prefix,
-              defaultVersion: versioning.defaultVersion,
-            },
-    };
-  };
-
-  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());
-    },
-  );
-  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;
-  };
-});
+import { INestApplication, VersioningType } from "@nestjs/common";
+import { MODULE_PATH } from "@nestjs/common/constants";
+import { NestContainer } from "@nestjs/core";
+import { Module } from "@nestjs/core/injector/module";
+import fs from "fs";
+import path from "path";
+import { HashMap, Pair, Singleton } from "tstl";
+
+import { INestiaConfig } from "../INestiaConfig";
+import { SdkGenerator } from "../generates/SdkGenerator";
+import { INormalizedInput } from "../structures/INormalizedInput";
+import { ArrayUtil } from "../utils/ArrayUtil";
+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.");
+    });
+
+  const analyze_application = async (
+    app: INestApplication,
+  ): Promise<INormalizedInput> => {
+    const files: HashMap<Pair<Function, string>, Set<string>> = new HashMap();
+    const container: NestContainer = (app as any).container as NestContainer;
+    const modules: Module[] = [...container.getModules().values()].filter(
+      (m) => !!m.controllers.size,
+    );
+    for (const m of modules) {
+      const path: string =
+        Reflect.getMetadata(
+          MODULE_PATH + container.getModules().applicationId,
+          m.metatype,
+        ) ??
+        Reflect.getMetadata(MODULE_PATH, m.metatype) ??
+        "";
+      for (const controller of [...m.controllers.keys()]) {
+        const file: string | null =
+          (await require("get-function-location")(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);
+      }
+    }
+
+    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()],
+      })),
+      globalPrefix:
+        typeof (app as any).config?.globalPrefix === "string"
+          ? {
+              prefix: (app as any).config.globalPrefix,
+              exclude: (app as any).config.globalPrefixOptions?.exclude ?? {},
+            }
+          : undefined,
+      versioning:
+        versioning === undefined || versioning.type !== VersioningType.URI
+          ? undefined
+          : {
+              prefix:
+                versioning.prefix === undefined || versioning.prefix === false
+                  ? "v"
+                  : versioning.prefix,
+              defaultVersion: versioning.defaultVersion,
+            },
+    };
+  };
+
+  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());
+    },
+  );
+  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;
+  };
+});

package/src/analyses/GenericAnalyzer.ts

@@ -1,51 +1,51 @@
-import ts from "typescript";
-
-export namespace GenericAnalyzer {
-  export type Dictionary = WeakMap<ts.Type, ts.Type>;
-
-  export function analyze(
-    checker: ts.TypeChecker,
-    classNode: ts.ClassDeclaration,
-  ): Dictionary {
-    const dict: Dictionary = new WeakMap();
-    explore(checker, dict, classNode);
-    return dict;
-  }
-
-  function explore(
-    checker: ts.TypeChecker,
-    dict: Dictionary,
-    classNode: ts.ClassDeclaration,
-  ): void {
-    if (classNode.heritageClauses === undefined) return;
-
-    for (const heritage of classNode.heritageClauses)
-      for (const hType of heritage.types) {
-        // MUST BE CLASS
-        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
-        const superNode: ts.Declaration | undefined =
-          expression.symbol.getDeclarations()?.[0];
-
-        if (superNode === undefined || !ts.isClassDeclaration(superNode))
-          continue;
-
-        // SPECIFY GENERICS
-        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
-        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
-          superNode.typeParameters || [];
-
-        parameters.forEach((param, index) => {
-          const paramType: ts.Type = checker.getTypeAtLocation(param);
-          const usageType: ts.Type =
-            usages[index] !== undefined
-              ? checker.getTypeAtLocation(usages[index])
-              : checker.getTypeAtLocation(param.default!);
-
-          dict.set(paramType, usageType);
-        });
-
-        // RECUSRIVE EXPLORATION
-        explore(checker, dict, superNode);
-      }
-  }
-}
+import ts from "typescript";
+
+export namespace GenericAnalyzer {
+  export type Dictionary = WeakMap<ts.Type, ts.Type>;
+
+  export function analyze(
+    checker: ts.TypeChecker,
+    classNode: ts.ClassDeclaration,
+  ): Dictionary {
+    const dict: Dictionary = new WeakMap();
+    explore(checker, dict, classNode);
+    return dict;
+  }
+
+  function explore(
+    checker: ts.TypeChecker,
+    dict: Dictionary,
+    classNode: ts.ClassDeclaration,
+  ): void {
+    if (classNode.heritageClauses === undefined) return;
+
+    for (const heritage of classNode.heritageClauses)
+      for (const hType of heritage.types) {
+        // MUST BE CLASS
+        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
+        const superNode: ts.Declaration | undefined =
+          expression.symbol.getDeclarations()?.[0];
+
+        if (superNode === undefined || !ts.isClassDeclaration(superNode))
+          continue;
+
+        // SPECIFY GENERICS
+        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
+        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
+          superNode.typeParameters || [];
+
+        parameters.forEach((param, index) => {
+          const paramType: ts.Type = checker.getTypeAtLocation(param);
+          const usageType: ts.Type =
+            usages[index] !== undefined
+              ? checker.getTypeAtLocation(usages[index])
+              : checker.getTypeAtLocation(param.default!);
+
+          dict.set(paramType, usageType);
+        });
+
+        // RECUSRIVE EXPLORATION
+        explore(checker, dict, superNode);
+      }
+  }
+}

package/src/analyses/ImportAnalyzer.ts

@@ -1,138 +1,138 @@
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
-import ts from "typescript";
-
-import { ITypeTuple } from "../structures/ITypeTuple";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-
-export namespace ImportAnalyzer {
-  export interface IOutput {
-    features: [string, string[]][];
-    alias: string;
-  }
-
-  export type Dictionary = HashMap<string, HashSet<string>>;
-
-  export function analyze(
-    checker: ts.TypeChecker,
-    genericDict: GenericAnalyzer.Dictionary,
-    importDict: Dictionary,
-    type: ts.Type,
-  ): ITypeTuple | null {
-    type = get_type(checker, type);
-    explore_escaped_name(checker, genericDict, importDict, type);
-
-    try {
-      return {
-        type,
-        typeName: explore_escaped_name(checker, genericDict, importDict, type),
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  /* ---------------------------------------------------------
-        TYPE
-    --------------------------------------------------------- */
-  function get_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-    const symbol: ts.Symbol | undefined = type.getSymbol();
-    return symbol && get_name(symbol) === "Promise"
-      ? escape_promise(checker, type)
-      : type;
-  }
-
-  function escape_promise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
-    const generic: readonly ts.Type[] = checker.getTypeArguments(
-      type as ts.TypeReference,
-    );
-    if (generic.length !== 1)
-      throw new Error(
-        "Error on ImportAnalyzer.analyze(): invalid promise type.",
-      );
-    return generic[0];
-  }
-
-  function get_name(symbol: ts.Symbol): string {
-    return explore_name(
-      symbol.escapedName.toString(),
-      symbol.getDeclarations()?.[0]?.parent,
-    );
-  }
-
-  /* ---------------------------------------------------------
-        ESCAPED TEXT WITH IMPORT STATEMENTS
-    --------------------------------------------------------- */
-  function explore_escaped_name(
-    checker: ts.TypeChecker,
-    genericDict: GenericAnalyzer.Dictionary,
-    importDict: Dictionary,
-    type: ts.Type,
-  ): string {
-    //----
-    // CONDITIONAL BRANCHES
-    //----
-    // DECOMPOSE GENERIC ARGUMENT
-    while (genericDict.has(type) === true) type = genericDict.get(type)!;
-
-    // PRIMITIVE
-    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.getSymbol();
-
-    // UNION OR INTERSECT
-    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-      const joiner: string = type.isIntersection() ? " & " : " | ";
-      return type.types
-        .map((child) =>
-          explore_escaped_name(checker, genericDict, importDict, child),
-        )
-        .join(joiner);
-    }
-
-    // NO SYMBOL
-    else if (symbol === undefined)
-      return checker.typeToString(
-        type,
-        undefined,
-        ts.TypeFormatFlags.NoTruncation,
-      );
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = get_name(symbol);
-    const sourceFile: ts.SourceFile | undefined =
-      symbol.declarations?.[0]?.getSourceFile();
-    if (sourceFile === undefined) return name;
-
-    if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
-      const set: HashSet<string> = importDict.take(
-        sourceFile.fileName,
-        () => new HashSet(),
-      );
-      set.insert(name.split(".")[0]);
-    }
-
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = type.aliasSymbol
-      ? type.aliasTypeArguments || []
-      : checker.getTypeArguments(type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? explore_escaped_name(checker, genericDict, importDict, generic[0])
-        : `${name}<${generic
-            .map((child) =>
-              explore_escaped_name(checker, genericDict, importDict, child),
-            )
-            .join(", ")}>`
-      : name;
-  }
-
-  function explore_name(name: string, decl?: ts.Node): string {
-    return decl && ts.isModuleBlock(decl)
-      ? explore_name(
-          `${decl.parent.name.getFullText().trim()}.${name}`,
-          decl.parent.parent,
-        )
-      : name;
-  }
-}
+import { HashMap } from "tstl/container/HashMap";
+import { HashSet } from "tstl/container/HashSet";
+import ts from "typescript";
+
+import { ITypeTuple } from "../structures/ITypeTuple";
+import { GenericAnalyzer } from "./GenericAnalyzer";
+
+export namespace ImportAnalyzer {
+  export interface IOutput {
+    features: [string, string[]][];
+    alias: string;
+  }
+
+  export type Dictionary = HashMap<string, HashSet<string>>;
+
+  export function analyze(
+    checker: ts.TypeChecker,
+    genericDict: GenericAnalyzer.Dictionary,
+    importDict: Dictionary,
+    type: ts.Type,
+  ): ITypeTuple | null {
+    type = get_type(checker, type);
+    explore_escaped_name(checker, genericDict, importDict, type);
+
+    try {
+      return {
+        type,
+        typeName: explore_escaped_name(checker, genericDict, importDict, type),
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /* ---------------------------------------------------------
+        TYPE
+    --------------------------------------------------------- */
+  function get_type(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const symbol: ts.Symbol | undefined = type.getSymbol();
+    return symbol && get_name(symbol) === "Promise"
+      ? escape_promise(checker, type)
+      : type;
+  }
+
+  function escape_promise(checker: ts.TypeChecker, type: ts.Type): ts.Type {
+    const generic: readonly ts.Type[] = checker.getTypeArguments(
+      type as ts.TypeReference,
+    );
+    if (generic.length !== 1)
+      throw new Error(
+        "Error on ImportAnalyzer.analyze(): invalid promise type.",
+      );
+    return generic[0];
+  }
+
+  function get_name(symbol: ts.Symbol): string {
+    return explore_name(
+      symbol.escapedName.toString(),
+      symbol.getDeclarations()?.[0]?.parent,
+    );
+  }
+
+  /* ---------------------------------------------------------
+        ESCAPED TEXT WITH IMPORT STATEMENTS
+    --------------------------------------------------------- */
+  function explore_escaped_name(
+    checker: ts.TypeChecker,
+    genericDict: GenericAnalyzer.Dictionary,
+    importDict: Dictionary,
+    type: ts.Type,
+  ): string {
+    //----
+    // CONDITIONAL BRANCHES
+    //----
+    // DECOMPOSE GENERIC ARGUMENT
+    while (genericDict.has(type) === true) type = genericDict.get(type)!;
+
+    // PRIMITIVE
+    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.getSymbol();
+
+    // UNION OR INTERSECT
+    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+      const joiner: string = type.isIntersection() ? " & " : " | ";
+      return type.types
+        .map((child) =>
+          explore_escaped_name(checker, genericDict, importDict, child),
+        )
+        .join(joiner);
+    }
+
+    // NO SYMBOL
+    else if (symbol === undefined)
+      return checker.typeToString(
+        type,
+        undefined,
+        ts.TypeFormatFlags.NoTruncation,
+      );
+
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = get_name(symbol);
+    const sourceFile: ts.SourceFile | undefined =
+      symbol.declarations?.[0]?.getSourceFile();
+    if (sourceFile === undefined) return name;
+
+    if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
+      const set: HashSet<string> = importDict.take(
+        sourceFile.fileName,
+        () => new HashSet(),
+      );
+      set.insert(name.split(".")[0]);
+    }
+
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = type.aliasSymbol
+      ? type.aliasTypeArguments || []
+      : checker.getTypeArguments(type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? explore_escaped_name(checker, genericDict, importDict, generic[0])
+        : `${name}<${generic
+            .map((child) =>
+              explore_escaped_name(checker, genericDict, importDict, child),
+            )
+            .join(", ")}>`
+      : name;
+  }
+
+  function explore_name(name: string, decl?: ts.Node): string {
+    return decl && ts.isModuleBlock(decl)
+      ? explore_name(
+          `${decl.parent.name.getFullText().trim()}.${name}`,
+          decl.parent.parent,
+        )
+      : name;
+  }
+}