ts-class-to-openapi 1.2.2 → 1.2.4

package/dist/index.js

@@ -68,14 +68,14 @@ class SchemaTransformer {
         this.program = ts.createProgram(fileNames, tsOptions);
         this.checker = this.program.getTypeChecker();
     }
-    getPropertiesByClassDeclaration(classNode, visitedDeclarations = new Set()) {
+    getPropertiesByClassDeclaration(classNode, visitedDeclarations = new Set(), genericTypeMap = new Map()) {
         if (visitedDeclarations.has(classNode)) {
             return [];
         }
         visitedDeclarations.add(classNode);
         // if no heritage clauses, get properties directly from class
         if (!classNode.heritageClauses) {
-            return this.getPropertiesByClassMembers(classNode.members, classNode);
+            return this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
         } // use heritage clauses to get properties from base classes
         else {
             const heritageClause = classNode.heritageClauses[0];
@@ -91,24 +91,42 @@ class SchemaTransformer {
                     return [];
                 const declaration = symbol.declarations?.[0];
                 if (declaration && ts.isClassDeclaration(declaration)) {
-                    baseProperties = this.getPropertiesByClassDeclaration(declaration, visitedDeclarations);
+                    const newGenericTypeMap = new Map();
+                    if (declaration.typeParameters && type.typeArguments) {
+                        declaration.typeParameters.forEach((param, index) => {
+                            const arg = type.typeArguments[index];
+                            if (arg) {
+                                const resolvedArg = this.getTypeNodeToString(arg, genericTypeMap);
+                                newGenericTypeMap.set(param.name.text, resolvedArg);
+                            }
+                        });
+                    }
+                    baseProperties = this.getPropertiesByClassDeclaration(declaration, visitedDeclarations, newGenericTypeMap);
                 }
-                properties = this.getPropertiesByClassMembers(classNode.members, classNode);
+                properties = this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
                 return baseProperties.concat(properties);
             }
             else {
-                return this.getPropertiesByClassMembers(classNode.members, classNode);
+                return this.getPropertiesByClassMembers(classNode.members, classNode, genericTypeMap);
             }
         }
     }
-    getPropertiesByClassMembers(members, parentClassNode) {
+    getPropertiesByClassMembers(members, parentClassNode, genericTypeMap = new Map()) {
         const properties = [];
         for (const member of members) {
             if (ts.isPropertyDeclaration(member) &&
                 member.name &&
                 ts.isIdentifier(member.name)) {
+                // Skip static, private, and protected properties
+                if (member.modifiers) {
+                    const hasExcludedModifier = member.modifiers.some(m => m.kind === ts.SyntaxKind.StaticKeyword ||
+                        m.kind === ts.SyntaxKind.PrivateKeyword ||
+                        m.kind === ts.SyntaxKind.ProtectedKeyword);
+                    if (hasExcludedModifier)
+                        continue;
+                }
                 const propertyName = member.name.text;
-                const type = this.getPropertyType(member);
+                const type = this.getPropertyType(member, genericTypeMap);
                 const decorators = this.extractDecorators(member);
                 const isOptional = !!member.questionToken;
                 const isGeneric = this.isPropertyTypeGeneric(member);
@@ -168,17 +186,21 @@ class SchemaTransformer {
         }
         return properties;
     }
-    getPropertyType(property) {
+    getPropertyType(property, genericTypeMap = new Map()) {
         if (property.type) {
-            return this.getTypeNodeToString(property.type);
+            return this.getTypeNodeToString(property.type, genericTypeMap);
         }
         const type = this.checker.getTypeAtLocation(property);
         return this.getStringFromType(type);
     }
-    getTypeNodeToString(typeNode) {
+    getTypeNodeToString(typeNode, genericTypeMap = new Map()) {
         if (ts.isTypeReferenceNode(typeNode) &&
             ts.isIdentifier(typeNode.typeName)) {
-            if (typeNode.typeName.text.toLowerCase() === 'uploadfile') {
+            const typeName = typeNode.typeName.text;
+            if (genericTypeMap.has(typeName)) {
+                return genericTypeMap.get(typeName);
+            }
+            if (typeName.toLowerCase() === 'uploadfile') {
                 return 'UploadFile';
             }
             if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
@@ -203,11 +225,11 @@ class SchemaTransformer {
                 return constants.jsPrimitives.Boolean.type;
             case ts.SyntaxKind.ArrayType:
                 const arrayType = typeNode;
-                return `${this.getTypeNodeToString(arrayType.elementType)}[]`;
+                return `${this.getTypeNodeToString(arrayType.elementType, genericTypeMap)}[]`;
             case ts.SyntaxKind.UnionType:
                 // Handle union types like string | null
                 const unionType = typeNode;
-                const types = unionType.types.map(t => this.getTypeNodeToString(t));
+                const types = unionType.types.map(t => this.getTypeNodeToString(t, genericTypeMap));
                 // Filter out null and undefined, return the first meaningful type
                 const meaningfulTypes = types.filter(t => t !== 'null' && t !== 'undefined');
                 if (meaningfulTypes.length > 0 && meaningfulTypes[0]) {
@@ -219,6 +241,10 @@ class SchemaTransformer {
                 return 'object';
             default:
                 const typeText = typeNode.getText();
+                // Check if this is a generic type parameter we can resolve
+                if (genericTypeMap && genericTypeMap.has(typeText)) {
+                    return genericTypeMap.get(typeText);
+                }
                 // Handle some common TypeScript utility types
                 if (typeText.startsWith('Date'))
                     return constants.jsPrimitives.Date.type;
@@ -453,37 +479,159 @@ class SchemaTransformer {
         }
         return SchemaTransformer.instance;
     }
-    getSourceFileByClassName(className, sourceOptions) {
-        let sourceFiles = [];
-        if (sourceOptions?.isExternal) {
-            sourceFiles = this.program.getSourceFiles().filter(sf => {
-                return (sf.fileName.includes(sourceOptions.packageName) &&
-                    (!sourceOptions.filePath || sf.fileName === sourceOptions.filePath));
-            });
+    getSourceFileByClass(cls, sourceOptions) {
+        const className = cls.name;
+        const sourceFiles = this.getFilteredSourceFiles(sourceOptions);
+        const matches = [];
+        for (const sourceFile of sourceFiles) {
+            const node = sourceFile.statements.find(stmt => ts.isClassDeclaration(stmt) &&
+                stmt.name &&
+                stmt.name.text === className);
+            if (node) {
+                matches.push({ sourceFile, node });
+            }
         }
-        else {
-            sourceFiles = this.program.getSourceFiles().filter(sf => {
-                if (sf.isDeclarationFile)
-                    return false;
-                if (sf.fileName.includes('.d.ts'))
-                    return false;
-                if (sf.fileName.includes('node_modules'))
-                    return false;
+        if (matches.length === 0) {
+            return undefined;
+        }
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        if (matches.length > 1 && !sourceOptions?.filePath) {
+            const bestMatch = this.findBestMatch(cls, matches);
+            if (bestMatch) {
+                return bestMatch;
+            }
+            const firstMatch = matches[0];
+            if (firstMatch) {
+                console.warn(`[ts-class-to-openapi] Warning: Found multiple classes with name '${className}'. Using the first one found in '${firstMatch.sourceFile.fileName}'. To resolve this collision, provide 'sourceOptions.filePath'.`);
+            }
+        }
+        return matches[0];
+    }
+    checkTypeMatch(value, typeNode) {
+        const runtimeType = typeof value;
+        if (runtimeType === 'string' &&
+            typeNode.kind === ts.SyntaxKind.StringKeyword)
+            return true;
+        if (runtimeType === 'number' &&
+            typeNode.kind === ts.SyntaxKind.NumberKeyword)
+            return true;
+        if (runtimeType === 'boolean' &&
+            typeNode.kind === ts.SyntaxKind.BooleanKeyword)
+            return true;
+        if (Array.isArray(value) && ts.isArrayTypeNode(typeNode)) {
+            if (value.length === 0)
+                return true;
+            const firstItem = value[0];
+            const elementType = typeNode.elementType;
+            return this.checkTypeMatch(firstItem, elementType);
+        }
+        if (runtimeType === 'object' && value !== null && !Array.isArray(value)) {
+            if (ts.isTypeReferenceNode(typeNode) ||
+                typeNode.kind === ts.SyntaxKind.ObjectKeyword) {
                 return true;
+            }
+        }
+        return false;
+    }
+    findBestMatch(cls, matches) {
+        const runtimeSource = cls.toString();
+        const runtimeProperties = new Map();
+        const regexProperties = new Set();
+        // Try to extract properties from runtime source (assignments in constructor)
+        try {
+            const regex = /this\.([a-zA-Z0-9_$]+)\s*=/g;
+            let match;
+            while ((match = regex.exec(runtimeSource)) !== null) {
+                regexProperties.add(match[1]);
+            }
+        }
+        catch (e) {
+            // Ignore regex errors
+        }
+        // Try to instantiate the class to find properties
+        try {
+            const instance = new cls();
+            Object.keys(instance).forEach(key => {
+                runtimeProperties.set(key, instance[key]);
             });
         }
-        for (const sourceFile of sourceFiles) {
-            let node;
-            const found = sourceFile.statements.some(stmt => {
-                node = stmt;
-                return (ts.isClassDeclaration(stmt) &&
-                    stmt.name &&
-                    stmt.name.text === className);
+        catch (e) {
+            // Ignore instantiation errors (e.g. required constructor arguments)
+        }
+        // Try to get properties from class-validator metadata
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { getMetadataStorage } = require('class-validator');
+            const metadata = getMetadataStorage();
+            const targetMetadata = metadata.getTargetValidationMetadatas(cls, null, false, false);
+            targetMetadata.forEach((m) => {
+                if (m.propertyName && !runtimeProperties.has(m.propertyName)) {
+                    runtimeProperties.set(m.propertyName, undefined);
+                }
             });
-            if (found) {
-                return { sourceFile, node: node };
+        }
+        catch (e) {
+            // Ignore if class-validator is not available or fails
+        }
+        // console.log(`[findBestMatch] Class: ${cls.name}, Runtime Props: ${Array.from(runtimeProperties.keys()).join(', ')}`)
+        const scores = matches.map(match => {
+            let score = 0;
+            for (const member of match.node.members) {
+                if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
+                    if (runtimeSource.includes(member.name.text)) {
+                        score += 2;
+                    }
+                }
+                else if (ts.isPropertyDeclaration(member) &&
+                    ts.isIdentifier(member.name)) {
+                    const propName = member.name.text;
+                    if (runtimeProperties.has(propName)) {
+                        score += 1;
+                        const value = runtimeProperties.get(propName);
+                        if (member.type && this.checkTypeMatch(value, member.type)) {
+                            score += 5;
+                        }
+                    }
+                    else if (regexProperties.has(propName)) {
+                        score += 1;
+                    }
+                }
+            }
+            return { match, score };
+        });
+        scores.sort((a, b) => b.score - a.score);
+        const firstScore = scores[0];
+        const secondScore = scores[1];
+        if (firstScore && firstScore.score > 0) {
+            if (scores.length === 1 ||
+                (secondScore && firstScore.score > secondScore.score)) {
+                return firstScore.match;
             }
         }
+        return undefined;
+    }
+    getFilteredSourceFiles(sourceOptions) {
+        if (sourceOptions?.isExternal) {
+            return this.program.getSourceFiles().filter(sf => {
+                return (sf.fileName.includes(sourceOptions.packageName) &&
+                    (!sourceOptions.filePath || sf.fileName === sourceOptions.filePath));
+            });
+        }
+        return this.program.getSourceFiles().filter(sf => {
+            if (sf.isDeclarationFile)
+                return false;
+            if (sf.fileName.includes('.d.ts'))
+                return false;
+            if (sf.fileName.includes('node_modules'))
+                return false;
+            if (sourceOptions?.filePath &&
+                !sf.fileName.includes(sourceOptions.filePath)) {
+                return false;
+            }
+            return true;
+        });
     }
     isEnum(propertyDeclaration) {
         if (!propertyDeclaration.type) {
@@ -1032,7 +1180,7 @@ class SchemaTransformer {
     }
     transform(cls, sourceOptions) {
         let schema = { type: 'object', properties: {} };
-        const result = this.getSourceFileByClassName(cls.name, sourceOptions);
+        const result = this.getSourceFileByClass(cls, sourceOptions);
         if (!result?.sourceFile) {
             console.warn(`Class ${cls.name} not found in any source file.`);
             return { name: cls.name, schema: {} };