@nestia/sdk 2.6.2 → 2.6.3

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,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";