@nestia/sdk 3.10.0 → 3.11.0-dev.20240813

package/src/analyses/ExceptionAnalyzer.ts

@@ -1,154 +1,154 @@
-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 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 { INestiaProject } from "../structures/INestiaProject";
-import { IReflectController } from "../structures/IReflectController";
-import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
-import { ITypeTuple } from "../structures/ITypeTuple";
-import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
-import { GenericAnalyzer } from "./GenericAnalyzer";
-import { ImportAnalyzer } from "./ImportAnalyzer";
+// import { INestiaProject } from "../structures/INestiaProject";
+// import { IReflectController } from "../structures/IReflectController";
+// import { IReflectHttpOperation } from "../structures/IReflectHttpOperation";
+// import { ITypeTuple } from "../structures/ITypeTuple";
+// import { ITypedHttpRoute } from "../structures/ITypedHttpRoute";
+// import { GenericAnalyzer } from "./GenericAnalyzer";
+// import { ImportAnalyzer } from "./ImportAnalyzer";
 
-export namespace ExceptionAnalyzer {
-  export const analyze =
-    (project: INestiaProject) =>
-    (props: {
-      generics: GenericAnalyzer.Dictionary;
-      imports: ImportAnalyzer.Dictionary;
-      controller: IReflectController;
-      operation: IReflectHttpOperation;
-      declaration: ts.MethodDeclaration;
-    }): Record<
-      number | "2XX" | "3XX" | "4XX" | "5XX",
-      ITypedHttpRoute.IOutput
-    > => {
-      const output: Record<
-        number | "2XX" | "3XX" | "4XX" | "5XX",
-        ITypedHttpRoute.IOutput
-      > = {} as any;
-      for (const decorator of props.declaration.modifiers ?? [])
-        if (ts.isDecorator(decorator))
-          analyzeTyped(project)({
-            ...props,
-            output,
-            decorator,
-          });
-      return output;
-    };
+// export namespace ExceptionAnalyzer {
+//   export const analyze =
+//     (project: INestiaProject) =>
+//     (props: {
+//       generics: GenericAnalyzer.Dictionary;
+//       imports: ImportAnalyzer.Dictionary;
+//       controller: IReflectController;
+//       operation: IReflectHttpOperation;
+//       declaration: ts.MethodDeclaration;
+//     }): Record<
+//       number | "2XX" | "3XX" | "4XX" | "5XX",
+//       ITypedHttpRoute.IOutput
+//     > => {
+//       const output: Record<
+//         number | "2XX" | "3XX" | "4XX" | "5XX",
+//         ITypedHttpRoute.IOutput
+//       > = {} as any;
+//       for (const decorator of props.declaration.modifiers ?? [])
+//         if (ts.isDecorator(decorator))
+//           analyzeTyped(project)({
+//             ...props,
+//             output,
+//             decorator,
+//           });
+//       return output;
+//     };
 
-  const analyzeTyped =
-    (project: INestiaProject) =>
-    (props: {
-      generics: GenericAnalyzer.Dictionary;
-      imports: ImportAnalyzer.Dictionary;
-      controller: IReflectController;
-      operation: IReflectHttpOperation;
-      output: Record<
-        number | "2XX" | "3XX" | "4XX" | "5XX",
-        ITypedHttpRoute.IOutput
-      >;
-      decorator: ts.Decorator;
-    }): boolean => {
-      // CHECK DECORATOR
-      if (!ts.isCallExpression(props.decorator.expression)) return false;
-      else if ((props.decorator.expression.typeArguments ?? []).length !== 1)
-        return false;
+//   const analyzeTyped =
+//     (project: INestiaProject) =>
+//     (props: {
+//       generics: GenericAnalyzer.Dictionary;
+//       imports: ImportAnalyzer.Dictionary;
+//       controller: IReflectController;
+//       operation: IReflectHttpOperation;
+//       output: Record<
+//         number | "2XX" | "3XX" | "4XX" | "5XX",
+//         ITypedHttpRoute.IOutput
+//       >;
+//       decorator: ts.Decorator;
+//     }): boolean => {
+//       // CHECK DECORATOR
+//       if (!ts.isCallExpression(props.decorator.expression)) return false;
+//       else if ((props.decorator.expression.typeArguments ?? []).length !== 1)
+//         return false;
 
-      // CHECK SIGNATURE
-      const signature: ts.Signature | undefined =
-        project.checker.getResolvedSignature(props.decorator.expression);
-      if (!signature || !signature.declaration) return false;
-      else if (
-        path
-          .resolve(signature.declaration.getSourceFile().fileName)
-          .indexOf(TYPED_EXCEPTION_PATH) === -1
-      )
-        return false;
+//       // CHECK SIGNATURE
+//       const signature: ts.Signature | undefined =
+//         project.checker.getResolvedSignature(props.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)(
-        props.decorator.expression.arguments[0] ?? null,
-      );
-      if (status === null) return false;
+//       // GET TYPE INFO
+//       const status: string | null = getStatus(project.checker)(
+//         props.decorator.expression.arguments[0] ?? null,
+//       );
+//       if (status === null) return false;
 
-      const node: ts.TypeNode = props.decorator.expression.typeArguments![0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-      if (type.isTypeParameter()) {
-        project.errors.push({
-          file: props.controller.file,
-          controller: props.controller.name,
-          function: props.operation.name,
-          message: "TypedException() without generic argument specification.",
-        });
-        return false;
-      }
+//       const node: ts.TypeNode = props.decorator.expression.typeArguments![0];
+//       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+//       if (type.isTypeParameter()) {
+//         project.errors.push({
+//           file: props.controller.file,
+//           controller: props.controller.name,
+//           function: props.operation.name,
+//           message: "TypedException() without generic argument specification.",
+//         });
+//         return false;
+//       }
 
-      const tuple: ITypeTuple | null = ImportAnalyzer.analyze(project.checker)({
-        generics: props.generics,
-        imports: props.imports,
-        type,
-      });
-      if (tuple === null) {
-        project.errors.push({
-          file: props.controller.file,
-          controller: props.controller.name,
-          function: props.operation.name,
-          message: `TypeException() with unknown type on ${status} status.`,
-        });
-        return false;
-      }
+//       const tuple: ITypeTuple | null = ImportAnalyzer.analyze(project.checker)({
+//         generics: props.generics,
+//         imports: props.imports,
+//         type,
+//       });
+//       if (tuple === null) {
+//         project.errors.push({
+//           file: props.controller.file,
+//           controller: props.controller.name,
+//           function: props.operation.name,
+//           message: `TypeException() with unknown type on ${status} status.`,
+//         });
+//         return false;
+//       }
 
-      // DO ASSIGN
-      const matched: IReflectHttpOperation.IException[] = Object.entries(
-        props.operation.exceptions,
-      )
-        .filter(([key]) => status === key)
-        .map(([_key, value]) => value);
-      for (const m of matched)
-        props.output[m.status] = {
-          type: tuple.type,
-          typeName: tuple.typeName,
-          contentType: "application/json",
-          description: m.description,
-        };
-      return true;
-    };
+//       // DO ASSIGN
+//       const matched: IReflectHttpOperation.IException[] = Object.entries(
+//         props.operation.exceptions,
+//       )
+//         .filter(([key]) => status === key)
+//         .map(([_key, value]) => value);
+//       for (const m of matched)
+//         props.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 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 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 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",
-);
+// const TYPED_EXCEPTION_PATH = path.join(
+//   "node_modules",
+//   "@nestia",
+//   "core",
+//   "lib",
+//   "decorators",
+//   "TypedException.d.ts",
+// );

