ts-class-to-openapi 1.0.3 → 1.0.5

package/dist/run.js

@@ -38,6 +38,7 @@ const validatorDecorators = {
     ArrayNotEmpty: { name: 'ArrayNotEmpty' },
     ArrayMaxSize: { name: 'ArrayMaxSize' },
     ArrayMinSize: { name: 'ArrayMinSize' },
+    IsEnum: { name: 'IsEnum', type: 'string' },
 };
 const constants = {
     TS_CONFIG_DEFAULT_PATH,
@@ -96,6 +97,12 @@ class SchemaTransformer {
      * @private
      */
     loadedFiles = new Set();
+    /**
+     * Set of class names currently being processed to prevent circular references
+     * Key format: "fileName:className" for uniqueness across different files
+     * @private
+     */
+    processingClasses = new Set();
     /**
      * Private constructor for singleton pattern.
      *
@@ -148,20 +155,19 @@ class SchemaTransformer {
         }
     }
     /**
-     * Gets relevant source files for a class, filtering out unnecessary files to save memory.
+     * Transforms a class by its name into an OpenAPI schema object.
+     * Considers the context of the calling file to resolve ambiguous class names.
+     * Includes circular reference detection to prevent infinite recursion.
      *
-     * @param className - The name of the class to find files for
-     * @param filePath - Optional specific file path
-     * @returns Array of relevant source files
+     * @param className - The name of the class to transform
+     * @param contextFilePath - Optional path to context file for resolving class ambiguity
+     * @returns Object containing the class name and its corresponding JSON schema
+     * @throws {Error} When the specified class cannot be found
      * @private
      */
-    getRelevantSourceFiles(className, filePath) {
-        if (filePath) {
-            const sourceFile = this.program.getSourceFile(filePath);
-            return sourceFile ? [sourceFile] : [];
-        }
-        // Only get source files that are not declaration files and not in node_modules
-        return this.program.getSourceFiles().filter(sf => {
+    transformByName(className, contextFilePath) {
+        // Get all relevant source files (not declaration files and not in node_modules)
+        const sourceFiles = this.program.getSourceFiles().filter(sf => {
             if (sf.isDeclarationFile)
                 return false;
             if (sf.fileName.includes('.d.ts'))
@@ -172,19 +178,46 @@ class SchemaTransformer {
             this.loadedFiles.add(sf.fileName);
             return true;
         });
-    }
-    /**
-     * Transforms a class by its name into an OpenAPI schema object.
-     *
-     * @param className - The name of the class to transform
-     * @param filePath - Optional path to the file containing the class
-     * @returns Object containing the class name and its corresponding JSON schema
-     * @throws {Error} When the specified class cannot be found
-     * @private
-     */
-    transformByName(className, filePath) {
-        const sourceFiles = this.getRelevantSourceFiles(className, filePath);
-        for (const sourceFile of sourceFiles) {
+        // If we have a context file, try to find the class in that file first
+        if (contextFilePath) {
+            const contextSourceFile = this.program.getSourceFile(contextFilePath);
+            if (contextSourceFile) {
+                const classNode = this.findClassByName(contextSourceFile, className);
+                if (classNode) {
+                    const cacheKey = this.getCacheKey(contextSourceFile.fileName, className);
+                    // Check cache first
+                    if (this.classCache.has(cacheKey)) {
+                        return this.classCache.get(cacheKey);
+                    }
+                    // Check for circular reference before processing
+                    if (this.processingClasses.has(cacheKey)) {
+                        // Return a $ref reference to break circular dependency (OpenAPI 3.1 style)
+                        return {
+                            name: className,
+                            schema: {
+                                $ref: `#/components/schemas/${className}`,
+                                description: `Reference to ${className} (circular reference detected)`,
+                            },
+                        };
+                    }
+                    // Mark this class as being processed
+                    this.processingClasses.add(cacheKey);
+                    try {
+                        const result = this.transformClass(classNode, contextSourceFile);
+                        this.classCache.set(cacheKey, result);
+                        this.cleanupCache();
+                        return result;
+                    }
+                    finally {
+                        // Always remove from processing set when done
+                        this.processingClasses.delete(cacheKey);
+                    }
+                }
+            }
+        }
+        // Fallback to searching all files, but prioritize files that are more likely to be relevant
+        const prioritizedFiles = this.prioritizeSourceFiles(sourceFiles, contextFilePath);
+        for (const sourceFile of prioritizedFiles) {
             const classNode = this.findClassByName(sourceFile, className);
             if (classNode && sourceFile?.fileName) {
                 const cacheKey = this.getCacheKey(sourceFile.fileName, className);
@@ -192,16 +225,67 @@ class SchemaTransformer {
                 if (this.classCache.has(cacheKey)) {
                     return this.classCache.get(cacheKey);
                 }
-                const result = this.transformClass(classNode);
-                // Cache using fileName:className as key for uniqueness
-                this.classCache.set(cacheKey, result);
-                // Clean up cache if it gets too large
-                this.cleanupCache();
-                return result;
+                // Check for circular reference before processing
+                if (this.processingClasses.has(cacheKey)) {
+                    // Return a $ref reference to break circular dependency (OpenAPI 3.1 style)
+                    return {
+                        name: className,
+                        schema: {
+                            $ref: `#/components/schemas/${className}`,
+                            description: `Reference to ${className} (circular reference detected)`,
+                        },
+                    };
+                }
+                // Mark this class as being processed
+                this.processingClasses.add(cacheKey);
+                try {
+                    const result = this.transformClass(classNode, sourceFile);
+                    // Cache using fileName:className as key for uniqueness
+                    this.classCache.set(cacheKey, result);
+                    // Clean up cache if it gets too large
+                    this.cleanupCache();
+                    return result;
+                }
+                finally {
+                    // Always remove from processing set when done
+                    this.processingClasses.delete(cacheKey);
+                }
             }
         }
         throw new Error(`Class ${className} not found`);
     }
+    /**
+     * Prioritizes source files based on context to resolve class name conflicts.
+     * Gives priority to files in the same directory or with similar names.
+     *
+     * @param sourceFiles - Array of source files to prioritize
+     * @param contextFilePath - Optional path to context file for prioritization
+     * @returns Prioritized array of source files
+     * @private
+     */
+    prioritizeSourceFiles(sourceFiles, contextFilePath) {
+        if (!contextFilePath) {
+            return sourceFiles;
+        }
+        const contextDir = contextFilePath.substring(0, contextFilePath.lastIndexOf('/'));
+        return sourceFiles.sort((a, b) => {
+            const aDir = a.fileName.substring(0, a.fileName.lastIndexOf('/'));
+            const bDir = b.fileName.substring(0, b.fileName.lastIndexOf('/'));
+            // Prioritize files in the same directory as context
+            const aInSameDir = aDir === contextDir ? 1 : 0;
+            const bInSameDir = bDir === contextDir ? 1 : 0;
+            if (aInSameDir !== bInSameDir) {
+                return bInSameDir - aInSameDir; // Higher priority first
+            }
+            // Prioritize non-test files over test files
+            const aIsTest = a.fileName.includes('test') || a.fileName.includes('spec') ? 0 : 1;
+            const bIsTest = b.fileName.includes('test') || b.fileName.includes('spec') ? 0 : 1;
+            if (aIsTest !== bIsTest) {
+                return bIsTest - aIsTest; // Non-test files first
+            }
+            return 0;
+        });
+    }
     /**
      * Gets the singleton instance of SchemaTransformer.
      *
@@ -228,16 +312,88 @@ class SchemaTransformer {
     /**
      * Clears the current singleton instance. Useful for testing or when you need
      * to create a new instance with different configuration.
+     * @private
      */
     static clearInstance() {
-        SchemaTransformer.instance = null;
+        SchemaTransformer.instance = undefined;
+    }
+    /**
+     * Flag to prevent recursive disposal calls
+     * @private
+     */
+    static disposingInProgress = false;
+    /**
+     * Completely disposes of the current singleton instance and releases all resources.
+     * This is a static method that can be called without having an instance reference.
+     * Ensures complete memory cleanup regardless of the current state.
+     *
+     * @example
+     * ```typescript
+     * SchemaTransformer.disposeInstance();
+     * // All resources released, next getInstance() will create fresh instance
+     * ```
+     *
+     * @public
+     */
+    static disposeInstance() {
+        // Prevent recursive disposal calls
+        if (SchemaTransformer.disposingInProgress) {
+            return;
+        }
+        SchemaTransformer.disposingInProgress = true;
+        try {
+            if (SchemaTransformer.instance) {
+                SchemaTransformer.instance.dispose();
+            }
+        }
+        catch (error) {
+            // Log any disposal errors but continue with cleanup
+            console.warn('Warning during static disposal:', error);
+        }
+        finally {
+            // Always ensure the static instance is cleared
+            SchemaTransformer.instance = undefined;
+            SchemaTransformer.disposingInProgress = false;
+            // Force garbage collection for cleanup
+            if (global.gc) {
+                global.gc();
+            }
+        }
+    }
+    /**
+     * @deprecated Use disposeInstance() instead for better clarity
+     * @private
+     */
+    static dispose() {
+        SchemaTransformer.disposeInstance();
     }
     static getInstance(tsConfigPath, options) {
-        if (!SchemaTransformer.instance) {
+        if (!SchemaTransformer.instance || SchemaTransformer.isInstanceDisposed()) {
             SchemaTransformer.instance = new SchemaTransformer(tsConfigPath, options);
         }
         return SchemaTransformer.instance;
     }
+    /**
+     * Internal method to check if current instance is disposed
+     * @private
+     */
+    static isInstanceDisposed() {
+        return SchemaTransformer.instance
+            ? SchemaTransformer.instance.isDisposed()
+            : true;
+    }
+    /**
+     * Transforms a class using the singleton instance
+     * @param cls - The class constructor function to transform
+     * @param options - Optional configuration for memory management (only used if no instance exists)
+     * @returns Object containing the class name and its corresponding JSON schema
+     * @public
+     */
+    static transformClass(cls, options) {
+        // Use the singleton instance instead of creating a temporary one
+        const transformer = SchemaTransformer.getInstance(undefined, options);
+        return transformer.transform(cls);
+    }
     /**
      * Transforms a class constructor function into an OpenAPI schema object.
      *
@@ -272,31 +428,147 @@ class SchemaTransformer {
     clearCache() {
         this.classCache.clear();
         this.loadedFiles.clear();
+        this.processingClasses.clear();
         // Force garbage collection hint if available
         if (global.gc) {
             global.gc();
         }
     }
+    /**
+     * Completely disposes of the transformer instance and releases all resources.
+     * This includes clearing all caches, releasing TypeScript program resources,
+     * and resetting the singleton instance.
+     *
+     * After calling this method, you need to call getInstance() again to get a new instance.
+     *
+     * @example
+     * ```typescript
+     * const transformer = SchemaTransformer.getInstance();
+     * // ... use transformer
+     * transformer.dispose();
+     * // transformer is now unusable, need to get new instance
+     * const newTransformer = SchemaTransformer.getInstance();
+     * ```
+     *
+     * @private
+     */
+    dispose() {
+        try {
+            // Clear all caches and sets completely
+            this.classCache.clear();
+            this.loadedFiles.clear();
+            this.processingClasses.clear();
+            // Release TypeScript program resources
+            // While TypeScript doesn't provide explicit disposal methods,
+            // we can help garbage collection by clearing all references
+            // Clear all references to TypeScript objects
+            // @ts-ignore - We're intentionally setting these to null for cleanup
+            this.program = null;
+            // @ts-ignore - We're intentionally setting these to null for cleanup
+            this.checker = null;
+        }
+        catch (error) {
+            // If there's any error during disposal, log it but continue
+            console.warn('Warning during transformer disposal:', error);
+        }
+        finally {
+            // Force garbage collection for cleanup
+            if (global.gc) {
+                global.gc();
+            }
+        }
+    }
+    /**
+     * Completely resets the transformer by disposing current instance and creating a new one.
+     * This is useful when you need a fresh start with different TypeScript configuration
+     * or want to ensure all resources are properly released and recreated.
+     *
+     * @param tsConfigPath - Optional path to a specific TypeScript config file for the new instance
+     * @param options - Configuration options for memory management for the new instance
+     * @returns A fresh SchemaTransformer instance
+     *
+     * @example
+     * ```typescript
+     * const transformer = SchemaTransformer.getInstance();
+     * // ... use transformer
+     * const freshTransformer = transformer.reset('./new-tsconfig.json');
+     * ```
+     *
+     * @private
+     */
+    reset(tsConfigPath, options) {
+        // Dispose current instance using static method to properly clear instance reference
+        SchemaTransformer.disposeInstance();
+        // Create and return new instance
+        return SchemaTransformer.getInstance(tsConfigPath, options);
+    }
     /**
      * Gets memory usage statistics for monitoring and debugging.
      *
-     * @returns Object containing cache size and loaded files count
+     * @returns Object containing cache size, loaded files count, and processing status
      *
      * @example
      * ```typescript
      * const transformer = SchemaTransformer.getInstance();
      * const stats = transformer.getMemoryStats();
      * console.log(`Cache entries: ${stats.cacheSize}, Files loaded: ${stats.loadedFiles}`);
+     * console.log(`Currently processing: ${stats.currentlyProcessing} classes`);
      * ```
      *
-     * @public
+     * @private
      */
     getMemoryStats() {
         return {
-            cacheSize: this.classCache.size,
-            loadedFiles: this.loadedFiles.size,
+            cacheSize: this.classCache?.size || 0,
+            loadedFiles: this.loadedFiles?.size || 0,
+            currentlyProcessing: this.processingClasses?.size || 0,
+            maxCacheSize: this.maxCacheSize || 0,
+            autoCleanup: this.autoCleanup || false,
+            isDisposed: !this.program || !this.checker,
         };
     }
+    /**
+     * Checks if the transformer instance has been disposed and is no longer usable.
+     *
+     * @returns True if the instance has been disposed
+     *
+     * @example
+     * ```typescript
+     * const transformer = SchemaTransformer.getInstance();
+     * transformer.dispose();
+     * console.log(transformer.isDisposed()); // true
+     * ```
+     *
+     * @private
+     */
+    isDisposed() {
+        return (!this.program ||
+            !this.checker ||
+            !this.classCache ||
+            !this.loadedFiles ||
+            !this.processingClasses);
+    }
+    /**
+     * Static method to check if there's an active singleton instance.
+     *
+     * @returns True if there's an active instance, false if disposed or never created
+     *
+     * @example
+     * ```typescript
+     * console.log(SchemaTransformer.hasActiveInstance()); // false
+     * const transformer = SchemaTransformer.getInstance();
+     * console.log(SchemaTransformer.hasActiveInstance()); // true
+     * SchemaTransformer.dispose();
+     * console.log(SchemaTransformer.hasActiveInstance()); // false
+     * ```
+     *
+     * @private
+     */
+    static hasActiveInstance() {
+        return (SchemaTransformer.instance !== null &&
+            SchemaTransformer.instance !== undefined &&
+            !SchemaTransformer.isInstanceDisposed());
+    }
     /**
      * Finds a class declaration by name within a source file.
      *
@@ -321,13 +593,14 @@ class SchemaTransformer {
      * Transforms a TypeScript class declaration into a schema object.
      *
      * @param classNode - The TypeScript class declaration node
+     * @param sourceFile - The source file containing the class (for context)
      * @returns Object containing class name and generated schema
      * @private
      */
-    transformClass(classNode) {
+    transformClass(classNode, sourceFile) {
         const className = classNode.name?.text || 'Unknown';
         const properties = this.extractProperties(classNode);
-        const schema = this.generateSchema(properties);
+        const schema = this.generateSchema(properties, sourceFile?.fileName);
         return { name: className, schema };
     }
     /**
@@ -371,6 +644,237 @@ class SchemaTransformer {
         const type = this.checker.getTypeAtLocation(property);
         return this.checker.typeToString(type);
     }
+    /**
+     * Resolves generic types by analyzing the type alias and its arguments.
+     * For example, User<Role> where User is a type alias will be resolved to its structure.
+     *
+     * @param typeNode - The TypeScript type reference node with generic arguments
+     * @returns String representation of the resolved type or schema
+     * @private
+     */
+    resolveGenericType(typeNode) {
+        const typeName = typeNode.typeName.text;
+        const typeArguments = typeNode.typeArguments;
+        if (!typeArguments || typeArguments.length === 0) {
+            return typeName;
+        }
+        // Try to resolve the type using the TypeScript type checker
+        const type = this.checker.getTypeAtLocation(typeNode);
+        const resolvedType = this.checker.typeToString(type);
+        // If we can resolve it to a meaningful structure, use that
+        if (resolvedType &&
+            resolvedType !== typeName &&
+            !resolvedType.includes('any')) {
+            // For type aliases like User<Role>, we want to create a synthetic type name
+            // that represents the resolved structure
+            const typeArgNames = typeArguments.map(arg => {
+                if (ts.isTypeReferenceNode(arg) && ts.isIdentifier(arg.typeName)) {
+                    return arg.typeName.text;
+                }
+                return this.getTypeNodeToString(arg);
+            });
+            return `${typeName}_${typeArgNames.join('_')}`;
+        }
+        return typeName;
+    }
+    /**
+     * Checks if a type string represents a resolved generic type.
+     *
+     * @param type - The type string to check
+     * @returns True if it's a resolved generic type
+     * @private
+     */
+    isResolvedGenericType(type) {
+        // Simple heuristic: resolved generic types contain underscores and
+        // the parts after underscore should be known types
+        const parts = type.split('_');
+        return (parts.length > 1 &&
+            parts
+                .slice(1)
+                .every(part => this.isKnownType(part) || this.isPrimitiveType(part)));
+    }
+    /**
+     * Checks if a type is a known class or interface.
+     *
+     * @param typeName - The type name to check
+     * @returns True if it's a known type
+     * @private
+     */
+    isKnownType(typeName) {
+        // First check if it's a primitive type to avoid unnecessary lookups
+        if (this.isPrimitiveType(typeName)) {
+            return true;
+        }
+        try {
+            // Use a more conservative approach - check if we can find the class
+            // without actually transforming it to avoid side effects
+            const found = this.findClassInProject(typeName);
+            return found !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Finds a class by name in the project without transforming it.
+     *
+     * @param className - The class name to find
+     * @returns True if found, false otherwise
+     * @private
+     */
+    findClassInProject(className) {
+        const 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;
+            return true;
+        });
+        for (const sourceFile of sourceFiles) {
+            const found = this.findClassByName(sourceFile, className);
+            if (found)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if a type is a primitive type.
+     *
+     * @param typeName - The type name to check
+     * @returns True if it's a primitive type
+     * @private
+     */
+    isPrimitiveType(typeName) {
+        const lowerTypeName = typeName.toLowerCase();
+        // Check against all primitive types from constants
+        const primitiveTypes = [
+            constants.jsPrimitives.String.type.toLowerCase(),
+            constants.jsPrimitives.Number.type.toLowerCase(),
+            constants.jsPrimitives.Boolean.type.toLowerCase(),
+            constants.jsPrimitives.Date.type.toLowerCase(),
+            constants.jsPrimitives.Buffer.type.toLowerCase(),
+            constants.jsPrimitives.Uint8Array.type.toLowerCase(),
+            constants.jsPrimitives.File.type.toLowerCase(),
+            constants.jsPrimitives.UploadFile.type.toLowerCase(),
+            constants.jsPrimitives.BigInt.type.toLowerCase(),
+        ];
+        return primitiveTypes.includes(lowerTypeName);
+    }
+    /**
+     * Resolves a generic type schema by analyzing the type alias structure.
+     *
+     * @param resolvedTypeName - The resolved generic type name (e.g., User_Role)
+     * @returns OpenAPI schema for the resolved generic type
+     * @private
+     */
+    resolveGenericTypeSchema(resolvedTypeName) {
+        const parts = resolvedTypeName.split('_');
+        const baseTypeName = parts[0];
+        const typeArgNames = parts.slice(1);
+        if (!baseTypeName) {
+            return null;
+        }
+        // Find the original type alias declaration
+        const typeAliasSymbol = this.findTypeAliasDeclaration(baseTypeName);
+        if (!typeAliasSymbol) {
+            return null;
+        }
+        // Create a schema based on the type alias structure, substituting type parameters
+        return this.createSchemaFromTypeAlias(typeAliasSymbol, typeArgNames);
+    }
+    /**
+     * Finds a type alias declaration by name.
+     *
+     * @param typeName - The type alias name to find
+     * @returns The type alias declaration node or null
+     * @private
+     */
+    findTypeAliasDeclaration(typeName) {
+        for (const sourceFile of this.program.getSourceFiles()) {
+            if (sourceFile.isDeclarationFile)
+                continue;
+            const findTypeAlias = (node) => {
+                if (ts.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+                    return node;
+                }
+                return ts.forEachChild(node, findTypeAlias) || null;
+            };
+            const result = findTypeAlias(sourceFile);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    /**
+     * Creates a schema from a type alias declaration, substituting type parameters.
+     *
+     * @param typeAlias - The type alias declaration
+     * @param typeArgNames - The concrete type arguments
+     * @returns OpenAPI schema for the type alias
+     * @private
+     */
+    createSchemaFromTypeAlias(typeAlias, typeArgNames) {
+        const typeNode = typeAlias.type;
+        if (ts.isTypeLiteralNode(typeNode)) {
+            const schema = {
+                type: 'object',
+                properties: {},
+                required: [],
+            };
+            for (const member of typeNode.members) {
+                if (ts.isPropertySignature(member) &&
+                    member.name &&
+                    ts.isIdentifier(member.name)) {
+                    const propertyName = member.name.text;
+                    const isOptional = !!member.questionToken;
+                    if (member.type) {
+                        const propertyType = this.resolveTypeParameterInTypeAlias(member.type, typeAlias.typeParameters, typeArgNames);
+                        const { type, format, nestedSchema } = this.mapTypeToSchema(propertyType);
+                        if (nestedSchema) {
+                            schema.properties[propertyName] = nestedSchema;
+                        }
+                        else {
+                            schema.properties[propertyName] = { type };
+                            if (format)
+                                schema.properties[propertyName].format = format;
+                        }
+                        if (!isOptional) {
+                            schema.required.push(propertyName);
+                        }
+                    }
+                }
+            }
+            return schema;
+        }
+        return null;
+    }
+    /**
+     * Resolves type parameters in a type alias to concrete types.
+     *
+     * @param typeNode - The type node to resolve
+     * @param typeParameters - The type parameters of the type alias
+     * @param typeArgNames - The concrete type arguments
+     * @returns The resolved type string
+     * @private
+     */
+    resolveTypeParameterInTypeAlias(typeNode, typeParameters, typeArgNames) {
+        if (ts.isTypeReferenceNode(typeNode) &&
+            ts.isIdentifier(typeNode.typeName)) {
+            const typeName = typeNode.typeName.text;
+            // Check if this is a type parameter
+            if (typeParameters) {
+                const paramIndex = typeParameters.findIndex(param => param.name.text === typeName);
+                if (paramIndex !== -1 && paramIndex < typeArgNames.length) {
+                    const resolvedType = typeArgNames[paramIndex];
+                    return resolvedType || typeName;
+                }
+            }
+            return typeName;
+        }
+        return this.getTypeNodeToString(typeNode);
+    }
     /**
      * Converts a TypeScript type node to its string representation.
      *
@@ -396,6 +900,7 @@ class SchemaTransformer {
                         return firstTypeArg.typeName.text;
                     }
                 }
+                return this.resolveGenericType(typeNode);
             }
             return typeNode.typeName.text;
         }
@@ -494,19 +999,24 @@ class SchemaTransformer {
      * Generates an OpenAPI schema from extracted property information.
      *
      * @param properties - Array of property information to process
+     * @param contextFilePath - Optional context file path for resolving class references
      * @returns Complete OpenAPI schema object with properties and validation rules
      * @private
      */
-    generateSchema(properties) {
+    generateSchema(properties, contextFilePath) {
         const schema = {
             type: 'object',
             properties: {},
             required: [],
         };
         for (const property of properties) {
-            const { type, format, nestedSchema } = this.mapTypeToSchema(property.type);
+            const { type, format, nestedSchema } = this.mapTypeToSchema(property.type, contextFilePath);
             if (nestedSchema) {
                 schema.properties[property.name] = nestedSchema;
+                // Skip decorator application for $ref schemas
+                if (this.isRefSchema(nestedSchema)) {
+                    continue;
+                }
             }
             else {
                 schema.properties[property.name] = { type };
@@ -529,14 +1039,15 @@ class SchemaTransformer {
      * Handles primitive types, arrays, and nested objects recursively.
      *
      * @param type - The TypeScript type string to map
+     * @param contextFilePath - Optional context file path for resolving class references
      * @returns Object containing OpenAPI type, optional format, and nested schema
      * @private
      */
-    mapTypeToSchema(type) {
+    mapTypeToSchema(type, contextFilePath) {
         // Handle arrays
         if (type.endsWith('[]')) {
             const elementType = type.slice(0, -2);
-            const elementSchema = this.mapTypeToSchema(elementType);
+            const elementSchema = this.mapTypeToSchema(elementType, contextFilePath);
             const items = elementSchema.nestedSchema || {
                 type: elementSchema.type,
             };
@@ -580,9 +1091,31 @@ class SchemaTransformer {
                     format: constants.jsPrimitives.UploadFile.format,
                 };
             default:
+                // Check if it's a resolved generic type (e.g., User_Role)
+                if (type.includes('_') && this.isResolvedGenericType(type)) {
+                    try {
+                        const genericSchema = this.resolveGenericTypeSchema(type);
+                        if (genericSchema) {
+                            return {
+                                type: constants.jsPrimitives.Object.value,
+                                nestedSchema: genericSchema,
+                            };
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Failed to resolve generic type ${type}:`, error);
+                    }
+                }
                 // Handle nested objects
                 try {
-                    const nestedResult = this.transformByName(type);
+                    const nestedResult = this.transformByName(type, contextFilePath);
+                    // Check if it's a $ref schema (circular reference)
+                    if (nestedResult.schema.$ref) {
+                        return {
+                            type: constants.jsPrimitives.Object.value,
+                            nestedSchema: nestedResult.schema,
+                        };
+                    }
                     return {
                         type: constants.jsPrimitives.Object.value,
                         nestedSchema: nestedResult.schema,
@@ -593,6 +1126,16 @@ class SchemaTransformer {
                 }
         }
     }
+    /**
+     * Checks if a schema is a $ref schema (circular reference).
+     *
+     * @param schema - The schema to check
+     * @returns True if it's a $ref schema
+     * @private
+     */
+    isRefSchema(schema) {
+        return '$ref' in schema;
+    }
     /**
      * Applies class-validator decorators to schema properties.
      * Maps validation decorators to their corresponding OpenAPI schema constraints.
@@ -603,6 +1146,10 @@ class SchemaTransformer {
      * @private
      */
     applyDecorators(decorators, schema, propertyName) {
+        // Skip applying decorators to $ref schemas
+        if (this.isRefSchema(schema)) {
+            return;
+        }
         const isArrayType = schema.properties[propertyName].type ===
             constants.jsPrimitives.Array.value;
         for (const decorator of decorators) {
@@ -718,8 +1265,193 @@ class SchemaTransformer {
                 case constants.validatorDecorators.ArrayMaxSize.name:
                     schema.properties[propertyName].maxItems = decorator.arguments[0];
                     break;
+                case constants.validatorDecorators.IsEnum.name:
+                    this.applyEnumDecorator(decorator, schema, propertyName, isArrayType);
+                    break;
+            }
+        }
+    }
+    /**
+     * Applies the @IsEnum decorator to a property, handling both primitive values and object enums.
+     * Supports arrays of enum values as well.
+     *
+     * @param decorator - The IsEnum decorator information
+     * @param schema - The schema object to modify
+     * @param propertyName - The name of the property
+     * @param isArrayType - Whether the property is an array type
+     * @private
+     */
+    applyEnumDecorator(decorator, schema, propertyName, isArrayType) {
+        if (!decorator.arguments || decorator.arguments.length === 0) {
+            return;
+        }
+        const enumArg = decorator.arguments[0];
+        let enumValues = [];
+        // Handle different enum argument types
+        if (typeof enumArg === 'string') {
+            // This is likely a reference to an enum type name
+            // We need to try to resolve this to actual enum values
+            enumValues = this.resolveEnumValues(enumArg);
+        }
+        else if (typeof enumArg === 'object' && enumArg !== null) {
+            // Object enum - extract values
+            if (Array.isArray(enumArg)) {
+                // Already an array of values
+                enumValues = enumArg;
+            }
+            else {
+                // Enum object - get all values
+                enumValues = Object.values(enumArg);
+            }
+        }
+        // If we couldn't resolve enum values, fall back to string type without enum constraint
+        if (enumValues.length === 0) {
+            if (!isArrayType) {
+                schema.properties[propertyName].type = 'string';
+            }
+            else if (schema.properties[propertyName].items) {
+                schema.properties[propertyName].items.type = 'string';
+            }
+            return;
+        }
+        // Determine the type based on enum values
+        let enumType = 'string';
+        if (enumValues.length > 0) {
+            const firstValue = enumValues[0];
+            if (typeof firstValue === 'number') {
+                enumType = 'number';
+            }
+            else if (typeof firstValue === 'boolean') {
+                enumType = 'boolean';
+            }
+        }
+        // Apply enum to schema
+        if (!isArrayType) {
+            schema.properties[propertyName].type = enumType;
+            schema.properties[propertyName].enum = enumValues;
+        }
+        else if (schema.properties[propertyName].items) {
+            schema.properties[propertyName].items.type = enumType;
+            schema.properties[propertyName].items.enum = enumValues;
+        }
+    }
+    /**
+     * Attempts to resolve enum values from an enum type name.
+     * This searches through the TypeScript AST to find the enum declaration
+     * and extract its values.
+     *
+     * @param enumTypeName - The name of the enum type
+     * @returns Array of enum values if found, empty array otherwise
+     * @private
+     */
+    resolveEnumValues(enumTypeName) {
+        // Search for enum declarations in source files
+        for (const sourceFile of this.program.getSourceFiles()) {
+            if (sourceFile.isDeclarationFile)
+                continue;
+            if (sourceFile.fileName.includes('node_modules'))
+                continue;
+            const enumValues = this.findEnumValues(sourceFile, enumTypeName);
+            if (enumValues.length > 0) {
+                return enumValues;
+            }
+        }
+        return [];
+    }
+    /**
+     * Finds enum values in a specific source file.
+     *
+     * @param sourceFile - The source file to search
+     * @param enumTypeName - The name of the enum to find
+     * @returns Array of enum values if found, empty array otherwise
+     * @private
+     */
+    findEnumValues(sourceFile, enumTypeName) {
+        let enumValues = [];
+        const visit = (node) => {
+            // Handle TypeScript enum declarations
+            if (ts.isEnumDeclaration(node) && node.name?.text === enumTypeName) {
+                enumValues = this.extractEnumValues(node);
+                return;
+            }
+            // Handle const object declarations (like const Status = { ... } as const)
+            if (ts.isVariableStatement(node)) {
+                for (const declaration of node.declarationList.declarations) {
+                    if (ts.isVariableDeclaration(declaration) &&
+                        ts.isIdentifier(declaration.name) &&
+                        declaration.name.text === enumTypeName &&
+                        declaration.initializer) {
+                        let initializer = declaration.initializer;
+                        // Handle "as const" assertions
+                        if (ts.isAsExpression(initializer) && initializer.expression) {
+                            initializer = initializer.expression;
+                        }
+                        enumValues = this.extractObjectEnumValues(initializer);
+                        return;
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+        return enumValues;
+    }
+    /**
+     * Extracts values from a TypeScript enum declaration.
+     *
+     * @param enumNode - The enum declaration node
+     * @returns Array of enum values
+     * @private
+     */
+    extractEnumValues(enumNode) {
+        const values = [];
+        for (const member of enumNode.members) {
+            if (member.initializer) {
+                // Handle initialized enum members
+                if (ts.isStringLiteral(member.initializer)) {
+                    values.push(member.initializer.text);
+                }
+                else if (ts.isNumericLiteral(member.initializer)) {
+                    values.push(Number(member.initializer.text));
+                }
+            }
+            else {
+                // Handle auto-incremented numeric enums
+                if (values.length === 0) {
+                    values.push(0);
+                }
+                else {
+                    const lastValue = values[values.length - 1];
+                    if (typeof lastValue === 'number') {
+                        values.push(lastValue + 1);
+                    }
+                }
+            }
+        }
+        return values;
+    }
+    /**
+     * Extracts values from object literal enum (const object as const).
+     *
+     * @param initializer - The object literal initializer
+     * @returns Array of enum values
+     * @private
+     */
+    extractObjectEnumValues(initializer) {
+        const values = [];
+        if (ts.isObjectLiteralExpression(initializer)) {
+            for (const property of initializer.properties) {
+                if (ts.isPropertyAssignment(property) && property.initializer) {
+                    if (ts.isStringLiteral(property.initializer)) {
+                        values.push(property.initializer.text);
+                    }
+                    else if (ts.isNumericLiteral(property.initializer)) {
+                        values.push(Number(property.initializer.text));
+                    }
+                }
             }
         }
+        return values;
     }
     /**
      * Applies sensible default behaviors for properties without class-validator decorators.
@@ -739,6 +1471,10 @@ class SchemaTransformer {
      * @private
      */
     applyTypeBasedFormats(property, schema) {
+        // Skip applying type-based formats to $ref schemas
+        if (this.isRefSchema(schema)) {
+            return;
+        }
         const propertyName = property.name;
         const propertyType = property.type.toLowerCase();
         const propertySchema = schema.properties[propertyName];
@@ -773,6 +1509,10 @@ class SchemaTransformer {
      * @private
      */
     determineRequiredStatus(property, schema) {
+        // Skip determining required status for $ref schemas
+        if (this.isRefSchema(schema)) {
+            return;
+        }
         const propertyName = property.name;
         // Check if already marked as required by IsNotEmpty or ArrayNotEmpty decorator
         const isAlreadyRequired = schema.required.includes(propertyName);
@@ -813,7 +1553,7 @@ class SchemaTransformer {
  * @public
  */
 function transform(cls, options) {
-    return SchemaTransformer.getInstance(undefined, options).transform(cls);
+    return SchemaTransformer.transformClass(cls, options);
 }
 
 class FileTest {
@@ -857,3 +1597,4 @@ try {
 catch (error) {
     console.error('❌ Error:', error instanceof Error ? error.message : String(error));
 }
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"run.js","sources":["../src/transformer.fixtures.ts","../src/transformer.ts","../src/run.ts"],"sourcesContent":[null,null,null],"names":[],"mappings":"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"}