@nestia/sdk 7.1.1 → 7.2.1

package/src/structures/ITypedHttpRoute.ts

@@ -1,7 +1,7 @@
 import { IJsDocTagInfo } from "typia";
 
 import { IReflectController } from "./IReflectController";
-import { IReflectTypeImport } from "./IReflectTypeImport";
+import { IReflectImport } from "./IReflectImport";
 import { ITypedHttpRouteException } from "./ITypedHttpRouteException";
 import { ITypedHttpRouteParameter } from "./ITypedHttpRouteParameter";
 import { ITypedHttpRouteSuccess } from "./ITypedHttpRouteSuccess";
@@ -33,7 +33,7 @@ export interface ITypedHttpRoute {
   // ADDITIONAL INFORMATION
   security: Record<string, string[]>[];
   tags: string[];
-  imports: IReflectTypeImport[];
+  imports: IReflectImport[];
   description: string | null;
   jsDocTags: IJsDocTagInfo[];
   operationId: string | undefined;

package/src/structures/ITypedWebSocketRoute.ts

@@ -2,7 +2,7 @@ import { VERSION_NEUTRAL } from "@nestjs/common";
 import ts from "typescript";
 
 import { IReflectController } from "./IReflectController";
-import { IReflectTypeImport } from "./IReflectTypeImport";
+import { IReflectImport } from "./IReflectImport";
 import { ITypedWebSocketRouteParameter } from "./ITypedWebSocketRouteParameter";
 
 export interface ITypedWebSocketRoute {
@@ -18,7 +18,7 @@ export interface ITypedWebSocketRoute {
   pathParameters: ITypedWebSocketRouteParameter.IParam[];
   query: ITypedWebSocketRouteParameter.IQuery | null;
   driver: ITypedWebSocketRouteParameter.IDriver | null;
-  imports: IReflectTypeImport[];
+  imports: IReflectImport[];
   description: string | null;
   jsDocTags: ts.JSDocTagInfo[];
 }

package/src/transformers/IOperationMetadata.ts

@@ -3,8 +3,8 @@ import { IMetadata } from "typia/lib/schemas/metadata/IMetadata";
 import { IMetadataComponents } from "typia/lib/schemas/metadata/IMetadataComponents";
 import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
 
+import { IReflectImport } from "../structures/IReflectImport";
 import { IReflectType } from "../structures/IReflectType";
-import { IReflectTypeImport } from "../structures/IReflectTypeImport";
 
 export interface IOperationMetadata {
   parameters: IOperationMetadata.IParameter[];
@@ -22,13 +22,13 @@ export namespace IOperationMetadata {
   }
   export interface IResponse {
     type: IReflectType | null;
-    imports: IReflectTypeImport[];
+    imports: IReflectImport[];
     primitive: ValidationPipe<ISchema, IError>;
     resolved: ValidationPipe<ISchema, IError>;
   }
   export interface IException {
     type: IReflectType | null;
-    imports: IReflectTypeImport[];
+    imports: IReflectImport[];
     primitive: ValidationPipe<ISchema, IError>;
   }
 

package/src/transformers/SdkOperationProgrammer.ts

@@ -1,3 +1,4 @@
+import { Singleton } from "tstl";
 import ts from "typescript";
 import { CommentFactory } from "typia/lib/factories/CommentFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
@@ -8,7 +9,8 @@ import { MetadataObjectType } from "typia/lib/schemas/metadata/MetadataObjectTyp
 import { ValidationPipe } from "typia/lib/typings/ValidationPipe";
 import { Escaper } from "typia/lib/utils/Escaper";
 
-import { ImportAnalyzer } from "../analyses/ImportAnalyzer";
+import { DtoAnalyzer } from "../analyses/DtoAnalyzer";
+import { IReflectImport } from "../structures/IReflectImport";
 import { MetadataUtil } from "../utils/MetadataUtil";
 import { IOperationMetadata } from "./IOperationMetadata";
 import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
@@ -16,7 +18,7 @@ import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerConte
 export namespace SdkOperationProgrammer {
   export interface IProps {
     context: ISdkOperationTransformerContext;
-    generics: WeakMap<ts.Type, ts.Type>;
+    imports: Singleton<IReflectImport[]>;
     node: ts.MethodDeclaration;
     symbol: ts.Symbol | undefined;
     exceptions: ts.TypeNode[];
@@ -26,14 +28,15 @@ export namespace SdkOperationProgrammer {
       parameters: p.node.parameters.map((parameter, index) =>
         writeParameter({
           context: p.context,
-          generics: p.generics,
+          imports: p.imports,
           parameter,
           index,
         }),
       ),
       success: writeResponse({
         context: p.context,
-        generics: p.generics,
+        imports: p.imports,
+        typeNode: p.node.type ? getReturnTypeNode(p.node.type) : null,
         type: getReturnType({
           checker: p.context.checker,
           signature: p.context.checker.getSignatureFromDeclaration(p.node),
@@ -42,7 +45,8 @@ export namespace SdkOperationProgrammer {
       exceptions: p.exceptions.map((e) =>
         writeResponse({
           context: p.context,
-          generics: p.generics,
+          imports: p.imports,
+          typeNode: e,
           type: p.context.checker.getTypeFromTypeNode(e),
         }),
       ),
@@ -55,7 +59,7 @@ export namespace SdkOperationProgrammer {
 
   const writeParameter = (props: {
     context: ISdkOperationTransformerContext;
-    generics: WeakMap<ts.Type, ts.Type>;
+    imports: Singleton<IReflectImport[]>;
     parameter: ts.ParameterDeclaration;
     index: number;
   }): IOperationMetadata.IParameter => {
@@ -63,7 +67,8 @@ export namespace SdkOperationProgrammer {
       props.context.checker.getSymbolAtLocation(props.parameter);
     const common: IOperationMetadata.IResponse = writeResponse({
       context: props.context,
-      generics: props.generics,
+      imports: props.imports,
+      typeNode: props.parameter.type ?? null,
       type:
         props.context.checker.getTypeFromTypeNode(
           props.parameter.type ?? TypeFactory.keyword("any"),
@@ -86,15 +91,26 @@ export namespace SdkOperationProgrammer {
 
   const writeResponse = (p: {
     context: ISdkOperationTransformerContext;
-    generics: WeakMap<ts.Type, ts.Type>;
+    imports: Singleton<IReflectImport[]>;
+    typeNode: ts.TypeNode | null;
     type: ts.Type | null;
   }): IOperationMetadata.IResponse => {
-    const analyzed: ImportAnalyzer.IOutput = p.type
-      ? ImportAnalyzer.analyze(p.context.checker, p.generics, p.type)
-      : {
-          type: { name: "any" },
-          imports: [],
-        };
+    const analyzed: DtoAnalyzer.IOutput | null = p.typeNode
+      ? DtoAnalyzer.analyzeNode({
+          checker: p.context.checker,
+          imports: p.imports.get(),
+          typeNode: p.typeNode,
+        })
+      : p.type
+        ? DtoAnalyzer.analyzeType({
+            checker: p.context.checker,
+            imports: p.imports.get(),
+            type: p.type,
+          })
+        : {
+            type: { name: "any" },
+            imports: [],
+          };
     const [primitive, resolved] = [true, false].map((escape) =>
       MetadataFactory.analyze({
         checker: p.context.checker,
@@ -109,7 +125,12 @@ export namespace SdkOperationProgrammer {
       }),
     );
     return {
-      ...analyzed,
+      ...(analyzed
+        ? analyzed
+        : {
+            imports: [],
+            type: null,
+          }),
       primitive: writeSchema({
         collection: p.context.collection,
         result: primitive,
@@ -166,22 +187,6 @@ export namespace SdkOperationProgrammer {
       },
     };
   };
-
-  const getReturnType = (p: {
-    checker: ts.TypeChecker;
-    signature: ts.Signature | undefined;
-  }): ts.Type | null => {
-    const type: ts.Type | null =
-      (p.signature && p.checker.getReturnTypeOfSignature(p.signature)) ?? null;
-    if (type === null) return null;
-    else if (type.symbol?.name === "Promise") {
-      const generic: readonly ts.Type[] = p.checker.getTypeArguments(
-        type as ts.TypeReference,
-      );
-      return generic[0] ?? null;
-    }
-    return type;
-  };
 }
 
 const iterateVisited = (metadata: Metadata): Set<string> => {
@@ -207,3 +212,27 @@ const join = ({
   else if (Escaper.variable(key)) return `${object.name}.${key}`;
   return `${object.name}[${JSON.stringify(key)}]`;
 };
+
+const getReturnTypeNode = (node: ts.TypeNode): ts.TypeNode | null => {
+  if (ts.isTypeReferenceNode(node)) {
+    const typeName: string = node.typeName.getText();
+    if (typeName === "Promise") return node.typeArguments?.[0] ?? null;
+  }
+  return node;
+};
+
+const getReturnType = (p: {
+  checker: ts.TypeChecker;
+  signature: ts.Signature | undefined;
+}): ts.Type | null => {
+  const type: ts.Type | null =
+    (p.signature && p.checker.getReturnTypeOfSignature(p.signature)) ?? null;
+  if (type === null) return null;
+  else if (type.symbol?.name === "Promise") {
+    const generic: readonly ts.Type[] = p.checker.getTypeArguments(
+      type as ts.TypeReference,
+    );
+    return generic[0] ?? null;
+  }
+  return type;
+};

package/src/transformers/SdkOperationTransformer.ts

@@ -5,7 +5,8 @@ import { LiteralFactory } from "typia/lib/factories/LiteralFactory";
 import { MetadataCollection } from "typia/lib/factories/MetadataCollection";
 import { TypeFactory } from "typia/lib/factories/TypeFactory";
 
-import { GenericAnalyzer } from "../analyses/GenericAnalyzer";
+import { ImportAnalyzer } from "../analyses/ImportAnalyzer";
+import { IReflectImport } from "../structures/IReflectImport";
 import { IOperationMetadata } from "./IOperationMetadata";
 import { ISdkOperationTransformerContext } from "./ISdkOperationTransformerContext";
 import { SdkOperationProgrammer } from "./SdkOperationProgrammer";
@@ -29,6 +30,7 @@ export namespace SdkOperationTransformer {
           (node) =>
             iterateNode({
               context,
+              imports: new Singleton(() => ImportAnalyzer.analyze(file)),
               visitor,
               node,
             }),
@@ -62,6 +64,7 @@ export namespace SdkOperationTransformer {
 
   const iterateNode = (props: {
     context: ISdkOperationTransformerContext;
+    imports: Singleton<IReflectImport[]>;
     visitor: IVisitor;
     node: ts.Node;
   }): ts.Node =>
@@ -77,6 +80,7 @@ export namespace SdkOperationTransformer {
 
   const transformNode = (props: {
     context: ISdkOperationTransformerContext;
+    imports: Singleton<IReflectImport[]>;
     visitor: IVisitor;
     node: ts.Node;
   }): ts.Node => {
@@ -91,13 +95,9 @@ export namespace SdkOperationTransformer {
   const transformClass = (props: {
     context: ISdkOperationTransformerContext;
     visitor: IVisitor;
+    imports: Singleton<IReflectImport[]>;
     node: ts.ClassDeclaration;
   }): ts.ClassDeclaration => {
-    const generics: WeakMap<ts.Type, ts.Type> = GenericAnalyzer.analyze(
-      props.context.checker,
-      props.node,
-    );
-
     // TO AVOID COMMENT COMPILATION BUG
     const symbolDict: Map<string, ts.Symbol> = new Map();
     const classType: ts.InterfaceType = props.context.checker.getTypeAtLocation(
@@ -121,7 +121,6 @@ export namespace SdkOperationTransformer {
         ts.isMethodDeclaration(m)
           ? transformMethod({
               ...props,
-              generics,
               class: props.node,
               node: m,
               symbol: symbolDict.get(m.name.getText()),
@@ -134,8 +133,8 @@ export namespace SdkOperationTransformer {
   const transformMethod = (props: {
     context: ISdkOperationTransformerContext;
     visitor: IVisitor;
+    imports: Singleton<IReflectImport[]>;
     class: ts.ClassDeclaration;
-    generics: WeakMap<ts.Type, ts.Type>;
     node: ts.MethodDeclaration;
     symbol: ts.Symbol | undefined;
   }): ts.MethodDeclaration => {

package/lib/structures/IReflectTypeImport.d.ts

@@ -1,4 +0,0 @@
-export interface IReflectTypeImport {
-    file: string;
-    instances: string[];
-}

package/lib/structures/IReflectTypeImport.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"IReflectTypeImport.js","sourceRoot":"","sources":["../../src/structures/IReflectTypeImport.ts"],"names":[],"mappings":""}

package/src/structures/IReflectTypeImport.ts

@@ -1,4 +0,0 @@
-export interface IReflectTypeImport {
-  file: string;
-  instances: string[];
-}