@nestia/sdk 3.0.0-dev.20231209 → 3.0.0-dev.20240412

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,115 +1,148 @@
-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 { 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].value.toString();
+      else if (meta.escaped && meta.escaped.returns.constants.length === 1)
+        return meta.escaped.returns.constants[0].values[0].value.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/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,5 +1,4 @@
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
+import { HashMap, HashSet } from "tstl";
 import ts from "typescript";
 
 import { ITypeTuple } from "../structures/ITypeTuple";

package/src/analyses/PathAnalyzer.ts

@@ -1,98 +1,110 @@
-import { RequestMethod } from "@nestjs/common";
-import path from "path";
-import { Token, parse } from "path-to-regexp";
-
-import { INormalizedInput } from "../structures/INormalizedInput";
-
-export namespace PathAnalyzer {
-  export const combinate =
-    (globalPrefix: INormalizedInput["globalPrefix"]) =>
-    (versions: Array<string | null>) =>
-    (props: { path: string; method: string }): string[] => {
-      const out = (str: string) =>
-        versions.map((v) => (v === null ? str : join(v, str)));
-      if (!globalPrefix?.prefix.length) return out(props.path);
-      else if (!globalPrefix.exclude?.length)
-        return out(props.path).map((str) => join(globalPrefix.prefix, str));
-      return globalPrefix.exclude.some((exclude) =>
-        typeof exclude === "string"
-          ? RegExp(exclude).test(props.path)
-          : METHOD(exclude.method) === props.method &&
-            RegExp(exclude.path).test(props.path),
-      )
-        ? out(props.path)
-        : out(props.path).map((str) => join(globalPrefix.prefix, str));
-    };
-
-  export const join = (...args: string[]) =>
-    "/" +
-    _Trim(
-      path
-        .join(...args.filter((s) => !!s.length))
-        .split("\\")
-        .join("/"),
-    );
-
-  export const escape = (str: string, method: () => string) =>
-    "/" +
-    _Parse(str, method)
-      .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
-      .join("/");
-
-  export const parameters = (str: string, method: () => string) =>
-    _Parse(str, method)
-      .filter((arg) => arg.type === "param")
-      .map((arg) => arg.value);
-
-  function _Parse(str: string, method: () => string): IArgument[] {
-    const tokens: Token[] = parse(path.join(str).split("\\").join("/"));
-    const output: IArgument[] = [];
-
-    for (const key of tokens) {
-      if (typeof key === "string")
-        output.push({
-          type: "path",
-          value: _Trim(key),
-        });
-      else if (typeof key.name === "number" || _Trim(key.name) === "")
-        throw new Error(`Error on ${method}: ${ERROR_MESSAGE}.`);
-      else
-        output.push({
-          type: "param",
-          value: _Trim(key.name),
-        });
-    }
-    return output;
-  }
-
-  function _Trim(str: string): string {
-    if (str[0] === "/") str = str.substring(1);
-    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
-    return str;
-  }
-
-  interface IArgument {
-    type: "param" | "path";
-    value: string;
-  }
-}
-
-const ERROR_MESSAGE = "nestia supports only string typed parameter on path";
-const METHOD = (value: RequestMethod) =>
-  value === RequestMethod.ALL
-    ? "all"
-    : value === RequestMethod.DELETE
-    ? "delete"
-    : value === RequestMethod.GET
-    ? "get"
-    : value === RequestMethod.HEAD
-    ? "head"
-    : value === RequestMethod.OPTIONS
-    ? "options"
-    : value === RequestMethod.PATCH
-    ? "patch"
-    : value === RequestMethod.POST
-    ? "post"
-    : value === RequestMethod.PUT
-    ? "put"
-    : "unknown";
+import { RequestMethod } from "@nestjs/common";
+import path from "path";
+import { Token, parse } from "path-to-regexp";
+
+import { INormalizedInput } from "../structures/INormalizedInput";
+
+export namespace PathAnalyzer {
+  export const combinate =
+    (globalPrefix: INormalizedInput["globalPrefix"]) =>
+    (versions: Array<string | null>) =>
+    (props: { path: string; method: string }): string[] => {
+      const out = (str: string) =>
+        versions.map((v) => (v === null ? str : join(v, str)));
+      if (!globalPrefix?.prefix.length) return out(props.path);
+      else if (!globalPrefix.exclude?.length)
+        return out(props.path).map((str) => join(globalPrefix.prefix, str));
+      return globalPrefix.exclude.some((exclude) =>
+        typeof exclude === "string"
+          ? RegExp(exclude).test(props.path)
+          : METHOD(exclude.method) === props.method &&
+            RegExp(exclude.path).test(props.path),
+      )
+        ? out(props.path)
+        : out(props.path).map((str) => join(globalPrefix.prefix, str));
+    };
+
+  export const join = (...args: string[]) =>
+    "/" +
+    _Trim(
+      path
+        .join(...args.filter((s) => !!s.length))
+        .split("\\")
+        .join("/"),
+    );
+
+  export const escape = (str: string): string | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return (
+      "/" +
+      args
+        .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
+        .join("/")
+    );
+  };
+
+  export const parameters = (str: string): string[] | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return args.filter((arg) => arg.type === "param").map((arg) => arg.value);
+  };
+
+  function _Parse(str: string): IArgument[] | null {
+    const tokens: Token[] | null = (() => {
+      try {
+        return parse(path.join(str).split("\\").join("/"));
+      } catch {
+        return null;
+      }
+    })();
+    if (tokens === null) return null;
+
+    const output: IArgument[] = [];
+    for (const key of tokens) {
+      if (typeof key === "string")
+        output.push({
+          type: "path",
+          value: _Trim(key),
+        });
+      else if (typeof key.name === "number" || _Trim(key.name) === "")
+        return null;
+      else
+        output.push({
+          type: "param",
+          value: _Trim(key.name),
+        });
+    }
+    return output;
+  }
+
+  function _Trim(str: string): string {
+    if (str[0] === "/") str = str.substring(1);
+    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
+    return str;
+  }
+
+  interface IArgument {
+    type: "param" | "path";
+    value: string;
+  }
+}
+
+const METHOD = (value: RequestMethod) =>
+  value === RequestMethod.ALL
+    ? "all"
+    : value === RequestMethod.DELETE
+      ? "delete"
+      : value === RequestMethod.GET
+        ? "get"
+        : value === RequestMethod.HEAD
+          ? "head"
+          : value === RequestMethod.OPTIONS
+            ? "options"
+            : value === RequestMethod.PATCH
+              ? "patch"
+              : value === RequestMethod.POST
+                ? "post"
+                : value === RequestMethod.PUT
+                  ? "put"
+                  : "unknown";