ts-class-to-openapi 1.0.2 → 1.0.4

package/dist/index.esm.js

@@ -4,10 +4,10 @@ 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' },
+    Number: { type: 'Number', value: 'number', format: 'float' },
     Boolean: { type: 'Boolean', value: 'boolean' },
     Symbol: { type: 'Symbol', value: 'symbol' },
-    BigInt: { type: 'BigInt', value: 'integer' },
+    BigInt: { type: 'BigInt', value: 'integer', format: 'int64' },
     null: { type: 'null', value: 'null' },
     Object: { type: 'Object', value: 'object' },
     Array: { type: 'Array', value: 'array' },
@@ -36,6 +36,7 @@ const validatorDecorators = {
     ArrayNotEmpty: { name: 'ArrayNotEmpty' },
     ArrayMaxSize: { name: 'ArrayMaxSize' },
     ArrayMinSize: { name: 'ArrayMinSize' },
+    IsEnum: { name: 'IsEnum', type: 'string' },
 };
 const constants = {
     TS_CONFIG_DEFAULT_PATH,
@@ -173,16 +174,38 @@ class SchemaTransformer {
     }
     /**
      * Transforms a class by its name into an OpenAPI schema object.
+     * Now considers the context of the calling file to resolve ambiguous class names.
      *
      * @param className - The name of the class to transform
      * @param filePath - Optional path to the file containing the class
+     * @param contextFile - Optional 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, filePath) {
+    transformByName(className, filePath, contextFile) {
         const sourceFiles = this.getRelevantSourceFiles(className, filePath);
-        for (const sourceFile of sourceFiles) {
+        // If we have a context file, try to find the class in that file first
+        if (contextFile) {
+            const contextSourceFile = this.program.getSourceFile(contextFile);
+            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);
+                    }
+                    const result = this.transformClass(classNode, contextSourceFile);
+                    this.classCache.set(cacheKey, result);
+                    this.cleanupCache();
+                    return result;
+                }
+            }
+        }
+        // Fallback to searching all files, but prioritize files that are more likely to be relevant
+        const prioritizedFiles = this.prioritizeSourceFiles(sourceFiles, contextFile);
+        for (const sourceFile of prioritizedFiles) {
             const classNode = this.findClassByName(sourceFile, className);
             if (classNode && sourceFile?.fileName) {
                 const cacheKey = this.getCacheKey(sourceFile.fileName, className);
@@ -190,7 +213,7 @@ class SchemaTransformer {
                 if (this.classCache.has(cacheKey)) {
                     return this.classCache.get(cacheKey);
                 }
-                const result = this.transformClass(classNode);
+                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
@@ -200,6 +223,38 @@ class SchemaTransformer {
         }
         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 contextFile - Optional context file for prioritization
+     * @returns Prioritized array of source files
+     * @private
+     */
+    prioritizeSourceFiles(sourceFiles, contextFile) {
+        if (!contextFile) {
+            return sourceFiles;
+        }
+        const contextDir = contextFile.substring(0, contextFile.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.
      *
@@ -319,13 +374,14 @@ class SchemaTransformer {
      * Transforms a TypeScript class declaration into a schema object.
      *
      * @param classNode - The TypeScript class declaration node
+     * @param sourceFile - The source file containing the class (for context)
      * @returns Object containing class name and generated schema
      * @private
      */
-    transformClass(classNode) {
+    transformClass(classNode, sourceFile) {
         const className = classNode.name?.text || 'Unknown';
         const properties = this.extractProperties(classNode);
-        const schema = this.generateSchema(properties);
+        const schema = this.generateSchema(properties, sourceFile?.fileName);
         return { name: className, schema };
     }
     /**
@@ -369,6 +425,237 @@ class SchemaTransformer {
         const type = this.checker.getTypeAtLocation(property);
         return this.checker.typeToString(type);
     }
+    /**
+     * Resolves generic types by analyzing the type alias and its arguments.
+     * For example, User<Role> where User is a type alias will be resolved to its structure.
+     *
+     * @param typeNode - The TypeScript type reference node with generic arguments
+     * @returns String representation of the resolved type or schema
+     * @private
+     */
+    resolveGenericType(typeNode) {
+        const typeName = typeNode.typeName.text;
+        const typeArguments = typeNode.typeArguments;
+        if (!typeArguments || typeArguments.length === 0) {
+            return typeName;
+        }
+        // Try to resolve the type using the TypeScript type checker
+        const type = this.checker.getTypeAtLocation(typeNode);
+        const resolvedType = this.checker.typeToString(type);
+        // If we can resolve it to a meaningful structure, use that
+        if (resolvedType &&
+            resolvedType !== typeName &&
+            !resolvedType.includes('any')) {
+            // For type aliases like User<Role>, we want to create a synthetic type name
+            // that represents the resolved structure
+            const typeArgNames = typeArguments.map(arg => {
+                if (ts.isTypeReferenceNode(arg) && ts.isIdentifier(arg.typeName)) {
+                    return arg.typeName.text;
+                }
+                return this.getTypeNodeToString(arg);
+            });
+            return `${typeName}_${typeArgNames.join('_')}`;
+        }
+        return typeName;
+    }
+    /**
+     * Checks if a type string represents a resolved generic type.
+     *
+     * @param type - The type string to check
+     * @returns True if it's a resolved generic type
+     * @private
+     */
+    isResolvedGenericType(type) {
+        // Simple heuristic: resolved generic types contain underscores and
+        // the parts after underscore should be known types
+        const parts = type.split('_');
+        return (parts.length > 1 &&
+            parts
+                .slice(1)
+                .every(part => this.isKnownType(part) || this.isPrimitiveType(part)));
+    }
+    /**
+     * Checks if a type is a known class or interface.
+     *
+     * @param typeName - The type name to check
+     * @returns True if it's a known type
+     * @private
+     */
+    isKnownType(typeName) {
+        // First check if it's a primitive type to avoid unnecessary lookups
+        if (this.isPrimitiveType(typeName)) {
+            return true;
+        }
+        try {
+            // Use a more conservative approach - check if we can find the class
+            // without actually transforming it to avoid side effects
+            const found = this.findClassInProject(typeName);
+            return found !== null;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Finds a class by name in the project without transforming it.
+     *
+     * @param className - The class name to find
+     * @returns True if found, false otherwise
+     * @private
+     */
+    findClassInProject(className) {
+        const sourceFiles = this.program.getSourceFiles().filter(sf => {
+            if (sf.isDeclarationFile)
+                return false;
+            if (sf.fileName.includes('.d.ts'))
+                return false;
+            if (sf.fileName.includes('node_modules'))
+                return false;
+            return true;
+        });
+        for (const sourceFile of sourceFiles) {
+            const found = this.findClassByName(sourceFile, className);
+            if (found)
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if a type is a primitive type.
+     *
+     * @param typeName - The type name to check
+     * @returns True if it's a primitive type
+     * @private
+     */
+    isPrimitiveType(typeName) {
+        const lowerTypeName = typeName.toLowerCase();
+        // Check against all primitive types from constants
+        const primitiveTypes = [
+            constants.jsPrimitives.String.type.toLowerCase(),
+            constants.jsPrimitives.Number.type.toLowerCase(),
+            constants.jsPrimitives.Boolean.type.toLowerCase(),
+            constants.jsPrimitives.Date.type.toLowerCase(),
+            constants.jsPrimitives.Buffer.type.toLowerCase(),
+            constants.jsPrimitives.Uint8Array.type.toLowerCase(),
+            constants.jsPrimitives.File.type.toLowerCase(),
+            constants.jsPrimitives.UploadFile.type.toLowerCase(),
+            constants.jsPrimitives.BigInt.type.toLowerCase(),
+        ];
+        return primitiveTypes.includes(lowerTypeName);
+    }
+    /**
+     * Resolves a generic type schema by analyzing the type alias structure.
+     *
+     * @param resolvedTypeName - The resolved generic type name (e.g., User_Role)
+     * @returns OpenAPI schema for the resolved generic type
+     * @private
+     */
+    resolveGenericTypeSchema(resolvedTypeName) {
+        const parts = resolvedTypeName.split('_');
+        const baseTypeName = parts[0];
+        const typeArgNames = parts.slice(1);
+        if (!baseTypeName) {
+            return null;
+        }
+        // Find the original type alias declaration
+        const typeAliasSymbol = this.findTypeAliasDeclaration(baseTypeName);
+        if (!typeAliasSymbol) {
+            return null;
+        }
+        // Create a schema based on the type alias structure, substituting type parameters
+        return this.createSchemaFromTypeAlias(typeAliasSymbol, typeArgNames);
+    }
+    /**
+     * Finds a type alias declaration by name.
+     *
+     * @param typeName - The type alias name to find
+     * @returns The type alias declaration node or null
+     * @private
+     */
+    findTypeAliasDeclaration(typeName) {
+        for (const sourceFile of this.program.getSourceFiles()) {
+            if (sourceFile.isDeclarationFile)
+                continue;
+            const findTypeAlias = (node) => {
+                if (ts.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+                    return node;
+                }
+                return ts.forEachChild(node, findTypeAlias) || null;
+            };
+            const result = findTypeAlias(sourceFile);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    /**
+     * Creates a schema from a type alias declaration, substituting type parameters.
+     *
+     * @param typeAlias - The type alias declaration
+     * @param typeArgNames - The concrete type arguments
+     * @returns OpenAPI schema for the type alias
+     * @private
+     */
+    createSchemaFromTypeAlias(typeAlias, typeArgNames) {
+        const typeNode = typeAlias.type;
+        if (ts.isTypeLiteralNode(typeNode)) {
+            const schema = {
+                type: 'object',
+                properties: {},
+                required: [],
+            };
+            for (const member of typeNode.members) {
+                if (ts.isPropertySignature(member) &&
+                    member.name &&
+                    ts.isIdentifier(member.name)) {
+                    const propertyName = member.name.text;
+                    const isOptional = !!member.questionToken;
+                    if (member.type) {
+                        const propertyType = this.resolveTypeParameterInTypeAlias(member.type, typeAlias.typeParameters, typeArgNames);
+                        const { type, format, nestedSchema } = this.mapTypeToSchema(propertyType);
+                        if (nestedSchema) {
+                            schema.properties[propertyName] = nestedSchema;
+                        }
+                        else {
+                            schema.properties[propertyName] = { type };
+                            if (format)
+                                schema.properties[propertyName].format = format;
+                        }
+                        if (!isOptional) {
+                            schema.required.push(propertyName);
+                        }
+                    }
+                }
+            }
+            return schema;
+        }
+        return null;
+    }
+    /**
+     * Resolves type parameters in a type alias to concrete types.
+     *
+     * @param typeNode - The type node to resolve
+     * @param typeParameters - The type parameters of the type alias
+     * @param typeArgNames - The concrete type arguments
+     * @returns The resolved type string
+     * @private
+     */
+    resolveTypeParameterInTypeAlias(typeNode, typeParameters, typeArgNames) {
+        if (ts.isTypeReferenceNode(typeNode) &&
+            ts.isIdentifier(typeNode.typeName)) {
+            const typeName = typeNode.typeName.text;
+            // Check if this is a type parameter
+            if (typeParameters) {
+                const paramIndex = typeParameters.findIndex(param => param.name.text === typeName);
+                if (paramIndex !== -1 && paramIndex < typeArgNames.length) {
+                    const resolvedType = typeArgNames[paramIndex];
+                    return resolvedType || typeName;
+                }
+            }
+            return typeName;
+        }
+        return this.getTypeNodeToString(typeNode);
+    }
     /**
      * Converts a TypeScript type node to its string representation.
      *
@@ -394,6 +681,7 @@ class SchemaTransformer {
                         return firstTypeArg.typeName.text;
                     }
                 }
+                return this.resolveGenericType(typeNode);
             }
             return typeNode.typeName.text;
         }
@@ -492,17 +780,18 @@ class SchemaTransformer {
      * Generates an OpenAPI schema from extracted property information.
      *
      * @param properties - Array of property information to process
+     * @param contextFile - Optional context file path for resolving class references
      * @returns Complete OpenAPI schema object with properties and validation rules
      * @private
      */
-    generateSchema(properties) {
+    generateSchema(properties, contextFile) {
         const schema = {
             type: 'object',
             properties: {},
             required: [],
         };
         for (const property of properties) {
-            const { type, format, nestedSchema } = this.mapTypeToSchema(property.type);
+            const { type, format, nestedSchema } = this.mapTypeToSchema(property.type, contextFile);
             if (nestedSchema) {
                 schema.properties[property.name] = nestedSchema;
             }
@@ -513,9 +802,9 @@ class SchemaTransformer {
             }
             // Apply decorators if present
             this.applyDecorators(property.decorators, schema, property.name);
-            // If no decorators are present, apply sensible defaults based on TypeScript types
+            // If no decorators are present, apply type-based format specifications
             if (property.decorators.length === 0) {
-                this.applySensibleDefaults(property, schema);
+                this.applyTypeBasedFormats(property, schema);
             }
             // Determine if property should be required based on decorators and optional status
             this.determineRequiredStatus(property, schema);
@@ -527,14 +816,15 @@ class SchemaTransformer {
      * Handles primitive types, arrays, and nested objects recursively.
      *
      * @param type - The TypeScript type string to map
+     * @param contextFile - Optional context file path for resolving class references
      * @returns Object containing OpenAPI type, optional format, and nested schema
      * @private
      */
-    mapTypeToSchema(type) {
+    mapTypeToSchema(type, contextFile) {
         // Handle arrays
         if (type.endsWith('[]')) {
             const elementType = type.slice(0, -2);
-            const elementSchema = this.mapTypeToSchema(elementType);
+            const elementSchema = this.mapTypeToSchema(elementType, contextFile);
             const items = elementSchema.nestedSchema || {
                 type: elementSchema.type,
             };
@@ -578,9 +868,24 @@ class SchemaTransformer {
                     format: constants.jsPrimitives.UploadFile.format,
                 };
             default:
+                // Check if it's a resolved generic type (e.g., User_Role)
+                if (type.includes('_') && this.isResolvedGenericType(type)) {
+                    try {
+                        const genericSchema = this.resolveGenericTypeSchema(type);
+                        if (genericSchema) {
+                            return {
+                                type: constants.jsPrimitives.Object.value,
+                                nestedSchema: genericSchema,
+                            };
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Failed to resolve generic type ${type}:`, error);
+                    }
+                }
                 // Handle nested objects
                 try {
-                    const nestedResult = this.transformByName(type);
+                    const nestedResult = this.transformByName(type, undefined, contextFile);
                     return {
                         type: constants.jsPrimitives.Object.value,
                         nestedSchema: nestedResult.schema,
@@ -716,68 +1021,232 @@ class SchemaTransformer {
                 case constants.validatorDecorators.ArrayMaxSize.name:
                     schema.properties[propertyName].maxItems = decorator.arguments[0];
                     break;
+                case constants.validatorDecorators.IsEnum.name:
+                    this.applyEnumDecorator(decorator, schema, propertyName, isArrayType);
+                    break;
             }
         }
     }
     /**
-     * Applies sensible default behaviors for properties without class-validator decorators.
-     * This allows the schema generator to work with plain TypeScript classes.
+     * Applies the @IsEnum decorator to a property, handling both primitive values and object enums.
+     * Supports arrays of enum values as well.
      *
-     * @param property - The property information
+     * @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
      */
-    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;
+    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 if (propertyName === 'description' || propertyName === 'bio') {
-                propertySchema.maxLength = 500;
+            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 (propertyName === 'title') {
-                propertySchema.minLength = 1;
-                propertySchema.maxLength = 200;
+            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;
         }
-        if (propertySchema.type === 'integer' || propertySchema.type === 'number') {
-            if (propertyName === 'age') {
-                propertySchema.minimum = 0;
-                propertySchema.maximum = 150;
+    }
+    /**
+     * 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;
+                    }
+                }
             }
-            else if (propertyName === 'id') {
-                propertySchema.minimum = 1;
+            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 if (propertyName.includes('count') ||
-                propertyName.includes('quantity')) {
-                propertySchema.minimum = 0;
+            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) {
+        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.