ts-class-to-openapi 1.0.5 → 1.0.6

package/dist/index.esm.js

@@ -4,113 +4,57 @@ import path from 'path';
 const TS_CONFIG_DEFAULT_PATH = path.resolve(process.cwd(), 'tsconfig.json');
 const jsPrimitives = {
     String: { type: 'String', value: 'string' },
-    Number: { type: 'Number', value: 'number', format: 'float' },
+    Any: { type: 'Any'},
+    Unknown: { type: 'Unknown'},
+    Number: { type: 'Number', value: 'number', format: 'double' },
     Boolean: { type: 'Boolean', value: 'boolean' },
-    Symbol: { type: 'Symbol', value: 'symbol' },
+    Symbol: { type: 'Symbol', value: 'string' },
     BigInt: { type: 'BigInt', value: 'integer', format: 'int64' },
-    null: { type: 'null', value: 'null' },
+    null: { type: 'null'},
     Object: { type: 'Object', value: 'object' },
     Array: { type: 'Array', value: 'array' },
     Date: { type: 'Date', value: 'string', format: 'date-time' },
-    Function: { type: 'Function', value: 'function' },
-    Buffer: { type: 'Buffer', value: 'string', format: 'binary' },
-    Uint8Array: { type: 'Uint8Array', value: 'string', format: 'binary' },
+    Buffer: { type: 'Buffer', value: 'string'},
+    Uint8Array: { type: 'Uint8Array', value: 'string'},
     UploadFile: { type: 'UploadFile', value: 'string', format: 'binary' },
-    File: { type: 'File', value: 'string', format: 'binary' },
+    File: { type: 'File', value: 'string'},
 };
 const validatorDecorators = {
-    Length: { name: 'Length', type: 'string' },
-    MinLength: { name: 'MinLength', type: 'string' },
-    MaxLength: { name: 'MaxLength', type: 'string' },
+    Length: { name: 'Length'},
+    MinLength: { name: 'MinLength'},
+    MaxLength: { name: 'MaxLength'},
     IsInt: { name: 'IsInt', type: 'integer', format: 'int32' },
-    IsNumber: { name: 'IsNumber', type: 'number', format: 'double' },
-    IsString: { name: 'IsString', type: 'string', format: 'string' },
-    IsPositive: { name: 'IsPositive', type: 'number' },
+    IsNumber: { name: 'IsNumber', type: 'number'},
+    IsString: { name: 'IsString', type: 'string'},
+    IsPositive: { name: 'IsPositive'},
     IsDate: { name: 'IsDate', type: 'string', format: 'date-time' },
-    IsEmail: { name: 'IsEmail', type: 'string', format: 'email' },
+    IsEmail: { name: 'IsEmail', format: 'email' },
     IsNotEmpty: { name: 'IsNotEmpty' },
+    IsOptional: { name: 'IsOptional' },
     IsBoolean: { name: 'IsBoolean', type: 'boolean' },
-    IsArray: { name: 'IsArray', type: 'array' },
+    IsArray: { name: 'IsArray'},
     Min: { name: 'Min' },
     Max: { name: 'Max' },
     ArrayNotEmpty: { name: 'ArrayNotEmpty' },
     ArrayMaxSize: { name: 'ArrayMaxSize' },
     ArrayMinSize: { name: 'ArrayMinSize' },
-    IsEnum: { name: 'IsEnum', type: 'string' },
+    IsEnum: { name: 'IsEnum'},
 };
 const constants = {
     TS_CONFIG_DEFAULT_PATH,
     jsPrimitives,
-    validatorDecorators,
-};
+    validatorDecorators};
 
