@nestia/sdk 2.6.3-dev.20240328 → 2.6.4-dev.20240401

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,148 +1,148 @@
-import path from "path";
-import ts from "typescript";
-import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
-import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
-import { Metadata } from "typia/lib/schemas/metadata/Metadata";
-
-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 status: string | null = getStatus(project.checker)(
-        decorator.expression.arguments[0] ?? null,
-      );
-      if (status === null) return false;
-
-      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 ||
-        (project.config.clone !== true &&
-          (tuple.typeName === "__type" || tuple.typeName === "__object"))
-      ) {
-        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]) => status === key)
-        .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 getStatus =
-    (checker: ts.TypeChecker) =>
-    (expression: ts.Expression | null): string | null => {
-      if (expression === null) return null;
-
-      const type: ts.Type = checker.getTypeAtLocation(expression);
-      const result = MetadataFactory.analyze(checker)({
-        escape: true,
-        constant: true,
-        absorb: true,
-      })(new MetadataCollection())(type);
-      if (false === result.success) return null;
-
-      const meta: Metadata = result.data;
-      if (meta.constants.length === 1)
-        return meta.constants[0].values[0].toString();
-      else if (meta.escaped && meta.escaped.returns.constants.length === 1)
-        return meta.escaped.returns.constants[0].values[0].toString();
-      else if (ts.isStringLiteral(expression)) return expression.text;
-      else if (ts.isNumericLiteral(expression)) {
-        const value: number = Number(expression.text.split("_").join(""));
-        if (false === isNaN(value)) return value.toString();
-      }
-      return null;
-    };
-}
-
-const TYPED_EXCEPTION_PATH = path.join(
-  "node_modules",
-  "@nestia",
-  "core",
-  "lib",
-  "decorators",
-  "TypedException.d.ts",
-);
+import path from "path";
+import ts from "typescript";
+import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
+import { MetadataFactory } from "typia/lib/factories/MetadataFactory";
+import { Metadata } from "typia/lib/schemas/metadata/Metadata";
+
+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 status: string | null = getStatus(project.checker)(
+        decorator.expression.arguments[0] ?? null,
+      );
+      if (status === null) return false;
+
+      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 ||
+        (project.config.clone !== true &&
+          (tuple.typeName === "__type" || tuple.typeName === "__object"))
+      ) {
+        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]) => status === key)
+        .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 getStatus =
+    (checker: ts.TypeChecker) =>
+    (expression: ts.Expression | null): string | null => {
+      if (expression === null) return null;
+
+      const type: ts.Type = checker.getTypeAtLocation(expression);
+      const result = MetadataFactory.analyze(checker)({
+        escape: true,
+        constant: true,
+        absorb: true,
+      })(new MetadataCollection())(type);
+      if (false === result.success) return null;
+
+      const meta: Metadata = result.data;
+      if (meta.constants.length === 1)
+        return meta.constants[0].values[0].toString();
+      else if (meta.escaped && meta.escaped.returns.constants.length === 1)
+        return meta.escaped.returns.constants[0].values[0].toString();
+      else if (ts.isStringLiteral(expression)) return expression.text;
+      else if (ts.isNumericLiteral(expression)) {
+        const value: number = Number(expression.text.split("_").join(""));
+        if (false === isNaN(value)) return value.toString();
+      }
+      return null;
+    };
+}
+
+const TYPED_EXCEPTION_PATH = path.join(
+  "node_modules",
+  "@nestia",
+  "core",
+  "lib",
+  "decorators",
+  "TypedException.d.ts",
+);

package/src/analyses/ImportAnalyzer.ts

@@ -1,137 +1,137 @@
-import { HashMap, HashSet } from "tstl";
-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, HashSet } from "tstl";
+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;
+  }
+}

package/src/analyses/SecurityAnalyzer.ts

@@ -1,24 +1,24 @@
-import { MapUtil } from "../utils/MapUtil";
-
-export namespace SecurityAnalyzer {
-  const none = Symbol("none");
-  export const merge = (...entire: Record<string, string[]>[]) => {
-    const dict: Map<string | typeof none, Set<string>> = new Map();
-    for (const obj of entire) {
-      const entries = Object.entries(obj);
-      for (const [key, value] of entries) {
-        const set = MapUtil.take(dict, key, () => new Set());
-        for (const val of value) set.add(val);
-      }
-      if (entries.length === 0) MapUtil.take(dict, none, () => new Set());
-    }
-    const output: Record<string, string[]>[] = [];
-    for (const [key, set] of dict)
-      key === none
-        ? output.push({})
-        : output.push({
-            [key]: [...set],
-          });
-    return output;
-  };
-}
+import { MapUtil } from "../utils/MapUtil";
+
+export namespace SecurityAnalyzer {
+  const none = Symbol("none");
+  export const merge = (...entire: Record<string, string[]>[]) => {
+    const dict: Map<string | typeof none, Set<string>> = new Map();
+    for (const obj of entire) {
+      const entries = Object.entries(obj);
+      for (const [key, value] of entries) {
+        const set = MapUtil.take(dict, key, () => new Set());
+        for (const val of value) set.add(val);
+      }
+      if (entries.length === 0) MapUtil.take(dict, none, () => new Set());
+    }
+    const output: Record<string, string[]>[] = [];
+    for (const [key, set] of dict)
+      key === none
+        ? output.push({})
+        : output.push({
+            [key]: [...set],
+          });
+    return output;
+  };
+}