@tsoa-next/cli 8.0.3 → 8.0.4-dev.53.2c0aa7c6

package/dist/metadataGeneration/typeResolver.js

@@ -53,8 +53,26 @@ const localReferenceTypeCache = {};
 const inProgressTypes = {};
 const escapedDoubleQuote = String.raw `\"`;
 const backslash = '\\';
+const symbolModuleOriginCache = new WeakMap();
+const ioTsUtilityTypeCache = new WeakMap();
 const hasInitializer = (declaration) => 'initializer' in declaration && declaration.initializer !== undefined;
 const objectHasOwn = Object.hasOwn;
+const getSymbolModuleOriginCache = (typeChecker) => {
+    let cache = symbolModuleOriginCache.get(typeChecker);
+    if (!cache) {
+        cache = new WeakMap();
+        symbolModuleOriginCache.set(typeChecker, cache);
+    }
+    return cache;
+};
+const getIoTsUtilityTypeCache = (typeChecker) => {
+    let cache = ioTsUtilityTypeCache.get(typeChecker);
+    if (!cache) {
+        cache = new WeakMap();
+        ioTsUtilityTypeCache.set(typeChecker, cache);
+    }
+    return cache;
+};
 const getSyntheticOrigin = (symbol) => {
     const symbolWithLinks = symbol;
     return symbolWithLinks.links?.syntheticOrigin;
@@ -175,6 +193,10 @@ class TypeResolver {
         });
     }
     resolve() {
+        const recoverableTypeReference = this.getRecoverableTypeReferenceNode();
+        if (recoverableTypeReference) {
+            return this.resolveTypeReferenceNode(recoverableTypeReference, this.current, this.context, this.parentNode);
+        }
         const parentJsDocTagNames = this.parentNode ? (0, jsDocUtils_1.getJSDocTagNames)(this.parentNode) : undefined;
         const primitiveType = new primitiveTransformer_1.PrimitiveTransformer().transform(this.current.defaultNumberType, this.typeNode, parentJsDocTagNames);
         if (primitiveType) {
@@ -187,6 +209,13 @@ class TypeResolver {
         (0, flowUtils_1.throwUnless)(ts.isTypeReferenceNode(this.typeNode), new exceptions_1.GenerateMetadataError(`Unknown type: ${ts.SyntaxKind[this.typeNode.kind]}`, this.typeNode));
         return this.resolveTypeReferenceNode(this.typeNode, this.current, this.context, this.parentNode);
     }
+    getRecoverableTypeReferenceNode() {
+        if (!ts.isIdentifier(this.typeNode) && !ts.isQualifiedName(this.typeNode)) {
+            return undefined;
+        }
+        const parent = this.typeNode.parent;
+        return parent && ts.isTypeReferenceNode(parent) && parent.typeName === this.typeNode ? parent : undefined;
+    }
     resolveNonReferenceTypeNode() {
         return (this.resolveArrayTypeNode() ??
             this.resolveRestTypeNode() ??
@@ -505,7 +534,7 @@ class TypeResolver {
         if (!contextualType) {
             return undefined;
         }
-        const subResult = new TypeResolver(contextualType.type, current, parentNode, context).resolve();
+        const subResult = new TypeResolver(contextualType.type, current, parentNode, context, contextualType.resolvedType).resolve();
         if (subResult.dataType === 'any') {
             return this.createStringAndNumberUnion();
         }
@@ -617,14 +646,15 @@ class TypeResolver {
     }
     resolveIndexedAccessLiteralType(typeNode, typeChecker, current, context, objectType, indexType) {
         const propertyName = ts.isStringLiteral(indexType.literal) || ts.isNumericLiteral(indexType.literal) ? indexType.literal.text : indexType.literal.getText();
-        const symbol = typeChecker.getPropertyOfType(typeChecker.getTypeFromTypeNode(objectType), propertyName);
-        (0, flowUtils_1.throwUnless)(symbol, new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeChecker.typeToString(typeChecker.getTypeFromTypeNode(objectType))}`, typeNode));
+        const { type: resolvedObjectType, typeNode: resolvedObjectTypeNode } = this.resolveContextualIndexedAccessObjectType(objectType, typeChecker, context);
+        const symbol = typeChecker.getPropertyOfType(resolvedObjectType, propertyName);
+        (0, flowUtils_1.throwUnless)(symbol, new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeChecker.typeToString(resolvedObjectType)}`, typeNode));
         if (this.symbolHasTypeDeclaration(symbol.valueDeclaration)) {
             return new TypeResolver(symbol.valueDeclaration.type, current, typeNode, context).resolve();
         }
-        const declarationType = typeChecker.getTypeOfSymbolAtLocation(symbol, objectType);
+        const declarationType = typeChecker.getTypeOfSymbolAtLocation(symbol, resolvedObjectTypeNode);
         try {
-            return new TypeResolver(typeChecker.typeToTypeNode(declarationType, objectType, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
+            return new TypeResolver(typeChecker.typeToTypeNode(declarationType, resolvedObjectTypeNode, ts.NodeBuilderFlags.NoTruncation), current, typeNode, context).resolve();
         }
         catch {
             const typeNodeForError = typeChecker.typeToTypeNode(declarationType, undefined, ts.NodeBuilderFlags.NoTruncation);
@@ -632,6 +662,24 @@ class TypeResolver {
             throw new exceptions_1.GenerateMetadataError(`Could not determine the keys on ${typeName}`, typeNode);
         }
     }
+    resolveContextualIndexedAccessObjectType(objectType, typeChecker, context) {
+        const contextualTypeNode = this.getContextualIndexedAccessObjectTypeNode(objectType, context);
+        const resolvedTypeNode = contextualTypeNode ?? objectType;
+        const contextualType = contextualTypeNode && ts.isTypeReferenceNode(objectType) && ts.isIdentifier(objectType.typeName) ? context[objectType.typeName.text] : undefined;
+        return {
+            type: contextualType?.resolvedType ?? typeChecker.getTypeFromTypeNode(resolvedTypeNode),
+            typeNode: resolvedTypeNode,
+        };
+    }
+    getContextualIndexedAccessObjectTypeNode(objectType, context) {
+        if (ts.isParenthesizedTypeNode(objectType)) {
+            return this.getContextualIndexedAccessObjectTypeNode(objectType.type, context);
+        }
+        if (!ts.isTypeReferenceNode(objectType) || !ts.isIdentifier(objectType.typeName)) {
+            return undefined;
+        }
+        return context[objectType.typeName.text]?.type;
+    }
     symbolHasTypeDeclaration(node) {
         return node !== undefined && objectHasOwn(node, 'type') && node.type !== undefined;
     }
@@ -691,13 +739,13 @@ class TypeResolver {
         const decodedSymbol = current.typeChecker.getPropertyOfType(codecType, '_A');
         if (decodedSymbol) {
             const decodedType = current.typeChecker.getTypeOfSymbolAtLocation(decodedSymbol, codecTypeArgument);
-            const decodedNode = current.typeChecker.typeToTypeNode(decodedType, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation);
+            const decodedNode = this.normalizeTypeNodeFromBuilder(current.typeChecker.typeToTypeNode(decodedType, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation));
             if (decodedNode) {
                 return new TypeResolver(decodedNode, current, parentNode, context, decodedType).resolve();
             }
         }
         const resolvedType = current.typeChecker.getTypeFromTypeNode(typeNode);
-        const resolvedNode = current.typeChecker.typeToTypeNode(resolvedType, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation);
+        const resolvedNode = this.normalizeTypeNodeFromBuilder(current.typeChecker.typeToTypeNode(resolvedType, undefined, ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.NoTruncation));
         if (resolvedNode && !ts.isTypeReferenceNode(resolvedNode)) {
             return new TypeResolver(resolvedNode, current, parentNode, context, resolvedType).resolve();
         }
@@ -720,14 +768,15 @@ class TypeResolver {
                 return undefined;
             case 'Promise':
                 if (typeArguments?.length === 1) {
-                    return new TypeResolver(typeArguments[0], current, parentNode, context).resolve();
+                    const promisedType = this.getPromisedTypeOfReferencer(current.typeChecker);
+                    return new TypeResolver(typeArguments[0], current, parentNode, context, promisedType).resolve();
                 }
                 return undefined;
             case 'String':
                 return { dataType: 'string' };
             default:
                 if (context[typeName]) {
-                    return new TypeResolver(context[typeName].type, current, parentNode, context).resolve();
+                    return new TypeResolver(context[typeName].type, current, parentNode, context, context[typeName].resolvedType).resolve();
                 }
                 return undefined;
         }
@@ -759,46 +808,73 @@ class TypeResolver {
         if (!symbol || visited.has(symbol)) {
             return undefined;
         }
+        const cache = getIoTsUtilityTypeCache(typeChecker);
+        if (cache.has(symbol)) {
+            const cachedType = cache.get(symbol);
+            return cachedType || undefined;
+        }
         visited.add(symbol);
         if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
             const aliasedSymbol = typeChecker.getAliasedSymbol(symbol);
             const aliasedType = this.getIoTsUtilityTypeFromSymbol(aliasedSymbol, typeChecker, visited);
             if (aliasedType) {
+                cache.set(symbol, aliasedType);
                 return aliasedType;
             }
         }
         const symbolName = symbol.getName();
         if ((symbolName === 'TypeOf' || symbolName === 'Branded' || symbolName === 'Brand') && this.symbolComesFromModule(symbol, typeChecker, 'io-ts')) {
+            cache.set(symbol, symbolName);
             return symbolName;
         }
+        cache.set(symbol, false);
         return undefined;
     }
     symbolComesFromModule(symbol, typeChecker, moduleName, visited = new Set()) {
         if (visited.has(symbol)) {
             return false;
         }
+        const moduleCache = getSymbolModuleOriginCache(typeChecker);
+        const cachedByModule = moduleCache.get(symbol);
+        const cachedResult = cachedByModule?.get(moduleName);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
         visited.add(symbol);
+        const comesFromModule = this.symbolDeclarationsComeFromModule(symbol, moduleName) || this.aliasedSymbolComesFromModule(symbol, typeChecker, moduleName, visited);
+        if (cachedByModule) {
+            cachedByModule.set(moduleName, comesFromModule);
+        }
+        else {
+            moduleCache.set(symbol, new Map([[moduleName, comesFromModule]]));
+        }
+        return comesFromModule;
+    }
+    symbolDeclarationsComeFromModule(symbol, moduleName) {
         const declarations = symbol.declarations || (symbol.valueDeclaration ? [symbol.valueDeclaration] : []);
-        for (const declaration of declarations) {
-            let current = declaration.parent;
-            while (current && !ts.isImportDeclaration(current)) {
-                current = current.parent;
-            }
-            if (current && ts.isImportDeclaration(current) && ts.isStringLiteral(current.moduleSpecifier) && current.moduleSpecifier.text === moduleName) {
-                return true;
-            }
-            const fileName = declaration.getSourceFile().fileName.replaceAll('\\', '/');
-            if (fileName.includes(`/node_modules/${moduleName}/`)) {
-                return true;
-            }
+        return declarations.some(declaration => this.declarationComesFromModule(declaration, moduleName));
+    }
+    declarationComesFromModule(declaration, moduleName) {
+        const containingImportModuleSpecifier = this.getContainingImportModuleSpecifier(declaration);
+        if (containingImportModuleSpecifier === moduleName) {
+            return true;
         }
-        if ((symbol.flags & ts.SymbolFlags.Alias) !== 0) {
-            const aliasedSymbol = typeChecker.getAliasedSymbol(symbol);
-            if (aliasedSymbol !== symbol) {
-                return this.symbolComesFromModule(aliasedSymbol, typeChecker, moduleName, visited);
-            }
+        const fileName = declaration.getSourceFile().fileName.replaceAll('\\', '/');
+        return fileName.includes(`/node_modules/${moduleName}/`);
+    }
+    getContainingImportModuleSpecifier(node) {
+        let current = node.parent;
+        while (current && !ts.isImportDeclaration(current)) {
+            current = current.parent;
         }
-        return false;
+        return current && ts.isStringLiteral(current.moduleSpecifier) ? current.moduleSpecifier.text : undefined;
+    }
+    aliasedSymbolComesFromModule(symbol, typeChecker, moduleName, visited) {
+        if ((symbol.flags & ts.SymbolFlags.Alias) === 0) {
+            return false;
+        }
+        const aliasedSymbol = typeChecker.getAliasedSymbol(symbol);
+        return aliasedSymbol !== symbol && this.symbolComesFromModule(aliasedSymbol, typeChecker, moduleName, visited);
     }
     getLiteralValue(typeNode) {
         switch (typeNode.literal.kind) {
@@ -1377,48 +1453,81 @@ class TypeResolver {
         return undefined;
     }
     typeArgumentsToContext(type, targetEntity) {
-        let newContext = {};
         // Inline object types don't contribute generic declarations, so they map to an empty context.
-        if (!this.current.typeChecker) {
-            return newContext;
-        }
-        if (!ts.isIdentifier(targetEntity) && !ts.isQualifiedName(targetEntity)) {
-            return newContext;
-        }
-        const declarations = this.getModelTypeDeclarations(targetEntity);
-        const firstDeclaration = declarations[0];
-        const typeParameters = firstDeclaration?.typeParameters;
-        if (typeParameters) {
-            for (let index = 0; index < typeParameters.length; index++) {
-                const typeParameter = typeParameters[index];
-                const typeArg = type.typeArguments?.[index];
-                let resolvedType;
-                let name;
-                // Argument may be a forward reference from context
-                if (typeArg && ts.isTypeReferenceNode(typeArg) && ts.isIdentifier(typeArg.typeName) && this.context[typeArg.typeName.text]) {
-                    resolvedType = this.context[typeArg.typeName.text].type;
-                    name = this.context[typeArg.typeName.text].name;
-                }
-                else if (typeArg) {
-                    resolvedType = typeArg;
-                }
-                else if (typeParameter.default) {
-                    resolvedType = typeParameter.default;
-                }
-                else {
-                    throw new exceptions_1.GenerateMetadataError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
-                }
-                newContext = {
-                    ...newContext,
-                    [typeParameter.name.text]: {
-                        type: resolvedType,
-                        name: name || this.calcTypeName(resolvedType),
-                    },
-                };
-            }
+        const typeParameters = this.getTypeParametersForTargetEntity(targetEntity);
+        if (!typeParameters?.length) {
+            return {};
+        }
+        let newContext = {};
+        for (let index = 0; index < typeParameters.length; index += 1) {
+            const typeParameter = typeParameters[index];
+            const resolvedType = this.resolveContextualTypeArgument(type, typeParameter, index);
+            newContext = {
+                ...newContext,
+                [typeParameter.name.text]: {
+                    type: resolvedType.type,
+                    name: resolvedType.name || this.calcTypeName(resolvedType.type),
+                    resolvedType: resolvedType.resolvedType,
+                },
+            };
         }
         return newContext;
     }
+    getTypeParametersForTargetEntity(targetEntity) {
+        if (!this.current.typeChecker || (!ts.isIdentifier(targetEntity) && !ts.isQualifiedName(targetEntity))) {
+            return undefined;
+        }
+        const firstDeclaration = this.getModelTypeDeclarations(targetEntity)[0];
+        return firstDeclaration?.typeParameters;
+    }
+    resolveContextualTypeArgument(type, typeParameter, index) {
+        const typeArgument = type.typeArguments?.[index];
+        const contextualType = this.getForwardReferencedContextType(typeArgument);
+        if (contextualType) {
+            return contextualType;
+        }
+        const resolvedType = typeArgument ?? typeParameter.default;
+        if (!resolvedType) {
+            throw new exceptions_1.GenerateMetadataError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
+        }
+        return {
+            type: resolvedType,
+            name: undefined,
+            resolvedType: this.getResolvedTypeForContextTypeArgument(resolvedType, index),
+        };
+    }
+    getForwardReferencedContextType(typeArgument) {
+        if (!typeArgument || !ts.isTypeReferenceNode(typeArgument) || !ts.isIdentifier(typeArgument.typeName)) {
+            return undefined;
+        }
+        return this.context[typeArgument.typeName.text];
+    }
+    getResolvedTypeForContextTypeArgument(typeNode, index) {
+        if (typeNode.pos === -1) {
+            return this.getReferencerTypeArgument(index);
+        }
+        return this.current.typeChecker.getTypeFromTypeNode(typeNode);
+    }
+    getReferencerTypeArgument(index) {
+        const referencer = this.referencer;
+        return referencer?.aliasTypeArguments?.[index] ?? referencer?.typeArguments?.[index];
+    }
+    getPromisedTypeOfReferencer(typeChecker) {
+        if (!this.referencer) {
+            return undefined;
+        }
+        const extendedTypeChecker = typeChecker;
+        return extendedTypeChecker.getPromisedTypeOfPromise?.(this.referencer);
+    }
+    normalizeTypeNodeFromBuilder(node) {
+        if (!node) {
+            return undefined;
+        }
+        if (ts.isIdentifier(node) || ts.isQualifiedName(node)) {
+            return ts.factory.createTypeReferenceNode(node, undefined);
+        }
+        return node;
+    }
     getReferenceAliasProperties(referenceType) {
         let type = referenceType;
         while (type.dataType === 'refAlias') {