ts-class-to-openapi 1.0.1 → 1.0.3

package/dist/test.js

@@ -1,1657 +0,0 @@
-'use strict';
-
-var node_test = require('node:test');
-var assert = require('node:assert');
-var ts = require('typescript');
-var path = require('path');
-var classValidator = require('class-validator');
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-const TS_CONFIG_DEFAULT_PATH = path.resolve(process.cwd(), 'tsconfig.json');
-const jsPrimitives = {
-    String: { type: 'String', value: 'string' },
-    Number: { type: 'Number', value: 'number' },
-    Boolean: { type: 'Boolean', value: 'boolean' },
-    Symbol: { type: 'Symbol', value: 'symbol' },
-    BigInt: { type: 'BigInt', value: 'integer' },
-    null: { type: 'null', value: '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' },
-    UploadFile: { type: 'UploadFile', value: 'string', format: 'binary' },
-    File: { type: 'File', value: 'string', format: 'binary' },
-};
-const validatorDecorators = {
-    Length: { name: 'Length', type: 'string' },
-    MinLength: { name: 'MinLength', type: 'string' },
-    MaxLength: { name: 'MaxLength', type: 'string' },
-    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' },
-    IsDate: { name: 'IsDate', type: 'string', format: 'date-time' },
-    IsEmail: { name: 'IsEmail', type: 'string', format: 'email' },
-    IsNotEmpty: { name: 'IsNotEmpty' },
-    IsBoolean: { name: 'IsBoolean', type: 'boolean' },
-    IsArray: { name: 'IsArray', type: 'array' },
-    Min: { name: 'Min' },
-    Max: { name: 'Max' },
-    ArrayNotEmpty: { name: 'ArrayNotEmpty' },
-    ArrayMaxSize: { name: 'ArrayMaxSize' },
-    ArrayMinSize: { name: 'ArrayMinSize' },
-};
-const constants = {
-    TS_CONFIG_DEFAULT_PATH,
-    jsPrimitives,
-    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();
-    /**
-     * 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);
-        if (error) {
-            console.log(new Error(`Error reading tsconfig file: ${error.messageText}`).message);
-            throw new Error(`Error reading tsconfig file: ${error.messageText}`);
-        }
-        const { options: tsOptions, fileNames } = ts.parseJsonConfigFileContent(config, ts.sys, './');
-        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();
-        }
-    }
-    /**
-     * Gets relevant source files for a class, filtering out unnecessary files to save memory.
-     *
-     * @param className - The name of the class to find files for
-     * @param filePath - Optional specific file path
-     * @returns Array of relevant source files
-     * @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 => {
-            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;
-        });
-    }
-    /**
-     * 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) {
-            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);
-                }
-                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;
-            }
-        }
-        throw new Error(`Class ${className} not found`);
-    }
-    /**
-     * 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.
-     */
-    static clearInstance() {
-        SchemaTransformer.instance = null;
-    }
-    static getInstance(tsConfigPath, options) {
-        if (!SchemaTransformer.instance) {
-            SchemaTransformer.instance = new SchemaTransformer(tsConfigPath, options);
-        }
-        return SchemaTransformer.instance;
-    }
-    /**
-     * 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();
-        // Force garbage collection hint if available
-        if (global.gc) {
-            global.gc();
-        }
-    }
-    /**
-     * Gets memory usage statistics for monitoring and debugging.
-     *
-     * @returns Object containing cache size and loaded files count
-     *
-     * @example
-     * ```typescript
-     * const transformer = SchemaTransformer.getInstance();
-     * const stats = transformer.getMemoryStats();
-     * console.log(`Cache entries: ${stats.cacheSize}, Files loaded: ${stats.loadedFiles}`);
-     * ```
-     *
-     * @public
-     */
-    getMemoryStats() {
-        return {
-            cacheSize: this.classCache.size,
-            loadedFiles: this.loadedFiles.size,
-        };
-    }
-    /**
-     * 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
-     * @returns Object containing class name and generated schema
-     * @private
-     */
-    transformClass(classNode) {
-        const className = classNode.name?.text || 'Unknown';
-        const properties = this.extractProperties(classNode);
-        const schema = this.generateSchema(properties);
-        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) {
-        const properties = [];
-        for (const member of classNode.members) {
-            if (ts.isPropertyDeclaration(member) &&
-                member.name &&
-                ts.isIdentifier(member.name)) {
-                const propertyName = member.name.text;
-                const type = this.getPropertyType(member);
-                const decorators = this.extractDecorators(member);
-                const isOptional = !!member.questionToken;
-                properties.push({
-                    name: propertyName,
-                    type,
-                    decorators,
-                    isOptional,
-                });
-            }
-        }
-        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);
-    }
-    /**
-     * 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')) {
-                return 'UploadFile';
-            }
-            if (typeNode.typeArguments && typeNode.typeArguments.length > 0) {
-                const firstTypeArg = typeNode.typeArguments[0];
-                if (firstTypeArg &&
-                    ts.isTypeReferenceNode(firstTypeArg) &&
-                    ts.isIdentifier(firstTypeArg.typeName)) {
-                    if (firstTypeArg.typeName.text.toLowerCase().includes('uploadfile')) {
-                        return 'UploadFile';
-                    }
-                    if (typeNode.typeName.text === 'BaseDto') {
-                        return firstTypeArg.typeName.text;
-                    }
-                }
-            }
-            return typeNode.typeName.text;
-        }
-        switch (typeNode.kind) {
-            case ts.SyntaxKind.StringKeyword:
-                return constants.jsPrimitives.String.type;
-            case ts.SyntaxKind.NumberKeyword:
-                return constants.jsPrimitives.Number.type;
-            case ts.SyntaxKind.BooleanKeyword:
-                return constants.jsPrimitives.Boolean.type;
-            case ts.SyntaxKind.ArrayType:
-                const arrayType = typeNode;
-                return `${this.getTypeNodeToString(arrayType.elementType)}[]`;
-            case ts.SyntaxKind.UnionType:
-                // Handle union types like string | null
-                const unionType = typeNode;
-                const types = unionType.types.map(t => this.getTypeNodeToString(t));
-                // Filter out null and undefined, return the first meaningful type
-                const meaningfulTypes = types.filter(t => t !== 'null' && t !== 'undefined');
-                if (meaningfulTypes.length > 0 && meaningfulTypes[0]) {
-                    return meaningfulTypes[0];
-                }
-                if (types.length > 0 && types[0]) {
-                    return types[0];
-                }
-                return 'object';
-            default:
-                const typeText = typeNode.getText();
-                // Handle some common TypeScript utility types
-                if (typeText.startsWith('Date'))
-                    return constants.jsPrimitives.Date.type;
-                if (typeText.includes('Buffer') || typeText.includes('Uint8Array'))
-                    return constants.jsPrimitives.Buffer.type;
-                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
-     */
-    extractDecorators(member) {
-        const decorators = [];
-        if (member.modifiers) {
-            for (const modifier of member.modifiers) {
-                if (ts.isDecorator(modifier) &&
-                    ts.isCallExpression(modifier.expression)) {
-                    const decoratorName = this.getDecoratorName(modifier.expression);
-                    const args = this.getDecoratorArguments(modifier.expression);
-                    decorators.push({ name: decoratorName, arguments: args });
-                }
-                else if (ts.isDecorator(modifier) &&
-                    ts.isIdentifier(modifier.expression)) {
-                    decorators.push({ name: modifier.expression.text, arguments: [] });
-                }
-            }
-        }
-        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))
-                return Number(arg.text);
-            if (ts.isStringLiteral(arg))
-                return arg.text;
-            if (arg.kind === ts.SyntaxKind.TrueKeyword)
-                return true;
-            if (arg.kind === ts.SyntaxKind.FalseKeyword)
-                return false;
-            return arg.getText();
-        });
-    }
-    /**
-     * Generates an OpenAPI schema from extracted property information.
-     *
-     * @param properties - Array of property information to process
-     * @returns Complete OpenAPI schema object with properties and validation rules
-     * @private
-     */
-    generateSchema(properties) {
-        const schema = {
-            type: 'object',
-            properties: {},
-            required: [],
-        };
-        for (const property of properties) {
-            const { type, format, nestedSchema } = this.mapTypeToSchema(property.type);
-            if (nestedSchema) {
-                schema.properties[property.name] = nestedSchema;
-            }
-            else {
-                schema.properties[property.name] = { type };
-                if (format)
-                    schema.properties[property.name].format = format;
-            }
-            // Apply decorators if present
-            this.applyDecorators(property.decorators, schema, property.name);
-            // If no decorators are present, apply sensible defaults based on TypeScript types
-            if (property.decorators.length === 0) {
-                this.applySensibleDefaults(property, schema);
-            }
-            // Determine if property should be required based on decorators and optional status
-            this.determineRequiredStatus(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
-     * @returns Object containing OpenAPI type, optional format, and nested schema
-     * @private
-     */
-    mapTypeToSchema(type) {
-        // Handle arrays
-        if (type.endsWith('[]')) {
-            const elementType = type.slice(0, -2);
-            const elementSchema = this.mapTypeToSchema(elementType);
-            const items = elementSchema.nestedSchema || {
-                type: elementSchema.type,
-            };
-            if (elementSchema.format)
-                items.format = elementSchema.format;
-            return {
-                type: 'array',
-                nestedSchema: {
-                    type: 'array',
-                    items,
-                    properties: {},
-                    required: [],
-                },
-            };
-        }
-        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:
-                // Handle nested objects
-                try {
-                    const nestedResult = this.transformByName(type);
-                    return {
-                        type: constants.jsPrimitives.Object.value,
-                        nestedSchema: nestedResult.schema,
-                    };
-                }
-                catch {
-                    return { type: constants.jsPrimitives.Object.value };
-                }
-        }
-    }
-    /**
-     * 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) {
-        const isArrayType = schema.properties[propertyName].type ===
-            constants.jsPrimitives.Array.value;
-        for (const decorator of decorators) {
-            const decoratorName = decorator.name;
-            switch (decoratorName) {
-                case constants.validatorDecorators.IsString.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsString.type;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].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;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsInt.type;
-                        schema.properties[propertyName].items.format =
-                            constants.validatorDecorators.IsInt.format;
-                    }
-                    break;
-                case constants.validatorDecorators.IsNumber.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsNumber.type;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsNumber.type;
-                    }
-                    break;
-                case constants.validatorDecorators.IsBoolean.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].type =
-                            constants.validatorDecorators.IsBoolean.type;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsBoolean.type;
-                    }
-                    break;
-                case constants.validatorDecorators.IsEmail.name:
-                    if (!isArrayType) {
-                        schema.properties[propertyName].format =
-                            constants.validatorDecorators.IsEmail.format;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].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;
-                    }
-                    else if (schema.properties[propertyName].items) {
-                        schema.properties[propertyName].items.type =
-                            constants.validatorDecorators.IsDate.type;
-                        schema.properties[propertyName].items.format =
-                            constants.validatorDecorators.IsDate.format;
-                    }
-                    break;
-                case constants.validatorDecorators.IsNotEmpty.name:
-                    if (!schema.required.includes(propertyName)) {
-                        schema.required.push(propertyName);
-                    }
-                    break;
-                case constants.validatorDecorators.MinLength.name:
-                    schema.properties[propertyName].minLength = decorator.arguments[0];
-                    break;
-                case constants.validatorDecorators.MaxLength.name:
-                    schema.properties[propertyName].maxLength = decorator.arguments[0];
-                    break;
-                case constants.validatorDecorators.Length.name:
-                    schema.properties[propertyName].minLength = decorator.arguments[0];
-                    if (decorator.arguments[1]) {
-                        schema.properties[propertyName].maxLength = decorator.arguments[1];
-                    }
-                    break;
-                case constants.validatorDecorators.Min.name:
-                    schema.properties[propertyName].minimum = decorator.arguments[0];
-                    break;
-                case constants.validatorDecorators.Max.name:
-                    schema.properties[propertyName].maximum = decorator.arguments[0];
-                    break;
-                case constants.validatorDecorators.IsPositive.name:
-                    schema.properties[propertyName].minimum = 0;
-                    break;
-                case constants.validatorDecorators.IsArray.name:
-                    schema.properties[propertyName].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);
-                    }
-                    break;
-                case constants.validatorDecorators.ArrayMinSize.name:
-                    schema.properties[propertyName].minItems = decorator.arguments[0];
-                    break;
-                case constants.validatorDecorators.ArrayMaxSize.name:
-                    schema.properties[propertyName].maxItems = decorator.arguments[0];
-                    break;
-            }
-        }
-    }
-    /**
-     * 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
-     */
-    applySensibleDefaults(property, schema) {
-        const propertyName = property.name;
-        property.type.toLowerCase();
-        // Add examples based on property names and types
-        const propertySchema = schema.properties[propertyName];
-        // Add common format hints based on property names
-        if (propertyName.includes('email') && propertySchema.type === 'string') {
-            propertySchema.format = 'email';
-        }
-        else if (propertyName.includes('password') &&
-            propertySchema.type === 'string') {
-            propertySchema.format = 'password';
-            propertySchema.minLength = 8;
-        }
-        else if (propertyName.includes('url') &&
-            propertySchema.type === 'string') {
-            propertySchema.format = 'uri';
-        }
-        else if (propertyName.includes('phone') &&
-            propertySchema.type === 'string') {
-            propertySchema.pattern = '^[+]?[1-9]\\d{1,14}$';
-        }
-        // Add reasonable constraints based on common property names
-        if (propertySchema.type === 'string') {
-            if (propertyName === 'name' ||
-                propertyName === 'firstName' ||
-                propertyName === 'lastName') {
-                propertySchema.minLength = 1;
-                propertySchema.maxLength = 100;
-            }
-            else if (propertyName === 'description' || propertyName === 'bio') {
-                propertySchema.maxLength = 500;
-            }
-            else if (propertyName === 'title') {
-                propertySchema.minLength = 1;
-                propertySchema.maxLength = 200;
-            }
-        }
-        if (propertySchema.type === 'integer' || propertySchema.type === 'number') {
-            if (propertyName === 'age') {
-                propertySchema.minimum = 0;
-                propertySchema.maximum = 150;
-            }
-            else if (propertyName === 'id') {
-                propertySchema.minimum = 1;
-            }
-            else if (propertyName.includes('count') ||
-                propertyName.includes('quantity')) {
-                propertySchema.minimum = 0;
-            }
-        }
-    }
-    /**
-     * 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) {
-        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;
-        }
-        // If property is not optional and not already required, make it required
-        schema.required.push(propertyName);
-    }
-}
-/**
- * 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.getInstance(undefined, options).transform(cls);
-}
-
-node_test.describe('Transform Function', () => {
-    node_test.test('should transform basic class with string property', () => {
-        class TestUser {
-            name;
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.IsNotEmpty()
-        ], TestUser.prototype, "name", void 0);
-        const result = transform(TestUser);
-        assert.strictEqual(result.name, 'TestUser');
-        assert.strictEqual(result.schema.type, 'object');
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.ok(result.schema.required.includes('name'));
-    });
-    node_test.test('should handle different primitive types', () => {
-        class PrimitiveTest {
-            name;
-            price;
-            active;
-            createdAt;
-        }
-        __decorate([
-            classValidator.IsString()
-        ], PrimitiveTest.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsNumber()
-        ], PrimitiveTest.prototype, "price", void 0);
-        __decorate([
-            classValidator.IsBoolean()
-        ], PrimitiveTest.prototype, "active", void 0);
-        __decorate([
-            classValidator.IsDate()
-        ], PrimitiveTest.prototype, "createdAt", void 0);
-        const result = transform(PrimitiveTest);
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.strictEqual(result.schema.properties.price.type, 'number');
-        assert.strictEqual(result.schema.properties.active.type, 'boolean');
-        assert.strictEqual(result.schema.properties.createdAt.type, 'string');
-        assert.strictEqual(result.schema.properties.createdAt.format, 'date-time');
-    });
-    node_test.test('should handle array types', () => {
-        class ArrayTest {
-            tags;
-        }
-        __decorate([
-            classValidator.IsArray(),
-            classValidator.IsString({ each: true })
-        ], ArrayTest.prototype, "tags", void 0);
-        const result = transform(ArrayTest);
-        assert.strictEqual(result.schema.properties.tags.type, 'array');
-        assert.ok(result.schema.properties.tags.items);
-        assert.strictEqual(result.schema.properties.tags.items.type, 'string');
-    });
-    node_test.test('should handle file upload types', () => {
-        class FileTest {
-            avatar;
-            files;
-        }
-        const result = transform(FileTest);
-        assert.strictEqual(result.schema.properties.avatar.type, 'string');
-        assert.strictEqual(result.schema.properties.avatar.format, 'binary');
-        assert.strictEqual(result.schema.properties.files.type, 'array');
-        assert.strictEqual(result.schema.properties.files.items.type, 'string');
-        assert.strictEqual(result.schema.properties.files.items.format, 'binary');
-    });
-    node_test.test('should handle validation decorators', () => {
-        class ValidationTest {
-            name;
-            age;
-            email;
-            price;
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.MinLength(5),
-            classValidator.MaxLength(100)
-        ], ValidationTest.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsInt(),
-            classValidator.Min(18),
-            classValidator.Max(100)
-        ], ValidationTest.prototype, "age", void 0);
-        __decorate([
-            classValidator.IsEmail()
-        ], ValidationTest.prototype, "email", void 0);
-        __decorate([
-            classValidator.IsNumber(),
-            classValidator.IsPositive()
-        ], ValidationTest.prototype, "price", void 0);
-        const result = transform(ValidationTest);
-        // String with length constraints
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.strictEqual(result.schema.properties.name.minLength, 5);
-        assert.strictEqual(result.schema.properties.name.maxLength, 100);
-        // Integer with min/max
-        assert.strictEqual(result.schema.properties.age.type, 'integer');
-        assert.strictEqual(result.schema.properties.age.format, 'int32');
-        assert.strictEqual(result.schema.properties.age.minimum, 18);
-        assert.strictEqual(result.schema.properties.age.maximum, 100);
-        // Email format
-        assert.strictEqual(result.schema.properties.email.format, 'email');
-        // Positive number
-        assert.strictEqual(result.schema.properties.price.minimum, 0);
-    });
-    node_test.test('should handle array validation decorators', () => {
-        class ArrayValidationTest {
-            requiredTags;
-            boundedArray;
-        }
-        __decorate([
-            classValidator.IsArray(),
-            classValidator.ArrayNotEmpty(),
-            classValidator.IsString({ each: true })
-        ], ArrayValidationTest.prototype, "requiredTags", void 0);
-        __decorate([
-            classValidator.IsArray(),
-            classValidator.ArrayMinSize(2),
-            classValidator.ArrayMaxSize(10)
-        ], ArrayValidationTest.prototype, "boundedArray", void 0);
-        const result = transform(ArrayValidationTest);
-        // Required array with minimum items
-        assert.strictEqual(result.schema.properties.requiredTags.type, 'array');
-        assert.strictEqual(result.schema.properties.requiredTags.minItems, 1);
-        assert.ok(result.schema.required.includes('requiredTags'));
-        // Array with size bounds
-        assert.strictEqual(result.schema.properties.boundedArray.type, 'array');
-        assert.strictEqual(result.schema.properties.boundedArray.minItems, 2);
-        assert.strictEqual(result.schema.properties.boundedArray.maxItems, 10);
-    });
-    node_test.test('should handle Length decorator variations', () => {
-        class LengthTest {
-            code;
-            shortCode;
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.Length(3, 10)
-        ], LengthTest.prototype, "code", void 0);
-        __decorate([
-            classValidator.IsString(),
-            classValidator.Length(5)
-        ], LengthTest.prototype, "shortCode", void 0);
-        const result = transform(LengthTest);
-        // Length with min and max
-        assert.strictEqual(result.schema.properties.code.minLength, 3);
-        assert.strictEqual(result.schema.properties.code.maxLength, 10);
-        // Length with only min
-        assert.strictEqual(result.schema.properties.shortCode.minLength, 5);
-        assert.strictEqual(result.schema.properties.shortCode.maxLength, undefined);
-    });
-    node_test.test('should handle required fields with IsNotEmpty', () => {
-        class RequiredTest {
-            name;
-            optionalField; // Added ? to make it optional
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.IsNotEmpty()
-        ], RequiredTest.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsString()
-        ], RequiredTest.prototype, "optionalField", void 0);
-        const result = transform(RequiredTest);
-        assert.ok(result.schema.required.includes('name'));
-        assert.ok(!result.schema.required.includes('optionalField'));
-    });
-    node_test.test('should handle nested objects', () => {
-        class Address {
-            street;
-            city;
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.IsNotEmpty()
-        ], Address.prototype, "street", void 0);
-        __decorate([
-            classValidator.IsString()
-        ], Address.prototype, "city", void 0);
-        class User {
-            name;
-            address;
-        }
-        __decorate([
-            classValidator.IsString()
-        ], User.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsNotEmpty()
-        ], User.prototype, "address", void 0);
-        const result = transform(User);
-        assert.strictEqual(result.schema.properties.address.type, 'object');
-        assert.ok(result.schema.properties.address.properties);
-        assert.ok(result.schema.properties.address.properties.street);
-        assert.ok(result.schema.properties.address.properties.city);
-        assert.ok(result.schema.required.includes('address'));
-    });
-    node_test.test('should handle generic types like BaseDto<T>', () => {
-        class GenericTest {
-            user;
-            description;
-        }
-        const result = transform(GenericTest);
-        assert.strictEqual(result.schema.properties.user.type, 'object');
-        assert.ok(result.schema.properties.user.properties);
-        assert.ok(result.schema.properties.user.properties.name);
-        assert.ok(result.schema.properties.user.properties.id);
-        assert.strictEqual(result.schema.properties.user.properties.name.type, 'string');
-        assert.strictEqual(result.schema.properties.user.properties.id.type, 'number');
-        assert.strictEqual(result.schema.properties.description.type, 'string');
-    });
-    node_test.test('should use proper cache keys to avoid conflicts between classes with same names', () => {
-        class TestClass {
-            name;
-            value;
-        }
-        __decorate([
-            classValidator.IsString()
-        ], TestClass.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsNumber()
-        ], TestClass.prototype, "value", void 0);
-        // Transform an existing class multiple times
-        const result1 = transform(TestClass);
-        const result2 = transform(TestClass);
-        // Both results should be identical (this indicates that the cache works)
-        assert.deepStrictEqual(result1, result2);
-        // Verify that the properties are correct
-        assert.ok(result1.schema.properties.name);
-        assert.ok(result1.schema.properties.value);
-        assert.strictEqual(result1.schema.properties.name.type, 'string');
-        assert.strictEqual(result1.schema.properties.value.type, 'number');
-    });
-    node_test.test('should manage memory efficiently with cache cleanup', () => {
-        // Clear any existing singleton instance
-        SchemaTransformer.clearInstance();
-        // Create a transformer with small cache size for testing
-        const transformer = SchemaTransformer.getInstance(undefined, {
-            maxCacheSize: 2,
-            autoCleanup: true,
-        });
-        // Clear any existing cache
-        transformer.clearCache();
-        class TestClass1 {
-            name;
-        }
-        __decorate([
-            classValidator.IsString()
-        ], TestClass1.prototype, "name", void 0);
-        class TestClass2 {
-            value;
-        }
-        __decorate([
-            classValidator.IsNumber()
-        ], TestClass2.prototype, "value", void 0);
-        class TestClass3 {
-            active;
-        }
-        __decorate([
-            classValidator.IsBoolean()
-        ], TestClass3.prototype, "active", void 0);
-        // Transform multiple classes to trigger cache cleanup
-        const result1 = transformer.transform(TestClass1);
-        const result2 = transformer.transform(TestClass2);
-        let stats = transformer.getMemoryStats();
-        assert.strictEqual(stats.cacheSize, 2);
-        // This should trigger cache cleanup due to maxCacheSize: 2
-        const result3 = transformer.transform(TestClass3);
-        stats = transformer.getMemoryStats();
-        assert.ok(stats.cacheSize <= 2, 'Cache should be cleaned up automatically');
-        // Verify results are still correct
-        assert.strictEqual(result1.schema.properties.name.type, 'string');
-        assert.strictEqual(result2.schema.properties.value.type, 'number');
-        assert.strictEqual(result3.schema.properties.active.type, 'boolean');
-        // Test manual cache clearing
-        transformer.clearCache();
-        stats = transformer.getMemoryStats();
-        assert.strictEqual(stats.cacheSize, 0);
-        assert.strictEqual(stats.loadedFiles, 0);
-    });
-});
-
-class SimpleUser {
-    name;
-    email;
-    age;
-}
-__decorate([
-    classValidator.IsString(),
-    classValidator.IsNotEmpty()
-], SimpleUser.prototype, "name", void 0);
-__decorate([
-    classValidator.IsEmail()
-], SimpleUser.prototype, "email", void 0);
-__decorate([
-    classValidator.IsInt(),
-    classValidator.Min(18),
-    classValidator.Max(100)
-], SimpleUser.prototype, "age", void 0);
-
-class ArrayEntity {
-    basicArray;
-    requiredArray;
-    minSizeArray;
-    maxSizeArray;
-    boundedArray;
-}
-__decorate([
-    classValidator.IsArray(),
-    classValidator.IsString({ each: true })
-], ArrayEntity.prototype, "basicArray", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.ArrayNotEmpty(),
-    classValidator.IsString({ each: true })
-], ArrayEntity.prototype, "requiredArray", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.ArrayMinSize(2),
-    classValidator.IsString({ each: true })
-], ArrayEntity.prototype, "minSizeArray", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.ArrayMaxSize(5),
-    classValidator.IsString({ each: true })
-], ArrayEntity.prototype, "maxSizeArray", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.ArrayMinSize(1),
-    classValidator.ArrayMaxSize(3),
-    classValidator.IsString({ each: true })
-], ArrayEntity.prototype, "boundedArray", void 0);
-
-class CompleteEntity {
-    id;
-    name;
-    email;
-    active;
-    createdAt;
-    price;
-    code;
-    shortCode;
-    tags;
-    emails;
-    numbers;
-    address;
-    profile;
-}
-__decorate([
-    classValidator.IsInt(),
-    classValidator.Min(1)
-], CompleteEntity.prototype, "id", void 0);
-__decorate([
-    classValidator.IsString(),
-    classValidator.IsNotEmpty(),
-    classValidator.MinLength(2),
-    classValidator.MaxLength(50)
-], CompleteEntity.prototype, "name", void 0);
-__decorate([
-    classValidator.IsEmail()
-], CompleteEntity.prototype, "email", void 0);
-__decorate([
-    classValidator.IsBoolean()
-], CompleteEntity.prototype, "active", void 0);
-__decorate([
-    classValidator.IsDate()
-], CompleteEntity.prototype, "createdAt", void 0);
-__decorate([
-    classValidator.IsNumber(),
-    classValidator.IsPositive()
-], CompleteEntity.prototype, "price", void 0);
-__decorate([
-    classValidator.IsString(),
-    classValidator.Length(3, 10)
-], CompleteEntity.prototype, "code", void 0);
-__decorate([
-    classValidator.IsString(),
-    classValidator.Length(5)
-], CompleteEntity.prototype, "shortCode", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.IsString({ each: true }),
-    classValidator.ArrayNotEmpty()
-], CompleteEntity.prototype, "tags", void 0);
-__decorate([
-    classValidator.IsArray()
-], CompleteEntity.prototype, "emails", void 0);
-__decorate([
-    classValidator.IsArray(),
-    classValidator.ArrayMinSize(1),
-    classValidator.ArrayMaxSize(5)
-], CompleteEntity.prototype, "numbers", void 0);
-__decorate([
-    classValidator.IsNotEmpty()
-], CompleteEntity.prototype, "address", void 0);
-
-class BrokenEntity {
-    name;
-    // This should cause issues - circular reference
-    parent;
-    // Array without proper type decoration
-    items;
-    // Property without any decorators
-    undecoratedProperty;
-    // Complex type that doesn't exist
-    complexType;
-}
-__decorate([
-    classValidator.IsString(),
-    classValidator.IsNotEmpty()
-], BrokenEntity.prototype, "name", void 0);
-__decorate([
-    classValidator.IsArray()
-], BrokenEntity.prototype, "items", void 0);
-
-node_test.describe('Transform Function Integration Tests', () => {
-    node_test.test('should transform SimpleUser class correctly', () => {
-        const result = transform(SimpleUser);
-        assert.strictEqual(result.name, 'SimpleUser');
-        assert.strictEqual(result.schema.type, 'object');
-        // Check properties
-        assert.ok(result.schema.properties.name);
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.ok(result.schema.properties.email);
-        assert.strictEqual(result.schema.properties.email.type, 'string');
-        assert.strictEqual(result.schema.properties.email.format, 'email');
-        assert.ok(result.schema.properties.age);
-        assert.strictEqual(result.schema.properties.age.type, 'integer');
-        assert.strictEqual(result.schema.properties.age.format, 'int32');
-        assert.strictEqual(result.schema.properties.age.minimum, 18);
-        assert.strictEqual(result.schema.properties.age.maximum, 100);
-        // Check required fields
-        assert.ok(result.schema.required.includes('name'));
-    });
-    node_test.test('should transform ArrayEntity with array decorators correctly', () => {
-        const result = transform(ArrayEntity);
-        assert.strictEqual(result.name, 'ArrayEntity');
-        // Basic array
-        assert.strictEqual(result.schema.properties.basicArray.type, 'array');
-        // Required array with ArrayNotEmpty
-        assert.strictEqual(result.schema.properties.requiredArray.type, 'array');
-        assert.strictEqual(result.schema.properties.requiredArray.minItems, 1);
-        assert.ok(result.schema.required.includes('requiredArray'));
-        // Array with minimum size
-        assert.strictEqual(result.schema.properties.minSizeArray.type, 'array');
-        assert.strictEqual(result.schema.properties.minSizeArray.minItems, 2);
-        // Array with maximum size
-        assert.strictEqual(result.schema.properties.maxSizeArray.type, 'array');
-        assert.strictEqual(result.schema.properties.maxSizeArray.maxItems, 5);
-        // Array with both min and max size
-        assert.strictEqual(result.schema.properties.boundedArray.type, 'array');
-        assert.strictEqual(result.schema.properties.boundedArray.minItems, 1);
-        assert.strictEqual(result.schema.properties.boundedArray.maxItems, 3);
-    });
-    node_test.test('should transform CompleteEntity with all decorators correctly', () => {
-        const result = transform(CompleteEntity);
-        assert.strictEqual(result.name, 'CompleteEntity');
-        // Validate all properties exist
-        const expectedProperties = [
-            'id',
-            'name',
-            'email',
-            'active',
-            'createdAt',
-            'price',
-            'code',
-            'shortCode',
-            'tags',
-            'emails',
-            'numbers',
-            'address',
-            'profile',
-        ];
-        expectedProperties.forEach(prop => {
-            assert.ok(result.schema.properties[prop], `Property ${prop} should exist`);
-        });
-        // Validate required fields
-        const expectedRequired = ['name', 'tags', 'address'];
-        expectedRequired.forEach(field => {
-            assert.ok(result.schema.required.includes(field), `Field ${field} should be required`);
-        });
-        // IsInt with Min
-        assert.strictEqual(result.schema.properties.id.type, 'integer');
-        assert.strictEqual(result.schema.properties.id.format, 'int32');
-        assert.strictEqual(result.schema.properties.id.minimum, 1);
-        // IsString with constraints
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.strictEqual(result.schema.properties.name.minLength, 2);
-        assert.strictEqual(result.schema.properties.name.maxLength, 50);
-        assert.ok(result.schema.required.includes('name'));
-        // IsEmail
-        assert.strictEqual(result.schema.properties.email.format, 'email');
-        // IsBoolean
-        assert.strictEqual(result.schema.properties.active.type, 'boolean');
-        // IsDate
-        assert.strictEqual(result.schema.properties.createdAt.type, 'string');
-        assert.strictEqual(result.schema.properties.createdAt.format, 'date-time');
-        // IsNumber with IsPositive
-        assert.strictEqual(result.schema.properties.price.type, 'number');
-        assert.strictEqual(result.schema.properties.price.minimum, 0);
-        // Length with both min and max
-        assert.strictEqual(result.schema.properties.code.minLength, 3);
-        assert.strictEqual(result.schema.properties.code.maxLength, 10);
-        // Length with only min
-        assert.strictEqual(result.schema.properties.shortCode.minLength, 5);
-        // Array with string items and ArrayNotEmpty
-        assert.strictEqual(result.schema.properties.tags.type, 'array');
-        assert.strictEqual(result.schema.properties.tags.minItems, 1);
-        assert.ok(result.schema.required.includes('tags'));
-        // Array with email validation on items
-        assert.strictEqual(result.schema.properties.emails.type, 'array');
-        // Array with size constraints and int items
-        assert.strictEqual(result.schema.properties.numbers.type, 'array');
-        assert.strictEqual(result.schema.properties.numbers.minItems, 1);
-        assert.strictEqual(result.schema.properties.numbers.maxItems, 5);
-        // Nested object reference - complete Address schema
-        assert.strictEqual(result.schema.properties.address.type, 'object');
-        assert.ok(result.schema.required.includes('address'));
-        assert.ok(result.schema.properties.address.properties);
-        // Validate Address schema structure
-        const addressSchema = result.schema.properties.address;
-        assert.ok(addressSchema.properties, 'Address should have properties');
-        assert.ok(addressSchema.properties.street, 'Address should have street property');
-        assert.strictEqual(addressSchema.properties.street.type, 'string');
-        assert.ok(addressSchema.properties.city, 'Address should have city property');
-        assert.strictEqual(addressSchema.properties.city.type, 'string');
-        // Note: Some properties might not be detected due to TypeScript compilation
-        // This is a known limitation of the current implementation
-        if (addressSchema.properties.country) {
-            assert.strictEqual(addressSchema.properties.country.type, 'string');
-            if (addressSchema.properties.country.minLength) {
-                assert.strictEqual(addressSchema.properties.country.minLength, 2);
-            }
-        }
-        assert.ok(addressSchema.required, 'Address should have required array');
-        assert.ok(addressSchema.required.includes('street'), 'Street should be required');
-        // City might not be required in all cases
-        if (addressSchema.required.includes('city')) {
-            assert.ok(true, 'City is required');
-        }
-        // Partial reference - this should actually fail for complex types
-        assert.strictEqual(result.schema.properties.profile.type, 'object');
-        // This might fail - Partial types shouldn't expand nested schemas
-        assert.strictEqual(result.schema.properties.profile.properties, undefined, 'Partial should not expand nested properties');
-    });
-    node_test.test('should handle problematic BrokenEntity and expose issues', () => {
-        const result = transform(BrokenEntity);
-        assert.strictEqual(result.name, 'BrokenEntity');
-        // Circular reference should be handled
-        assert.ok(result.schema.properties.parent, 'Should have parent property');
-        assert.strictEqual(result.schema.properties.parent.type, 'object');
-        // Array without specific item type
-        assert.strictEqual(result.schema.properties.items.type, 'array');
-        assert.ok(result.schema.properties.items.items, 'Array should have items definition');
-        // Undecorated property should still appear
-        assert.ok(result.schema.properties.undecoratedProperty, 'Undecorated property should exist');
-        // Complex type should fallback to object
-        assert.strictEqual(result.schema.properties.complexType.type, 'object');
-        // Only name should be required
-        assert.deepStrictEqual(result.schema.required, ['name']);
-    });
-});
-
-node_test.describe('Plain Classes Without Decorators', () => {
-    node_test.test('should handle plain class without decorators', () => {
-        class PlainUser {
-            id;
-            name;
-            email;
-            age;
-            isActive;
-            tags;
-            createdAt;
-        }
-        try {
-            const result = transform(PlainUser);
-            // Verify basic structure
-            assert.strictEqual(result.name, 'PlainUser');
-            assert.strictEqual(result.schema.type, 'object');
-            // Check if properties are detected
-            const properties = result.schema.properties;
-            assert.ok(properties.id, 'Should have id property');
-            assert.ok(properties.name, 'Should have name property');
-            assert.ok(properties.email, 'Should have email property');
-            assert.ok(properties.age, 'Should have age property');
-            assert.ok(properties.isActive, 'Should have isActive property');
-            assert.ok(properties.tags, 'Should have tags property');
-            assert.ok(properties.createdAt, 'Should have createdAt property');
-        }
-        catch (error) {
-            console.error('Error transforming plain class:', error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-    });
-});
-
-class OptionalPropertiesUser {
-    // Required property without decorator (no ?)
-    name;
-    // Optional property without decorator (has ?)
-    nickname;
-    // Required property with decorator (no ?)
-    email;
-    // Optional property with @IsOptional decorator (has ?)
-    middleName;
-    // Required property with decorator but no IsNotEmpty (no ?)
-    age;
-    // Optional property with decorator but no IsOptional (has ?)
-    score;
-    // Property with IsNotEmpty but marked as optional (has ?)
-    // This should still be required because IsNotEmpty overrides the optional status
-    requiredButOptionalSyntax;
-    // Plain optional property without any decorators (has ?)
-    bio;
-    // Plain required property without any decorators (no ?)
-    username;
-}
-__decorate([
-    classValidator.IsString(),
-    classValidator.IsNotEmpty()
-], OptionalPropertiesUser.prototype, "email", void 0);
-__decorate([
-    classValidator.IsOptional(),
-    classValidator.IsString()
-], OptionalPropertiesUser.prototype, "middleName", void 0);
-__decorate([
-    classValidator.IsInt(),
-    classValidator.Min(18),
-    classValidator.Max(100)
-], OptionalPropertiesUser.prototype, "age", void 0);
-__decorate([
-    classValidator.IsInt(),
-    classValidator.Min(0)
-], OptionalPropertiesUser.prototype, "score", void 0);
-__decorate([
-    classValidator.IsString(),
-    classValidator.IsNotEmpty()
-], OptionalPropertiesUser.prototype, "requiredButOptionalSyntax", void 0);
-
-node_test.describe('Optional Properties Tests', () => {
-    node_test.test('should correctly identify required and optional properties based on TypeScript optional operator', () => {
-        // Clear any existing instance to ensure clean state
-        SchemaTransformer.clearInstance();
-        const transformer = SchemaTransformer.getInstance();
-        const result = transformer.transform(OptionalPropertiesUser);
-        assert.strictEqual(result.name, 'OptionalPropertiesUser');
-        assert.strictEqual(result.schema.type, 'object');
-        assert(result.schema.properties);
-        assert(result.schema.required);
-        // Properties that should be required:
-        // - name (no ? operator, no decorators)
-        // - email (no ? operator, has IsNotEmpty)
-        // - age (no ? operator, has decorators but no IsNotEmpty)
-        // - requiredButOptionalSyntax (has ? but also has IsNotEmpty which overrides)
-        // - username (no ? operator, no decorators)
-        const expectedRequired = [
-            'email',
-            'age',
-            'requiredButOptionalSyntax',
-            'name',
-            'username', // No ? operator, no decorators
-        ];
-        // Properties that should NOT be required:
-        // - nickname (has ? operator, no decorators)
-        // - middleName (has ? operator, has IsOptional)
-        // - score (has ? operator, has decorators but no IsNotEmpty)
-        // - bio (has ? operator, no decorators)
-        const expectedOptional = ['nickname', 'middleName', 'score', 'bio'];
-        // Check that all expected required properties are in the required array
-        for (const prop of expectedRequired) {
-            assert(result.schema.required.includes(prop), `Property ${prop} should be required`);
-        }
-        // Check that optional properties are NOT in the required array
-        for (const prop of expectedOptional) {
-            assert(!result.schema.required.includes(prop), `Property ${prop} should be optional`);
-        }
-        // Verify specific property types and formats
-        assert.strictEqual(result.schema.properties.name.type, 'string');
-        assert.strictEqual(result.schema.properties.nickname.type, 'string');
-        assert.strictEqual(result.schema.properties.email.type, 'string');
-        assert.strictEqual(result.schema.properties.middleName.type, 'string');
-        assert.strictEqual(result.schema.properties.age.type, 'integer');
-        assert.strictEqual(result.schema.properties.score.type, 'integer');
-        assert.strictEqual(result.schema.properties.bio.type, 'string');
-        assert.strictEqual(result.schema.properties.username.type, 'string');
-        // Verify decorator constraints are still applied
-        assert.strictEqual(result.schema.properties.age.minimum, 18);
-        assert.strictEqual(result.schema.properties.age.maximum, 100);
-        assert.strictEqual(result.schema.properties.score.minimum, 0);
-    });
-    node_test.test('should handle properties with only TypeScript optional operator (no class-validator decorators)', () => {
-        // Clear any existing instance to ensure clean state
-        SchemaTransformer.clearInstance();
-        const transformer = SchemaTransformer.getInstance();
-        class PlainTypeScriptClass {
-            requiredProp;
-            optionalProp;
-            requiredNumber;
-            optionalNumber;
-        }
-        const result = transformer.transform(PlainTypeScriptClass);
-        // Required properties (no ? operator)
-        assert(result.schema.required.includes('requiredProp'), 'requiredProp should be required');
-        assert(result.schema.required.includes('requiredNumber'), 'requiredNumber should be required');
-        // Optional properties (has ? operator)
-        assert(!result.schema.required.includes('optionalProp'), 'optionalProp should be optional');
-        assert(!result.schema.required.includes('optionalNumber'), 'optionalNumber should be optional');
-        // All properties should exist in the schema
-        assert(result.schema.properties.requiredProp);
-        assert(result.schema.properties.optionalProp);
-        assert(result.schema.properties.requiredNumber);
-        assert(result.schema.properties.optionalNumber);
-    });
-    node_test.test('should prioritize IsNotEmpty decorator over TypeScript optional operator', () => {
-        // Clear any existing instance to ensure clean state
-        SchemaTransformer.clearInstance();
-        const transformer = SchemaTransformer.getInstance();
-        class MixedOptionalClass {
-            requiredEvenIfOptional; // Should be required due to IsNotEmpty
-            optionalWithDecorator; // Should be optional despite having decorators
-        }
-        __decorate([
-            classValidator.IsString(),
-            classValidator.IsNotEmpty()
-        ], MixedOptionalClass.prototype, "requiredEvenIfOptional", void 0);
-        __decorate([
-            classValidator.IsString()
-        ], MixedOptionalClass.prototype, "optionalWithDecorator", void 0);
-        const result = transformer.transform(MixedOptionalClass);
-        // IsNotEmpty should override the ? operator
-        assert(result.schema.required.includes('requiredEvenIfOptional'), 'requiredEvenIfOptional should be required due to IsNotEmpty');
-        // Should remain optional since no IsNotEmpty
-        assert(!result.schema.required.includes('optionalWithDecorator'), 'optionalWithDecorator should remain optional');
-    });
-    node_test.test('should work correctly with nested objects and optional properties', () => {
-        // Clear any existing instance to ensure clean state
-        SchemaTransformer.clearInstance();
-        const transformer = SchemaTransformer.getInstance();
-        class UserWithAddress {
-            name;
-            address;
-            requiredAddress;
-        }
-        __decorate([
-            classValidator.IsNotEmpty()
-        ], UserWithAddress.prototype, "requiredAddress", void 0);
-        const result = transformer.transform(UserWithAddress);
-        // name and requiredAddress should be required
-        assert(result.schema.required.includes('name'), 'name should be required');
-        assert(result.schema.required.includes('requiredAddress'), 'requiredAddress should be required');
-        // address should be optional
-        assert(!result.schema.required.includes('address'), 'address should be optional');
-        // All properties should exist
-        assert(result.schema.properties.name);
-        assert(result.schema.properties.address);
-        assert(result.schema.properties.requiredAddress);
-    });
-    node_test.test('should demonstrate backward compatibility with existing class-validator decorators', () => {
-        // Clear any existing instance to ensure clean state
-        SchemaTransformer.clearInstance();
-        const transformer = SchemaTransformer.getInstance();
-        class LegacyClass {
-            // Old behavior: only marked as required with IsNotEmpty
-            description; // This will now be required due to no ? operator
-            name; // This remains required due to IsNotEmpty
-            // New behavior: respects TypeScript optional syntax
-            nickname; // This is optional due to ? operator
-        }
-        __decorate([
-            classValidator.IsString()
-        ], LegacyClass.prototype, "description", void 0);
-        __decorate([
-            classValidator.IsString(),
-            classValidator.IsNotEmpty()
-        ], LegacyClass.prototype, "name", void 0);
-        __decorate([
-            classValidator.IsString()
-        ], LegacyClass.prototype, "nickname", void 0);
-        const result = transformer.transform(LegacyClass);
-        // Both description and name should be required now
-        assert(result.schema.required.includes('description'), 'description should be required (no ? operator)');
-        assert(result.schema.required.includes('name'), 'name should be required (IsNotEmpty)');
-        // nickname should be optional
-        assert(!result.schema.required.includes('nickname'), 'nickname should be optional (? operator)');
-    });
-});
-//# sourceMappingURL=test.js.map