-/**
- * Transforms class-validator decorated classes into OpenAPI schema objects.
- * Analyzes TypeScript source files directly using the TypeScript compiler API.
- * Implemented as a singleton for performance optimization.
- *
- * @example
- * ```typescript
- * const transformer = SchemaTransformer.getInstance();
- * const schema = transformer.transform(User);
- * console.log(schema);
- * ```
- *
- * @public
- */
 class SchemaTransformer {
-    /**
-     * Singleton instance
-     * @private
-     */
     static instance = null;
-    /**
-     * TypeScript program instance for analyzing source files.
-     * @private
-     */
     program;
-    /**
-     * TypeScript type checker for resolving types.
-     * @private
-     */
     checker;
-    /**
-     * Cache for storing transformed class schemas to avoid reprocessing.
-     * Key format: "fileName:className" for uniqueness across different files.
-     * @private
-     */
     classCache = new Map();
-    /**
-     * Maximum number of entries to keep in cache before cleanup
-     * @private
-     */
     maxCacheSize;
-    /**
-     * Whether to automatically clean up cache
-     * @private
-     */
     autoCleanup;
-    /**
-     * Set of file paths that have been loaded to avoid redundant processing
-     * @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.
-     *
-     * @param tsConfigPath - Optional path to a specific TypeScript config file
-     * @param options - Configuration options for memory management
-     * @throws {Error} When TypeScript configuration cannot be loaded
-     * @private
-     */
     constructor(tsConfigPath = constants.TS_CONFIG_DEFAULT_PATH, options = {}) {
-        // Initialize configuration with defaults
         this.maxCacheSize = options.maxCacheSize ?? 100;
         this.autoCleanup = options.autoCleanup ?? true;
         const { config, error } = ts.readConfigFile(tsConfigPath || 'tsconfig.json', ts.sys.readFile);
@@ -122,493 +66,7 @@ class SchemaTransformer {
         this.program = ts.createProgram(fileNames, tsOptions);
         this.checker = this.program.getTypeChecker();
     }
-    /**
-     * Generates a unique cache key using file name and class name.
-     *
-     * @param fileName - The source file name
-     * @param className - The class name
-     * @returns Unique cache key in format "fileName:className"
-     * @private
-     */
-    getCacheKey(fileName, className) {
-        return `${fileName}:${className}`;
-    }
-    /**
-     * Cleans up cache when it exceeds maximum size to prevent memory leaks.
-     * Removes oldest entries using LRU strategy.
-     * @private
-     */
-    cleanupCache() {
-        if (!this.autoCleanup || this.classCache.size <= this.maxCacheSize) {
-            return;
-        }
-        const entries = Array.from(this.classCache.entries());
-        const toDelete = entries.slice(0, Math.floor(this.maxCacheSize / 2));
-        for (const [key] of toDelete) {
-            this.classCache.delete(key);
-        }
-        // Force garbage collection hint
-        if (global.gc) {
-            global.gc();
-        }
-    }
-    /**
-     * 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 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
-     */
-    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'))
-                return false;
-            if (sf.fileName.includes('node_modules'))
-                return false;
-            // Mark file as loaded for memory tracking
-            this.loadedFiles.add(sf.fileName);
-            return true;
-        });
-        // 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);
-                // Check cache first using fileName:className as key
-                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, 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.
-     *
-     * @param tsConfigPath - Optional path to a specific TypeScript config file (only used on first call)
-     * @param options - Configuration options for memory management (only used on first call)
-     * @returns The singleton instance
-     *
-     * @example
-     * ```typescript
-     * const transformer = SchemaTransformer.getInstance();
-     * ```
-     *
-     * @example
-     * ```typescript
-     * // With memory optimization options
-     * const transformer = SchemaTransformer.getInstance('./tsconfig.json', {
-     *   maxCacheSize: 50,
-     *   autoCleanup: true
-     * });
-     * ```
-     *
-     * @public
-     */
-    /**
-     * 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 = 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 || 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.
-     *
-     * @param cls - The class constructor function to transform
-     * @returns Object containing the class name and its corresponding JSON schema
-     *
-     * @example
-     * ```typescript
-     * import { User } from './entities/user.js';
-     * const transformer = SchemaTransformer.getInstance();
-     * const schema = transformer.transform(User);
-     * ```
-     *
-     * @public
-     */
-    transform(cls) {
-        return this.transformByName(cls.name);
-    }
-    /**
-     * Clears all cached schemas and loaded file references to free memory.
-     * Useful for long-running applications or when processing many different classes.
-     *
-     * @example
-     * ```typescript
-     * const transformer = SchemaTransformer.getInstance();
-     * // After processing many classes...
-     * transformer.clearCache();
-     * ```
-     *
-     * @public
-     */
-    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, 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`);
-     * ```
-     *
-     * @private
-     */
-    getMemoryStats() {
-        return {
-            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.
-     *
-     * @param sourceFile - The TypeScript source file to search in
-     * @param className - The name of the class to find
-     * @returns The class declaration node if found, undefined otherwise
-     * @private
-     */
-    findClassByName(sourceFile, className) {
-        let result;
-        const visit = (node) => {
-            if (ts.isClassDeclaration(node) && node.name?.text === className) {
-                result = node;
-                return;
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sourceFile);
-        return result;
-    }
-    /**
-     * 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, sourceFile) {
-        const className = classNode.name?.text || 'Unknown';
-        const properties = this.extractProperties(classNode);
-        const schema = this.generateSchema(properties, sourceFile?.fileName);
-        return { name: className, schema };
-    }
-    /**
-     * Extracts property information from a class declaration.
-     *
-     * @param classNode - The TypeScript class declaration node
-     * @returns Array of property information including names, types, decorators, and optional status
-     * @private
-     */
-    extractProperties(classNode) {
+    getPropertiesByClassDeclaration(classNode) {
         const properties = [];
         for (const member of classNode.members) {
             if (ts.isPropertyDeclaration(member) &&
@@ -618,272 +76,35 @@ class SchemaTransformer {
                 const type = this.getPropertyType(member);
                 const decorators = this.extractDecorators(member);
                 const isOptional = !!member.questionToken;
-                properties.push({
+                const isGeneric = this.isPropertyTypeGeneric(member);
+                const isPrimitive = this.isPrimitiveType(type);
+                const property = {
                     name: propertyName,
                     type,
                     decorators,
                     isOptional,
-                });
+                    isGeneric,
+                    originalProperty: member,
+                    isPrimitive,
+                    isClassType: this.isClassType(member),
+                    isArray: this.isArrayProperty(member),
+                };
+                properties.push(property);
             }
         }
         return properties;
     }
-    /**
-     * Gets the TypeScript type of a property as a string.
-     *
-     * @param property - The property declaration to analyze
-     * @returns String representation of the property's type
-     * @private
-     */
     getPropertyType(property) {
         if (property.type) {
             return this.getTypeNodeToString(property.type);
         }
         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);
+        return this.getStringFromType(type);
     }
-    /**
-     * Converts a TypeScript type node to its string representation.
-     *
-     * @param typeNode - The TypeScript type node to convert
-     * @returns String representation of the type
-     * @private
-     */
     getTypeNodeToString(typeNode) {
         if (ts.isTypeReferenceNode(typeNode) &&
             ts.isIdentifier(typeNode.typeName)) {
-            if (typeNode.typeName.text.toLowerCase().includes('uploadfile')) {
+            if (typeNode.typeName.text.toLowerCase() === 'uploadfile') {
                 return 'UploadFile';
             }
             if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
@@ -891,12 +112,9 @@ class SchemaTransformer {
                 if (firstTypeArg &&
                     ts.isTypeReferenceNode(firstTypeArg) &&
                     ts.isIdentifier(firstTypeArg.typeName)) {
-                    if (firstTypeArg.typeName.text.toLowerCase().includes('uploadfile')) {
+                    if (firstTypeArg.typeName.text.toLowerCase() === 'uploadfile') {
                         return 'UploadFile';
                     }
-                    if (typeNode.typeName.text === 'BaseDto') {
-                        return firstTypeArg.typeName.text;
-                    }
                 }
                 return this.resolveGenericType(typeNode);
             }
@@ -935,13 +153,24 @@ class SchemaTransformer {
                 return typeText;
         }
     }
-    /**
-     * Extracts decorator information from a property declaration.
-     *
-     * @param member - The property declaration to analyze
-     * @returns Array of decorator information including names and arguments
-     * @private
-     */
+    resolveGenericType(typeNode) {
+        const typeName = typeNode.typeName.text;
+        const typeArguments = typeNode.typeArguments;
+        if (!typeArguments || typeArguments.length === 0) {
+            return typeName;
+        }
+        const type = this.checker.getTypeAtLocation(typeNode);
+        const resolvedType = this.getStringFromType(type);
+        if (resolvedType &&
+            resolvedType !== typeName &&
+            !resolvedType.includes('any')) {
+            return resolvedType;
+        }
+        return typeName;
+    }
+    getStringFromType(type) {
+        return this.checker.typeToString(type);
+    }
     extractDecorators(member) {
         const decorators = [];
         if (member.modifiers) {
@@ -960,26 +189,12 @@ class SchemaTransformer {
         }
         return decorators;
     }
-    /**
-     * Gets the name of a decorator from a call expression.
-     *
-     * @param callExpression - The decorator call expression
-     * @returns The decorator name or "unknown" if not identifiable
-     * @private
-     */
     getDecoratorName(callExpression) {
         if (ts.isIdentifier(callExpression.expression)) {
             return callExpression.expression.text;
         }
         return 'unknown';
     }
-    /**
-     * Extracts arguments from a decorator call expression.
-     *
-     * @param callExpression - The decorator call expression
-     * @returns Array of parsed decorator arguments
-     * @private
-     */
     getDecoratorArguments(callExpression) {
         return callExpression.arguments.map(arg => {
             if (ts.isNumericLiteral(arg))
@@ -993,565 +208,501 @@ class SchemaTransformer {
             return arg.getText();
         });
     }
-    /**
-     * 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, contextFilePath) {
-        const schema = {
-            type: 'object',
-            properties: {},
-            required: [],
-        };
-        for (const property of properties) {
-            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;
+    isPropertyTypeGeneric(property) {
+        if (property.type && this.isGenericTypeFromNode(property.type)) {
+            return true;
+        }
+        try {
+            const type = this.checker.getTypeAtLocation(property);
+            return this.isGenericTypeFromSymbol(type);
+        }
+        catch (error) {
+            console.warn('Error analyzing property type for generics:', error);
+            return false;
+        }
+    }
+    isGenericTypeFromNode(typeNode) {
+        if (ts.isTypeReferenceNode(typeNode) && typeNode.typeArguments) {
+            return typeNode.typeArguments.length > 0;
+        }
+        // Check for mapped types (e.g., { [K in keyof T]: T[K] })
+        if (ts.isMappedTypeNode(typeNode)) {
+            return true;
+        }
+        // Check for conditional types (e.g., T extends U ? X : Y)
+        if (ts.isConditionalTypeNode(typeNode)) {
+            return true;
+        }
+        // Check for indexed access types (e.g., T[K])
+        if (ts.isIndexedAccessTypeNode(typeNode)) {
+            return true;
+        }
+        // Check for type operators like keyof, typeof
+        if (ts.isTypeOperatorNode(typeNode)) {
+            return true;
+        }
+        return false;
+    }
+    isGenericTypeFromSymbol(type) {
+        // First check if it's a simple array type - these should NOT be considered generic
+        if (this.isSimpleArrayType(type)) {
+            return false;
+        }
+        // Check if the type has type parameters
+        if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
+            return true;
+        }
+        // Check if it's a type reference with type arguments
+        // But exclude simple arrays which internally use Array<T> representation
+        if (type.typeArguments && type.typeArguments.length > 0) {
+            const symbol = type.getSymbol();
+            if (symbol && symbol.getName() === 'Array') {
+                // This is Array<T> - only consider it generic if T itself is a utility type
+                const elementType = type.typeArguments[0];
+                if (elementType) {
+                    return this.isUtilityTypeFromType(elementType);
                 }
+                return false;
             }
-            else {
-                schema.properties[property.name] = { type };
-                if (format)
-                    schema.properties[property.name].format = format;
+            const elementType = type.typeArguments[0];
+            return this.isUtilityTypeFromType(elementType);
+        }
+        // Check type flags for generic indicators
+        if (type.flags & ts.TypeFlags.TypeParameter) {
+            return true;
+        }
+        if (type.flags & ts.TypeFlags.Conditional) {
+            return true;
+        }
+        if (type.flags & ts.TypeFlags.Index) {
+            return true;
+        }
+        if (type.flags & ts.TypeFlags.IndexedAccess) {
+            return true;
+        }
+        // Check if the type symbol indicates a generic type
+        const symbol = type.getSymbol();
+        if (symbol && symbol.declarations) {
+            for (const declaration of symbol.declarations) {
+                // Check for type alias declarations with type parameters
+                if (ts.isTypeAliasDeclaration(declaration) &&
+                    declaration.typeParameters) {
+                    return true;
+                }
+                // Check for interface declarations with type parameters
+                if (ts.isInterfaceDeclaration(declaration) &&
+                    declaration.typeParameters) {
+                    return true;
+                }
+                // Check for class declarations with type parameters
+                if (ts.isClassDeclaration(declaration) && declaration.typeParameters) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    isUtilityTypeFromType(type) {
+        if (!type.aliasSymbol)
+            return false;
+        const aliasName = type.aliasSymbol.getName();
+        const utilityTypes = [
+            'Partial',
+            'Required',
+            'Readonly',
+            'Pick',
+            'Omit',
+            'Record',
+            'Exclude',
+            'Extract',
+            'NonNullable',
+        ];
+        return utilityTypes.includes(aliasName);
+    }
+    isSimpleArrayType(type) {
+        const symbol = type.getSymbol();
+        if (!symbol || symbol.getName() !== 'Array') {
+            return false;
+        }
+        // Check if this is Array<T> where T is a simple, non-generic type
+        if (type.typeArguments &&
+            type.typeArguments.length === 1) {
+            const elementType = type.typeArguments[0];
+            if (!elementType)
+                return false;
+            // If the element type is a utility type, then this array should be considered generic
+            if (this.isUtilityTypeFromType(elementType)) {
+                return false;
+            }
+            // If the element type itself has generic parameters, this array is generic
+            if (elementType.typeArguments &&
+                elementType.typeArguments.length > 0) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    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(),
+            constants.jsPrimitives.Symbol.type.toLowerCase(),
+            constants.jsPrimitives.null.type.toLowerCase(),
+            constants.jsPrimitives.Object.type.toLowerCase(),
+            constants.jsPrimitives.Array.type.toLowerCase(),
+            constants.jsPrimitives.Any.type.toLowerCase(),
+            constants.jsPrimitives.Unknown.type.toLowerCase(),
+        ];
+        const primitivesArray = primitiveTypes.map(t => t.concat('[]'));
+        return (primitiveTypes.includes(lowerTypeName) ||
+            primitivesArray.includes(lowerTypeName));
+    }
+    static getInstance(tsConfigPath, options) {
+        if (!SchemaTransformer.instance) {
+            SchemaTransformer.instance = new SchemaTransformer(tsConfigPath, options);
+        }
+        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));
+            });
+        }
+        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;
+                return true;
+            });
+        }
+        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);
+            });
+            if (found) {
+                return { sourceFile, node: node };
             }
-            // Apply decorators if present
-            this.applyDecorators(property.decorators, schema, property.name);
-            // If no decorators are present, apply type-based format specifications
-            if (property.decorators.length === 0) {
-                this.applyTypeBasedFormats(property, schema);
+        }
+    }
+    isClassType(propertyDeclaration) {
+        // If there's no explicit type annotation, we can't determine reliably
+        if (!propertyDeclaration.type) {
+            return false;
+        }
+        // Check if the original property type is an array type
+        if (this.isArrayProperty(propertyDeclaration) &&
+            ts.isTypeReferenceNode(propertyDeclaration.type
+                .elementType)) {
+            const type = this.checker.getTypeAtLocation(propertyDeclaration.type.elementType);
+            const symbol = type.getSymbol();
+            if (symbol && symbol.declarations) {
+                return symbol.declarations.some(decl => ts.isClassDeclaration(decl));
+            }
+        }
+        else if (ts.isTypeReferenceNode(propertyDeclaration.type)) {
+            const type = this.checker.getTypeAtLocation(propertyDeclaration.type);
+            const symbol = type.getSymbol();
+            if (symbol && symbol.declarations) {
+                return symbol.declarations.some(decl => ts.isClassDeclaration(decl));
+            }
+        }
+        return false;
+    }
+    getDeclarationProperty(property) {
+        if (!property.originalProperty.type) {
+            return undefined;
+        }
+        if (ts.isArrayTypeNode(property.originalProperty.type) &&
+            ts.isTypeReferenceNode(property.originalProperty.type.elementType)) {
+            const type = this.checker.getTypeAtLocation(property.originalProperty.type.elementType);
+            const symbol = type.getSymbol();
+            if (symbol && symbol.declarations) {
+                return symbol.declarations[0];
+            }
+        }
+        else if (ts.isTypeReferenceNode(property.originalProperty.type)) {
+            const type = this.checker.getTypeAtLocation(property.originalProperty.type);
+            const symbol = type.getSymbol();
+            if (symbol && symbol.declarations) {
+                return symbol.declarations[0];
+            }
+        }
+        return undefined;
+    }
+    isArrayProperty(propertyDeclaration) {
+        if (!propertyDeclaration.type) {
+            return false;
+        }
+        return ts.isArrayTypeNode(propertyDeclaration.type);
+    }
+    getSchemaFromProperties({ properties, visitedClass, transformedSchema, }) {
+        let schema = {};
+        const required = [];
+        for (const property of properties) {
+            schema[property.name] = this.getSchemaFromProperty({
+                property,
+                visitedClass,
+                transformedSchema,
+            });
+            // this.applyDecorators(property, schema as SchemaType)
+            if (!property.isOptional) {
+                required.push(property.name);
             }
-            // Determine if property should be required based on decorators and optional status
-            this.determineRequiredStatus(property, schema);
         }
+        return {
+            type: 'object',
+            properties: schema,
+            required: required.length ? required : undefined,
+        };
+    }
+    getSchemaFromProperty({ property, visitedClass, transformedSchema, }) {
+        let schema = {};
+        if (property.isPrimitive) {
+            schema = this.getSchemaFromPrimitive(property);
+        }
+        else if (property.isClassType) {
+            schema = this.getSchemaFromClass({
+                property,
+                visitedClass,
+                transformedSchema,
+            });
+        }
+        else {
+            schema = { type: 'object', properties: {}, additionalProperties: true };
+        }
+        this.applyDecorators(property, schema);
         return schema;
     }
-    /**
-     * Maps TypeScript types to OpenAPI schema types and formats.
-     * 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, contextFilePath) {
-        // Handle arrays
-        if (type.endsWith('[]')) {
-            const elementType = type.slice(0, -2);
-            const elementSchema = this.mapTypeToSchema(elementType, contextFilePath);
-            const items = elementSchema.nestedSchema || {
-                type: elementSchema.type,
-            };
-            if (elementSchema.format)
-                items.format = elementSchema.format;
+    getSchemaFromClass({ property, transformedSchema = new Map(), visitedClass = new Set(), }) {
+        let schema = { type: 'object' };
+        const declaration = this.getDeclarationProperty(property);
+        if (!declaration ||
+            !ts.isClassDeclaration(declaration) ||
+            !declaration.name) {
+            return { type: 'object' };
+        }
+        if (visitedClass.has(declaration)) {
+            if (transformedSchema.has(declaration.name.text)) {
+                return transformedSchema.get(declaration.name.text);
+            }
             return {
-                type: 'array',
-                nestedSchema: {
-                    type: 'array',
-                    items,
-                    properties: {},
-                    required: [],
-                },
+                $ref: `#/components/schemas/${declaration.name.text}`,
             };
         }
-        if (type.toLocaleLowerCase().includes('uploadfile'))
-            type = 'UploadFile';
-        // Handle primitives
-        switch (type.toLowerCase()) {
-            case constants.jsPrimitives.String.type.toLowerCase():
-                return { type: constants.jsPrimitives.String.value };
-            case constants.jsPrimitives.Number.type.toLowerCase():
-                return { type: constants.jsPrimitives.Number.value };
-            case constants.jsPrimitives.Boolean.type.toLowerCase():
-                return { type: constants.jsPrimitives.Boolean.value };
-            case constants.jsPrimitives.Date.type.toLowerCase():
-                return {
-                    type: constants.jsPrimitives.Date.value,
-                    format: constants.jsPrimitives.Date.format,
-                };
-            case constants.jsPrimitives.Buffer.type.toLowerCase():
-            case constants.jsPrimitives.Uint8Array.type.toLowerCase():
-            case constants.jsPrimitives.File.type.toLowerCase():
-                return {
-                    type: constants.jsPrimitives.Buffer.value,
-                    format: constants.jsPrimitives.Buffer.format,
-                };
-            case constants.jsPrimitives.UploadFile.type.toLowerCase():
-                return {
-                    type: constants.jsPrimitives.UploadFile.value,
-                    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, 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,
-                    };
-                }
-                catch {
-                    return { type: constants.jsPrimitives.Object.value };
-                }
+        visitedClass.add(declaration);
+        const properties = this.getPropertiesByClassDeclaration(declaration);
+        let transformerProps = this.getSchemaFromProperties({
+            properties,
+            visitedClass,
+            transformedSchema: transformedSchema,
+        });
+        if (property.isArray) {
+            schema.type = 'array';
+            schema.items = {
+                type: transformerProps.type,
+                properties: transformerProps.properties,
+                required: transformerProps.required,
+            };
         }
+        else {
+            schema.type = transformerProps.type;
+            schema.properties = transformerProps.properties;
+            schema.required = transformerProps.required;
+        }
+        transformedSchema.set(declaration.name.text, schema);
+        if (schema.properties && Object.keys(schema.properties).length === 0) {
+            schema = { type: 'object', properties: {}, additionalProperties: true };
+        }
+        return schema;
     }
-    /**
-     * 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.
-     *
-     * @param decorators - Array of decorator information to apply
-     * @param schema - The schema object to modify
-     * @param propertyName - Name of the property being processed
-     * @private
-     */
-    applyDecorators(decorators, schema, propertyName) {
-        // Skip applying decorators to $ref schemas
-        if (this.isRefSchema(schema)) {
-            return;
+    getSchemaFromPrimitive(property) {
+        const propertySchema = { type: 'object' };
+        const propertyType = property.type.toLowerCase().replace('[]', '').trim();
+        switch (propertyType) {
+            case constants.jsPrimitives.String.value:
+                propertySchema.type = constants.jsPrimitives.String.value;
+                break;
+            case constants.jsPrimitives.Number.value:
+                propertySchema.type = constants.jsPrimitives.Number.value;
+                propertySchema.format = constants.jsPrimitives.Number.format;
+                break;
+            case constants.jsPrimitives.BigInt.type.toLocaleLowerCase():
+                propertySchema.type = constants.jsPrimitives.BigInt.value;
+                propertySchema.format = constants.jsPrimitives.BigInt.format;
+                break;
+            case constants.jsPrimitives.Date.type.toLocaleLowerCase():
+                propertySchema.type = constants.jsPrimitives.Date.value;
+                propertySchema.format = constants.jsPrimitives.Date.format;
+                break;
+            case constants.jsPrimitives.Buffer.value:
+            case constants.jsPrimitives.Uint8Array.value:
+            case constants.jsPrimitives.File.value:
+            case constants.jsPrimitives.UploadFile.value:
+                propertySchema.type = constants.jsPrimitives.UploadFile.value;
+                propertySchema.format = constants.jsPrimitives.UploadFile.format;
+                break;
+            case constants.jsPrimitives.Array.value:
+                propertySchema.type = constants.jsPrimitives.Array.value;
+                break;
+            case constants.jsPrimitives.Boolean.value:
+                propertySchema.type = constants.jsPrimitives.Boolean.value;
+                break;
+            case constants.jsPrimitives.Symbol.type.toLocaleLowerCase():
+                propertySchema.type = constants.jsPrimitives.Symbol.value;
+                break;
+            case constants.jsPrimitives.Object.value:
+                propertySchema.type = constants.jsPrimitives.Object.value;
+                break;
+            default:
+                propertySchema.type = constants.jsPrimitives.String.value;
         }
-        const isArrayType = schema.properties[propertyName].type ===
-            constants.jsPrimitives.Array.value;
-        for (const decorator of decorators) {
+        if (property.isArray) {
+            propertySchema.type = `array`;
+            propertySchema.items = { type: propertyType };
+        }
+        return propertySchema;
+    }
+    //Todo: implement properly
+    applyEnumDecorator(decorator, schema) { }
+    applyDecorators(property, schema) {
+        for (const decorator of property.decorators) {
             const decoratorName = decorator.name;
             switch (decoratorName) {
                 case constants.validatorDecorators.IsString.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsString.type;
+                    if (!property.isArray) {
+                        schema.type = constants.validatorDecorators.IsString.type;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsString.type;
+                    else if (schema.items) {
+                        schema.items.type = constants.validatorDecorators.IsString.type;
                     }
                     break;
                 case constants.validatorDecorators.IsInt.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsInt.type;
-                        schema.properties[propertyName].format =
-                            constants.validatorDecorators.IsInt.format;
+                    if (!property.isArray) {
+                        schema.type = constants.validatorDecorators.IsInt.type;
+                        schema.format = constants.validatorDecorators.IsInt.format;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsInt.type;
-                        schema.properties[propertyName].items.format =
-                            constants.validatorDecorators.IsInt.format;
+                    else if (schema.items) {
+                        schema.items.type = constants.validatorDecorators.IsInt.type;
+                        schema.items.format = constants.validatorDecorators.IsInt.format;
                     }
                     break;
                 case constants.validatorDecorators.IsNumber.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsNumber.type;
+                    if (!property.isArray) {
+                        schema.type = constants.validatorDecorators.IsNumber.type;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsNumber.type;
+                    else if (schema.items) {
+                        schema.items.type = constants.validatorDecorators.IsNumber.type;
                     }
                     break;
                 case constants.validatorDecorators.IsBoolean.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsBoolean.type;
+                    if (!property.isArray) {
+                        schema.type = constants.validatorDecorators.IsBoolean.type;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsBoolean.type;
+                    else if (schema.items) {
+                        schema.items.type = constants.validatorDecorators.IsBoolean.type;
                     }
                     break;
                 case constants.validatorDecorators.IsEmail.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].format =
-                            constants.validatorDecorators.IsEmail.format;
+                    if (!property.isArray) {
+                        schema.format = constants.validatorDecorators.IsEmail.format;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.format =
-                            constants.validatorDecorators.IsEmail.format;
+                    else if (schema.items) {
+                        schema.items.format = constants.validatorDecorators.IsEmail.format;
                     }
                     break;
                 case constants.validatorDecorators.IsDate.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsDate.type;
-                        schema.properties[propertyName].format =
-                            constants.validatorDecorators.IsDate.format;
+                    if (!property.isArray) {
+                        schema.type = constants.validatorDecorators.IsDate.type;
+                        schema.format = constants.validatorDecorators.IsDate.format;
                     }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsDate.type;
-                        schema.properties[propertyName].items.format =
-                            constants.validatorDecorators.IsDate.format;
+                    else if (schema.items) {
+                        schema.items.type = constants.validatorDecorators.IsDate.type;
+                        schema.items.format = constants.validatorDecorators.IsDate.format;
                     }
                     break;
                 case constants.validatorDecorators.IsNotEmpty.name:
-                    if (!schema.required.includes(propertyName)) {
-                        schema.required.push(propertyName);
-                    }
+                    property.isOptional = false;
+                    break;
+                case constants.validatorDecorators.IsOptional.name:
+                    property.isOptional = true;
                     break;
                 case constants.validatorDecorators.MinLength.name:
-                    schema.properties[propertyName].minLength = decorator.arguments[0];
+                    schema.minLength = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.MaxLength.name:
-                    schema.properties[propertyName].maxLength = decorator.arguments[0];
+                    schema.maxLength = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.Length.name:
-                    schema.properties[propertyName].minLength = decorator.arguments[0];
+                    schema.minLength = decorator.arguments[0];
                     if (decorator.arguments[1]) {
-                        schema.properties[propertyName].maxLength = decorator.arguments[1];
+                        schema.maxLength = decorator.arguments[1];
                     }
                     break;
                 case constants.validatorDecorators.Min.name:
-                    schema.properties[propertyName].minimum = decorator.arguments[0];
+                    schema.minimum = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.Max.name:
-                    schema.properties[propertyName].maximum = decorator.arguments[0];
+                    schema.maximum = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.IsPositive.name:
-                    schema.properties[propertyName].minimum = 0;
+                    schema.minimum = 0;
                     break;
                 case constants.validatorDecorators.IsArray.name:
-                    schema.properties[propertyName].type =
-                        constants.jsPrimitives.Array.value;
+                    schema.type = constants.jsPrimitives.Array.value;
                     break;
                 case constants.validatorDecorators.ArrayNotEmpty.name:
-                    schema.properties[propertyName].minItems = 1;
-                    if (!schema.required.includes(propertyName)) {
-                        schema.required.push(propertyName);
-                    }
+                    schema.minItems = 1;
+                    property.isOptional = false;
                     break;
                 case constants.validatorDecorators.ArrayMinSize.name:
-                    schema.properties[propertyName].minItems = decorator.arguments[0];
+                    schema.minItems = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.ArrayMaxSize.name:
-                    schema.properties[propertyName].maxItems = decorator.arguments[0];
+                    schema.maxItems = decorator.arguments[0];
                     break;
                 case constants.validatorDecorators.IsEnum.name:
-                    this.applyEnumDecorator(decorator, schema, propertyName, isArrayType);
+                    this.applyEnumDecorator(decorator, schema);
                     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.
-     * This allows the schema generator to work with plain TypeScript classes.
-     *
-     * @param property - The property information
-     * @param schema - The schema object to modify
-     * @private
-     */
-    /**
-     * Applies OpenAPI format specifications based on TypeScript types.
-     * This method is called when no decorators are present to set appropriate
-     * format values for primitive types according to OpenAPI specification.
-     *
-     * @param property - The property information containing type details
-     * @param schema - The schema object to modify
-     * @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];
-        switch (propertyType) {
-            case constants.jsPrimitives.Number.value:
-                propertySchema.format = constants.jsPrimitives.Number.format;
-                break;
-            case constants.jsPrimitives.BigInt.value:
-                propertySchema.format = constants.jsPrimitives.BigInt.format;
-                break;
-            case constants.jsPrimitives.Date.value:
-                propertySchema.format = constants.jsPrimitives.Date.format;
-                break;
-            case constants.jsPrimitives.Buffer.value:
-            case constants.jsPrimitives.Uint8Array.value:
-            case constants.jsPrimitives.File.value:
-            case constants.jsPrimitives.UploadFile.value:
-                propertySchema.format = constants.jsPrimitives.UploadFile.format;
-                break;
-        }
-    }
-    /**
-     * Determines if a property should be required based on decorators and optional status.
-     *
-     * Logic:
-     * - If property has IsNotEmpty or ArrayNotEmpty decorator, it's required (handled in applyDecorators)
-     * - Otherwise, the property is not required (preserving original behavior)
-     * - The isOptional information is stored for future use and documentation
-     *
-     * @param property - The property information
-     * @param schema - The schema object to modify
-     * @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);
-        // If already required by decorators, don't change it
-        if (isAlreadyRequired) {
-            return;
-        }
-        // If property is optional (has ?), it should not be required unless explicitly marked
-        if (property.isOptional) {
-            return;
+    transform(cls, sourceOptions) {
+        let schema = { type: 'object', properties: {} };
+        const result = this.getSourceFileByClassName(cls.name, sourceOptions);
+        if (!result?.sourceFile) {
+            console.warn(`Class ${cls.name} not found in any source file.`);
+            return { name: cls.name, schema: {} };
         }
-        // If property is not optional and not already required, make it required
-        schema.required.push(propertyName);
+        const properties = this.getPropertiesByClassDeclaration(result.node);
+        schema = this.getSchemaFromProperties({ properties });
+        return { name: cls.name, schema };
     }
 }
-/**
- * Convenience function to transform a class using the singleton instance.
- *
- * @param cls - The class constructor function to transform
- * @param options - Optional configuration for memory management
- * @returns Object containing the class name and its corresponding JSON schema
- *
- * @example
- * ```typescript
- * import { transform } from 'class-validator-to-open-api'
- * import { User } from './entities/user.js'
- *
- * const schema = transform(User)
- * console.log(schema)
- * ```
- *
- * @example
- * ```typescript
- * // With memory optimization
- * const schema = transform(User, { maxCacheSize: 50, autoCleanup: true })
- * ```
- *
- * @public
- */
 function transform(cls, options) {
-    return SchemaTransformer.transformClass(cls, options);
+    // Use the singleton instance instead of creating a temporary one
+    const transformer = SchemaTransformer.getInstance(undefined, options);
+    return transformer.transform(cls, options?.sourceOptions);
 }
 
-export { SchemaTransformer, transform };
+export { transform };