@nestia/sdk 2.4.2 → 2.4.3

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,124 +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,57 +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,159 +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;
+  }
+}