@nestia/sdk 8.0.8 → 9.0.0-dev.20251107

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 { 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;
-//     };
-
-//   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;
-
-//       // 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 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;
-//     };
-
-//   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",
-// );
+// 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";
+
+// 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;
+
+//       // 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;
+
+//       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;
+//       }
+
+//       // 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 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,49 +1,49 @@
-import ts from "typescript";
-
-export namespace GenericAnalyzer {
-  export function analyze(
-    checker: ts.TypeChecker,
-    classNode: ts.ClassDeclaration,
-  ): 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: WeakMap<ts.Type, ts.Type>,
-    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);
-        });
-
-        // RECURSIVE EXPLORATION
-        explore(checker, dict, superNode);
-      }
-  }
-}
+import ts from "typescript";
+
+export namespace GenericAnalyzer {
+  export function analyze(
+    checker: ts.TypeChecker,
+    classNode: ts.ClassDeclaration,
+  ): 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: WeakMap<ts.Type, ts.Type>,
+    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);
+        });
+
+        // RECURSIVE EXPLORATION
+        explore(checker, dict, superNode);
+      }
+  }
+}

package/src/analyses/ImportAnalyzer.ts

@@ -1,126 +1,126 @@
-import path from "path";
-import ts from "typescript";
-
-import { IReflectImport } from "../structures/IReflectImport";
-import { MapUtil } from "../utils/MapUtil";
-
-export namespace ImportAnalyzer {
-  export const analyze = (file: ts.SourceFile): IReflectImport[] =>
-    file.statements
-      .filter(ts.isImportDeclaration)
-      .map((imp) => {
-        const clause: ts.ImportClause | undefined = imp.importClause;
-        if (clause === undefined) return null;
-        try {
-          // no real position
-          // import statement generated by transformer like typia
-          imp.moduleSpecifier.getText();
-        } catch {
-          return null;
-        }
-
-        const reflect: IReflectImport = {
-          file: normalizePath(
-            path.dirname(file.fileName),
-            ts.isStringLiteral(imp.moduleSpecifier)
-              ? imp.moduleSpecifier.text
-              : escapeQuotes(imp.moduleSpecifier.getText()),
-          ),
-          elements: [],
-          default: null,
-          asterisk: null,
-        };
-        if (clause.name) reflect.default = clause.name.getText();
-        if (clause.namedBindings === undefined) return reflect;
-        else if (ts.isNamedImports(clause.namedBindings))
-          reflect.elements = clause.namedBindings.elements.map((e) =>
-            e.name.getText(),
-          );
-        else if (ts.isNamespaceImport(clause.namedBindings))
-          reflect.asterisk = clause.namedBindings.name.getText();
-        return reflect;
-      })
-      .filter((r) => r !== null);
-
-  export const merge = (imports: IReflectImport[]): IReflectImport[] => {
-    // group by files
-    const fileGroups: Map<string, IReflectImport[]> = new Map();
-    for (const imp of imports) {
-      const array: IReflectImport[] = MapUtil.take(
-        fileGroups,
-        imp.file,
-        () => [],
-      );
-      array.push(imp);
-    }
-    return Array.from(fileGroups.entries())
-      .map(([key, value]) => mergeGroup(key, value))
-      .flat();
-  };
-
-  function mergeGroup(
-    file: string,
-    imports: IReflectImport[],
-  ): IReflectImport[] {
-    const allStarImports: IReflectImport[] = Array.from(
-      new Set(
-        imports
-          .filter((imp) => imp.asterisk !== null)
-          .map((imp) => imp.asterisk!),
-      ),
-    )
-      .sort()
-      .map(
-        (allStarImport) =>
-          ({
-            file,
-            elements: [],
-            default: null,
-            asterisk: allStarImport,
-          }) satisfies IReflectImport,
-      );
-    const defaultImports: IReflectImport[] = Array.from(
-      new Set(
-        imports
-          .filter((imp) => imp.default !== null)
-          .map((imp) => imp.default!),
-      ),
-    )
-      .sort()
-      .map(
-        (defaultImport) =>
-          ({
-            file,
-            elements: [],
-            default: defaultImport,
-            asterisk: null,
-          }) satisfies IReflectImport,
-      );
-    const instances: Set<string> = new Set(
-      imports.map((imp) => imp.elements).flat(),
-    );
-    if (instances.size !== 0) {
-      if (defaultImports.length !== 0)
-        defaultImports[0].elements = Array.from(instances).sort();
-      else
-        defaultImports.push({
-          file,
-          elements: Array.from(instances).sort(),
-          default: null,
-          asterisk: null,
-        });
-    }
-    return [...allStarImports, ...defaultImports];
-  }
-
-  function escapeQuotes(str: string): string {
-    if (str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
-    else if (str.startsWith('"') && str.endsWith('"')) return str.slice(1, -1);
-    return str;
-  }
-
-  function normalizePath(root: string, str: string): string {
-    if (str.startsWith(".")) return path.resolve(root, str);
-    return `node_modules/${str}`;
-  }
-}
+import path from "path";
+import ts from "typescript";
+
+import { IReflectImport } from "../structures/IReflectImport";
+import { MapUtil } from "../utils/MapUtil";
+
+export namespace ImportAnalyzer {
+  export const analyze = (file: ts.SourceFile): IReflectImport[] =>
+    file.statements
+      .filter(ts.isImportDeclaration)
+      .map((imp) => {
+        const clause: ts.ImportClause | undefined = imp.importClause;
+        if (clause === undefined) return null;
+        try {
+          // no real position
+          // import statement generated by transformer like typia
+          imp.moduleSpecifier.getText();
+        } catch {
+          return null;
+        }
+
+        const reflect: IReflectImport = {
+          file: normalizePath(
+            path.dirname(file.fileName),
+            ts.isStringLiteral(imp.moduleSpecifier)
+              ? imp.moduleSpecifier.text
+              : escapeQuotes(imp.moduleSpecifier.getText()),
+          ),
+          elements: [],
+          default: null,
+          asterisk: null,
+        };
+        if (clause.name) reflect.default = clause.name.getText();
+        if (clause.namedBindings === undefined) return reflect;
+        else if (ts.isNamedImports(clause.namedBindings))
+          reflect.elements = clause.namedBindings.elements.map((e) =>
+            e.name.getText(),
+          );
+        else if (ts.isNamespaceImport(clause.namedBindings))
+          reflect.asterisk = clause.namedBindings.name.getText();
+        return reflect;
+      })
+      .filter((r) => r !== null);
+
+  export const merge = (imports: IReflectImport[]): IReflectImport[] => {
+    // group by files
+    const fileGroups: Map<string, IReflectImport[]> = new Map();
+    for (const imp of imports) {
+      const array: IReflectImport[] = MapUtil.take(
+        fileGroups,
+        imp.file,
+        () => [],
+      );
+      array.push(imp);
+    }
+    return Array.from(fileGroups.entries())
+      .map(([key, value]) => mergeGroup(key, value))
+      .flat();
+  };
+
+  function mergeGroup(
+    file: string,
+    imports: IReflectImport[],
+  ): IReflectImport[] {
+    const allStarImports: IReflectImport[] = Array.from(
+      new Set(
+        imports
+          .filter((imp) => imp.asterisk !== null)
+          .map((imp) => imp.asterisk!),
+      ),
+    )
+      .sort()
+      .map(
+        (allStarImport) =>
+          ({
+            file,
+            elements: [],
+            default: null,
+            asterisk: allStarImport,
+          }) satisfies IReflectImport,
+      );
+    const defaultImports: IReflectImport[] = Array.from(
+      new Set(
+        imports
+          .filter((imp) => imp.default !== null)
+          .map((imp) => imp.default!),
+      ),
+    )
+      .sort()
+      .map(
+        (defaultImport) =>
+          ({
+            file,
+            elements: [],
+            default: defaultImport,
+            asterisk: null,
+          }) satisfies IReflectImport,
+      );
+    const instances: Set<string> = new Set(
+      imports.map((imp) => imp.elements).flat(),
+    );
+    if (instances.size !== 0) {
+      if (defaultImports.length !== 0)
+        defaultImports[0].elements = Array.from(instances).sort();
+      else
+        defaultImports.push({
+          file,
+          elements: Array.from(instances).sort(),
+          default: null,
+          asterisk: null,
+        });
+    }
+    return [...allStarImports, ...defaultImports];
+  }
+
+  function escapeQuotes(str: string): string {
+    if (str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
+    else if (str.startsWith('"') && str.endsWith('"')) return str.slice(1, -1);
+    return str;
+  }
+
+  function normalizePath(root: string, str: string): string {
+    if (str.startsWith(".")) return path.resolve(root, str);
+    return `node_modules/${str}`;
+  }
+}