@nestia/sdk 2.4.3 → 2.4.4

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,115 +1,115 @@
-import path from "path";
-import ts from "typescript";
-
-import { IController } from "../structures/IController";
-import { INestiaProject } from "../structures/INestiaProject";
-import { IRoute } from "../structures/IRoute";
-import { ITypeTuple } from "../structures/ITypeTuple";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-import { ImportAnalyzer } from "./ImportAnalyzer";
-
-export namespace ExceptionAnalyzer {
-  export const analyze =
-    (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (
-      declaration: ts.MethodDeclaration,
-    ): Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput> => {
-      const output: Record<
-        number | "2XX" | "3XX" | "4XX" | "5XX",
-        IRoute.IOutput
-      > = {} as any;
-      for (const decorator of declaration.modifiers ?? [])
-        if (ts.isDecorator(decorator))
-          analyzeTyped(project)(genericDict, importDict)(controller, func)(
-            output,
-          )(decorator);
-      return output;
-    };
-
-  const analyzeTyped =
-    (project: INestiaProject) =>
-    (
-      genericDict: GenericAnalyzer.Dictionary,
-      importDict: ImportAnalyzer.Dictionary,
-    ) =>
-    (controller: IController, func: IController.IFunction) =>
-    (output: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>) =>
-    (decorator: ts.Decorator): boolean => {
-      // CHECK DECORATOR
-      if (!ts.isCallExpression(decorator.expression)) return false;
-      else if ((decorator.expression.typeArguments ?? []).length !== 1)
-        return false;
-
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(decorator.expression);
-      if (!signature || !signature.declaration) return false;
-      else if (
-        path
-          .resolve(signature.declaration.getSourceFile().fileName)
-          .indexOf(TYPED_EXCEPTION_PATH) === -1
-      )
-        return false;
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = decorator.expression.typeArguments![0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-      if (type.isTypeParameter()) {
-        project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
-          message: "TypedException() without generic argument specification.",
-        });
-        return false;
-      }
-
-      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(
-        project.checker,
-        genericDict,
-        importDict,
-        type,
-      );
-      if (tuple === null || tuple.typeName === "__type") {
-        project.errors.push({
-          file: controller.file,
-          controller: controller.name,
-          function: func.name,
-          message: "TypeException() with implicit (unnamed) type.",
-        });
-        return false;
-      }
-
-      // DO ASSIGN
-      const matched: IController.IException[] = Object.entries(func.exceptions)
-        .filter(([_key, value]) =>
-          value.type.includes(" | ") && tuple.typeName.includes(" | ")
-            ? value.type.split(" | ").sort().join(" | ") ===
-              tuple.typeName.split(" | ").sort().join(" | ")
-            : value.type === tuple.typeName,
-        )
-        .map(([_key, value]) => value);
-      for (const m of matched)
-        output[m.status] = {
-          type: tuple.type,
-          typeName: tuple.typeName,
-          contentType: "application/json",
-          description: m.description,
-        };
-      return true;
-    };
-}
-
-const TYPED_EXCEPTION_PATH = path.join(
-  "node_modules",
-  "@nestia",
-  "core",
-  "lib",
-  "decorators",
-  "TypedException.d.ts",
-);
+import path from "path";
+import ts from "typescript";
+
+import { IController } from "../structures/IController";
+import { INestiaProject } from "../structures/INestiaProject";
+import { IRoute } from "../structures/IRoute";
+import { ITypeTuple } from "../structures/ITypeTuple";
+import { GenericAnalyzer } from "./GenericAnalyzer";
+import { ImportAnalyzer } from "./ImportAnalyzer";
+
+export namespace ExceptionAnalyzer {
+  export const analyze =
+    (project: INestiaProject) =>
+    (
+      genericDict: GenericAnalyzer.Dictionary,
+      importDict: ImportAnalyzer.Dictionary,
+    ) =>
+    (controller: IController, func: IController.IFunction) =>
+    (
+      declaration: ts.MethodDeclaration,
+    ): Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput> => {
+      const output: Record<
+        number | "2XX" | "3XX" | "4XX" | "5XX",
+        IRoute.IOutput
+      > = {} as any;
+      for (const decorator of declaration.modifiers ?? [])
+        if (ts.isDecorator(decorator))
+          analyzeTyped(project)(genericDict, importDict)(controller, func)(
+            output,
+          )(decorator);
+      return output;
+    };
+
+  const analyzeTyped =
+    (project: INestiaProject) =>
+    (
+      genericDict: GenericAnalyzer.Dictionary,
+      importDict: ImportAnalyzer.Dictionary,
+    ) =>
+    (controller: IController, func: IController.IFunction) =>
+    (output: Record<number | "2XX" | "3XX" | "4XX" | "5XX", IRoute.IOutput>) =>
+    (decorator: ts.Decorator): boolean => {
+      // CHECK DECORATOR
+      if (!ts.isCallExpression(decorator.expression)) return false;
+      else if ((decorator.expression.typeArguments ?? []).length !== 1)
+        return false;
+
+      // CHECK SIGNATURE
+      const signature: ts.Signature | undefined =
+        project.checker.getResolvedSignature(decorator.expression);
+      if (!signature || !signature.declaration) return false;
+      else if (
+        path
+          .resolve(signature.declaration.getSourceFile().fileName)
+          .indexOf(TYPED_EXCEPTION_PATH) === -1
+      )
+        return false;
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = decorator.expression.typeArguments![0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+      if (type.isTypeParameter()) {
+        project.errors.push({
+          file: controller.file,
+          controller: controller.name,
+          function: func.name,
+          message: "TypedException() without generic argument specification.",
+        });
+        return false;
+      }
+
+      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(
+        project.checker,
+        genericDict,
+        importDict,
+        type,
+      );
+      if (tuple === null || tuple.typeName === "__type") {
+        project.errors.push({
+          file: controller.file,
+          controller: controller.name,
+          function: func.name,
+          message: "TypeException() with implicit (unnamed) type.",
+        });
+        return false;
+      }
+
+      // DO ASSIGN
+      const matched: IController.IException[] = Object.entries(func.exceptions)
+        .filter(([_key, value]) =>
+          value.type.includes(" | ") && tuple.typeName.includes(" | ")
+            ? value.type.split(" | ").sort().join(" | ") ===
+              tuple.typeName.split(" | ").sort().join(" | ")
+            : value.type === tuple.typeName,
+        )
+        .map(([_key, value]) => value);
+      for (const m of matched)
+        output[m.status] = {
+          type: tuple.type,
+          typeName: tuple.typeName,
+          contentType: "application/json",
+          description: m.description,
+        };
+      return true;
+    };
+}
+
+const TYPED_EXCEPTION_PATH = path.join(
+  "node_modules",
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  "TypedException.d.ts",
+);

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;
+  }
+}