package/src/analyses/GenericAnalyzer.ts

@@ -1,20 +1,18 @@
 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();
+  ): WeakMap<ts.Type, ts.Type> {
+    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
     explore(checker, dict, classNode);
     return dict;
   }
 
   function explore(
     checker: ts.TypeChecker,
-    dict: Dictionary,
+    dict: WeakMap<ts.Type, ts.Type>,
     classNode: ts.ClassDeclaration,
   ): void {
     if (classNode.heritageClauses === undefined) return;

package/src/analyses/ImportAnalyzer.ts

@@ -1,57 +1,61 @@
-import { HashMap, HashSet } from "tstl";
 import ts from "typescript";
 
-import { ITypeTuple } from "../structures/ITypeTuple";
-import { GenericAnalyzer } from "./GenericAnalyzer";
+import { IReflectType } from "../structures/IReflectType";
+import { IReflectTypeImport } from "../structures/IReflectTypeImport";
+import { MapUtil } from "../utils/MapUtil";
 
 export namespace ImportAnalyzer {
   export interface IOutput {
-    features: [string, string[]][];
-    alias: string;
+    imports: IReflectTypeImport[];
+    type: IReflectType | null;
   }
-
-  export type Dictionary = HashMap<string, HashSet<string>>;
-
-  export const analyze =
-    (checker: ts.TypeChecker) =>
-    (props: {
-      generics: GenericAnalyzer.Dictionary;
-      imports: Dictionary;
-      type: ts.Type;
-    }): ITypeTuple | null => {
-      const type: ts.Type = get_type(checker)(props.type);
-      explore_escaped_name(checker)({
-        ...props,
-        type,
-      });
-      try {
-        return {
+  export const analyze = (
+    checker: ts.TypeChecker,
+    generics: WeakMap<ts.Type, ts.Type>,
+    type: ts.Type,
+  ): IOutput => {
+    const imports: Map<string, Set<string>> = new Map();
+    try {
+      type = escape(checker, type);
+      return {
+        type: explore({
+          checker,
+          generics,
+          imports,
           type,
-          typeName: explore_escaped_name(checker)({
-            ...props,
-            type,
-          }),
-        };
-      } catch {
-        return null;
-      }
-    };
+        }),
+        imports: [...imports].map(([file, instances]) => ({
+          file,
+          instances: Array.from(instances),
+        })),
+      };
+    } catch {
+      return {
+        imports: [],
+        type: null,
+      };
+    }
+  };
 
-  /* ---------------------------------------------------------
-        TYPE
-    --------------------------------------------------------- */
-  const 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;
-    };
+  export const unique = (
+    imports: IReflectTypeImport[],
+  ): IReflectTypeImport[] => {
+    const map: Map<string, Set<string>> = new Map();
+    imports.forEach(({ file, instances }) => {
+      const set: Set<string> = MapUtil.take(map, file, () => new Set());
+      instances.forEach((instance) => set.add(instance));
+    });
+    return [...map].map(([file, instances]) => ({
+      file,
+      instances: Array.from(instances),
+    }));
+  };
 
-  const escape_promise =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type): ts.Type => {
+  /* ---------------------------------------------------------
+    TYPE
+  --------------------------------------------------------- */
+  const escape = (checker: ts.TypeChecker, type: ts.Type): ts.Type => {
+    if (type.symbol && getNameOfSymbol(type.symbol) === "Promise") {
       const generic: readonly ts.Type[] = checker.getTypeArguments(
         type as ts.TypeReference,
       );
@@ -59,98 +63,109 @@ export namespace ImportAnalyzer {
         throw new Error(
           "Error on ImportAnalyzer.analyze(): invalid promise type.",
         );
-      return generic[0];
-    };
+      type = generic[0];
+    }
+    return type;
+  };
 
-  const get_name = (symbol: ts.Symbol): string =>
-    explore_name(
+  const getNameOfSymbol = (symbol: ts.Symbol): string =>
+    exploreName(
       symbol.escapedName.toString(),
       symbol.getDeclarations()?.[0]?.parent,
     );
 
   /* ---------------------------------------------------------
-        ESCAPED TEXT WITH IMPORT STATEMENTS
-    --------------------------------------------------------- */
-  const explore_escaped_name =
-    (checker: ts.TypeChecker) =>
-    (props: {
-      generics: GenericAnalyzer.Dictionary;
-      imports: Dictionary;
-      type: ts.Type;
-    }): string => {
-      //----
-      // CONDITIONAL BRANCHES
-      //----
-      // DECOMPOSE GENERIC ARGUMENT
-      let type: ts.Type = props.type;
-      while (props.generics.has(type) === true)
-        type = props.generics.get(type)!;
+    ESCAPED TEXT WITH IMPORT STATEMENTS
+  --------------------------------------------------------- */
+  const explore = (props: {
+    checker: ts.TypeChecker;
+    generics: WeakMap<ts.Type, ts.Type>;
+    imports: Map<string, Set<string>>;
+    type: ts.Type;
+  }): IReflectType => {
+    //----
+    // CONDITIONAL BRANCHES
+    //----
+    // DECOMPOSE GENERIC ARGUMENT
+    let type: ts.Type = props.type;
+    while (props.generics.has(type) === true) type = props.generics.get(type)!;
 
-      // PRIMITIVE
-      const symbol: ts.Symbol | undefined =
-        type.aliasSymbol ?? type.getSymbol();
+    // PRIMITIVE
+    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.symbol;
 
-      // UNION OR INTERSECT
-      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-        const joiner: string = type.isIntersection() ? " & " : " | ";
-        return type.types
+    // UNION OR INTERSECT
+    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+      const joiner: string = type.isIntersection() ? " & " : " | ";
+      return {
+        name: type.types
           .map((child) =>
-            explore_escaped_name(checker)({
+            explore({
               ...props,
               type: child,
             }),
           )
-          .join(joiner);
-      }
-      // NO SYMBOL
-      else if (symbol === undefined)
-        return checker.typeToString(
+          .map(getEscapedText)
+          .join(joiner),
+      };
+    }
+    // NO SYMBOL
+    else if (symbol === undefined)
+      return {
+        name: props.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;
-      else if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
-        const set: HashSet<string> = props.imports.take(
-          sourceFile.fileName,
-          () => new HashSet(),
-        );
-        set.insert(name.split(".")[0]);
-      }
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = getNameOfSymbol(symbol);
+    const sourceFile: ts.SourceFile | undefined =
+      symbol.declarations?.[0]?.getSourceFile();
+    if (sourceFile === undefined) return { name };
+    else if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
+      const set: Set<string> = MapUtil.take(
+        props.imports,
+        sourceFile.fileName,
+        () => new Set(),
+      );
+      set.add(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)({
-              ...props,
-              type: generic[0],
-            })
-          : `${name}<${generic
-              .map((child) =>
-                explore_escaped_name(checker)({
-                  ...props,
-                  type: child,
-                }),
-              )
-              .join(", ")}>`
-        : name;
-    };
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = type.aliasSymbol
+      ? type.aliasTypeArguments ?? []
+      : props.checker.getTypeArguments(type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? explore({
+            ...props,
+            type: generic[0],
+          })
+        : {
+            name,
+            typeArguments: generic.map((child) =>
+              explore({
+                ...props,
+                type: child,
+              }),
+            ),
+          }
+      : { name };
+  };
 
-  const explore_name = (name: string, decl?: ts.Node): string =>
+  const exploreName = (name: string, decl?: ts.Node): string =>
     decl && ts.isModuleBlock(decl)
-      ? explore_name(
+      ? exploreName(
           `${decl.parent.name.getFullText().trim()}.${name}`,
           decl.parent.parent,
         )
       : name;
+
+  const getEscapedText = (type: IReflectType): string =>
+    type.typeArguments
+      ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
+      : type.name;
 }