ts-class-to-openapi 1.2.0 → 1.2.2

package/README.md

@@ -231,7 +231,7 @@ const schema = transform(User)
 
 ### 4. Enumerations and Special Types
 
-Full compatibility with TypeScript enumerations:
+Full compatibility with TypeScript enumerations (both decorated and pure):
 
 ```typescript
 import { transform } from 'ts-class-to-openapi'
@@ -253,6 +253,9 @@ class Task {
   @IsEnum(UserType)
   assignedTo: UserType
 
+  // Pure TypeScript enum (automatically detected without decorator)
+  status: UserType
+
   @IsEnum(Priority)
   priority?: Priority
 
@@ -276,6 +279,10 @@ const schema = transform(Task)
         "type": "string",
         "enum": ["admin", "user", "moderator"]
       },
+      "status": {
+        "type": "string",
+        "enum": ["admin", "user", "moderator"]
+      },
       "priority": {
         "type": "number",
         "enum": [1, 2, 3]
@@ -287,7 +294,7 @@ const schema = transform(Task)
         "format": "date-time"
       }
     },
-    "required": ["assignedTo", "title", "completed", "dueDate"]
+    "required": ["assignedTo", "status", "title", "completed", "dueDate"]
   }
 }
 ```

package/dist/__test__/entities/enum-classes.d.ts

@@ -0,0 +1,30 @@
+export declare enum UserRole {
+    ADMIN = "admin",
+    USER = "user",
+    GUEST = "guest"
+}
+export declare enum OrderStatus {
+    PENDING = 0,
+    PROCESSING = 1,
+    SHIPPED = 2,
+    DELIVERED = 3,
+    CANCELLED = 4
+}
+export declare enum MixedEnum {
+    YES = "yes",
+    NO = 0
+}
+export declare class EnumTestEntity {
+    role: UserRole;
+    status: OrderStatus;
+    mixed: MixedEnum;
+}
+export declare class ArrayEnumTestEntity {
+    roles: UserRole[];
+    statuses: OrderStatus[];
+}
+export declare class PureEnumTestEntity {
+    role: UserRole;
+    status: OrderStatus;
+    mixed: MixedEnum;
+}

package/dist/__test__/index.d.ts

@@ -1,3 +1,4 @@
 import './testCases/pure-classes.test';
 import './testCases/decorated-classes.test';
 import './testCases/nested-classes.test';
+import './testCases/enum-properties.test';

package/dist/index.esm.js

@@ -110,7 +110,8 @@ class SchemaTransformer {
                 const decorators = this.extractDecorators(member);
                 const isOptional = !!member.questionToken;
                 const isGeneric = this.isPropertyTypeGeneric(member);
-                const isPrimitive = this.isPrimitiveType(type);
+                const isEnum = this.isEnum(member);
+                const isPrimitive = this.isPrimitiveType(type) || isEnum;
                 const isClassType = this.isClassType(member);
                 const isArray = this.isArrayProperty(member);
                 const isTypeLiteral = this.isTypeLiteral(member);
@@ -124,6 +125,7 @@ class SchemaTransformer {
                     isPrimitive,
                     isClassType,
                     isArray,
+                    isEnum,
                     isRef: false,
                     isTypeLiteral: isTypeLiteral,
                 };
@@ -275,9 +277,15 @@ class SchemaTransformer {
                 return true;
             if (arg.kind === ts.SyntaxKind.FalseKeyword)
                 return false;
-            return arg.getText();
+            return arg;
         });
     }
+    getSafeDecoratorArgument(arg) {
+        if (arg && typeof arg === 'object' && 'kind' in arg) {
+            return arg.getText();
+        }
+        return arg;
+    }
     isPropertyTypeGeneric(property) {
         if (property.type && this.isGenericTypeFromNode(property.type)) {
             return true;
@@ -475,49 +483,135 @@ class SchemaTransformer {
             }
         }
     }
+    isEnum(propertyDeclaration) {
+        if (!propertyDeclaration.type) {
+            return false;
+        }
+        let typeNode = propertyDeclaration.type;
+        if (ts.isArrayTypeNode(typeNode)) {
+            typeNode = typeNode.elementType;
+        }
+        if (ts.isTypeReferenceNode(typeNode)) {
+            const type = this.checker.getTypeAtLocation(typeNode);
+            // console.log('isEnum check:', typeNode.getText(), type.flags)
+            return (!!(type.flags & ts.TypeFlags.Enum) ||
+                !!(type.flags & ts.TypeFlags.EnumLiteral));
+        }
+        return false;
+    }
     isClassType(propertyDeclaration) {
         // If there's no explicit type annotation, we can't determine reliably
         if (!propertyDeclaration.type) {
             return false;
         }
         // Check if the original property type is an array type
-        if (this.isArrayProperty(propertyDeclaration) &&
-            ts.isTypeReferenceNode(propertyDeclaration.type
-                .elementType)) {
-            const type = this.checker.getTypeAtLocation(propertyDeclaration.type.elementType);
+        if (this.isArrayProperty(propertyDeclaration)) {
+            const arrayType = propertyDeclaration.type;
+            const elementType = arrayType.elementType;
+            // Special handling for utility types with type arguments (e.g., PayloadEntity<Person>)
+            if (ts.isTypeReferenceNode(elementType) &&
+                elementType.typeArguments &&
+                elementType.typeArguments.length > 0) {
+                // Check the first type argument - it might be the actual class
+                const firstTypeArg = elementType.typeArguments[0];
+                if (firstTypeArg) {
+                    const argType = this.checker.getTypeAtLocation(firstTypeArg);
+                    const argSymbol = argType.getSymbol();
+                    if (argSymbol && argSymbol.declarations) {
+                        const hasClass = argSymbol.declarations.some(decl => ts.isClassDeclaration(decl));
+                        if (hasClass)
+                            return true;
+                    }
+                }
+            }
+            // Get the type from the element, regardless of its syntaxkind
+            const type = this.checker.getTypeAtLocation(elementType);
             const symbol = type.getSymbol();
             if (symbol && symbol.declarations) {
                 return symbol.declarations.some(decl => ts.isClassDeclaration(decl));
             }
+            return false;
         }
-        else if (ts.isTypeReferenceNode(propertyDeclaration.type)) {
+        // Check non-array types
+        else {
+            // Special handling for utility types with type arguments (e.g., PayloadEntity<Branch>)
+            if (ts.isTypeReferenceNode(propertyDeclaration.type) &&
+                propertyDeclaration.type.typeArguments &&
+                propertyDeclaration.type.typeArguments.length > 0) {
+                // Check the first type argument - it might be the actual class
+                const firstTypeArg = propertyDeclaration.type.typeArguments[0];
+                if (firstTypeArg) {
+                    const argType = this.checker.getTypeAtLocation(firstTypeArg);
+                    const argSymbol = argType.getSymbol();
+                    if (argSymbol && argSymbol.declarations) {
+                        const hasClass = argSymbol.declarations.some(decl => ts.isClassDeclaration(decl));
+                        if (hasClass)
+                            return true;
+                    }
+                }
+            }
             const type = this.checker.getTypeAtLocation(propertyDeclaration.type);
             const symbol = type.getSymbol();
             if (symbol && symbol.declarations) {
                 return symbol.declarations.some(decl => ts.isClassDeclaration(decl));
             }
+            return false;
         }
-        return false;
     }
     getDeclarationProperty(property) {
         if (!property.originalProperty.type) {
             return undefined;
         }
-        if (ts.isArrayTypeNode(property.originalProperty.type) &&
-            ts.isTypeReferenceNode(property.originalProperty.type.elementType)) {
-            const type = this.checker.getTypeAtLocation(property.originalProperty.type.elementType);
+        // Handle array types - get the element type
+        if (ts.isArrayTypeNode(property.originalProperty.type)) {
+            const elementType = property.originalProperty.type.elementType;
+            // Check if it's a utility type with type arguments (e.g., PayloadEntity<Branch>[])
+            if (ts.isTypeReferenceNode(elementType) &&
+                elementType.typeArguments &&
+                elementType.typeArguments.length > 0) {
+                const firstTypeArg = elementType.typeArguments[0];
+                if (firstTypeArg) {
+                    const argType = this.checker.getTypeAtLocation(firstTypeArg);
+                    const argSymbol = argType.getSymbol();
+                    if (argSymbol && argSymbol.declarations) {
+                        const classDecl = argSymbol.declarations.find(decl => ts.isClassDeclaration(decl));
+                        if (classDecl)
+                            return classDecl;
+                    }
+                }
+            }
+            const type = this.checker.getTypeAtLocation(elementType);
             const symbol = type.getSymbol();
             if (symbol && symbol.declarations) {
-                return symbol.declarations[0];
+                // Return the first class declaration found
+                const classDecl = symbol.declarations.find(decl => ts.isClassDeclaration(decl));
+                return classDecl || symbol.declarations[0];
             }
+            return undefined;
         }
-        else if (ts.isTypeReferenceNode(property.originalProperty.type)) {
-            const type = this.checker.getTypeAtLocation(property.originalProperty.type);
-            const symbol = type.getSymbol();
-            if (symbol && symbol.declarations) {
-                return symbol.declarations[0];
+        // Handle non-array types
+        // Check if it's a utility type with type arguments (e.g., PayloadEntity<Branch>)
+        if (ts.isTypeReferenceNode(property.originalProperty.type) &&
+            property.originalProperty.type.typeArguments &&
+            property.originalProperty.type.typeArguments.length > 0) {
+            const firstTypeArg = property.originalProperty.type.typeArguments[0];
+            if (firstTypeArg) {
+                const argType = this.checker.getTypeAtLocation(firstTypeArg);
+                const argSymbol = argType.getSymbol();
+                if (argSymbol && argSymbol.declarations) {
+                    const classDecl = argSymbol.declarations.find(decl => ts.isClassDeclaration(decl));
+                    if (classDecl)
+                        return classDecl;
+                }
             }
         }
+        const type = this.checker.getTypeAtLocation(property.originalProperty.type);
+        const symbol = type.getSymbol();
+        if (symbol && symbol.declarations) {
+            // Return the first class declaration found
+            const classDecl = symbol.declarations.find(decl => ts.isClassDeclaration(decl));
+            return classDecl || symbol.declarations[0];
+        }
         return undefined;
     }
     isArrayProperty(propertyDeclaration) {
@@ -654,7 +748,58 @@ class SchemaTransformer {
         transformedSchema.set(declaration.name.text, schema);
         return schema;
     }
+    getSchemaFromEnum(property) {
+        let typeNode = property.originalProperty.type;
+        if (ts.isArrayTypeNode(typeNode)) {
+            typeNode = typeNode.elementType;
+        }
+        const type = this.checker.getTypeAtLocation(typeNode);
+        if (type.symbol && type.symbol.exports) {
+            const values = [];
+            type.symbol.exports.forEach(member => {
+                const declaration = member.valueDeclaration;
+                if (declaration && ts.isEnumMember(declaration)) {
+                    const value = this.checker.getConstantValue(declaration);
+                    if (value !== undefined) {
+                        values.push(value);
+                    }
+                }
+            });
+            if (values.length > 0) {
+                const propertySchema = { type: 'object' };
+                propertySchema.enum = values;
+                const isString = values.every(v => typeof v === 'string');
+                const isNumber = values.every(v => typeof v === 'number');
+                if (isString) {
+                    propertySchema.type = 'string';
+                }
+                else if (isNumber) {
+                    propertySchema.type = 'number';
+                }
+                else {
+                    propertySchema.type = 'string';
+                }
+                if (property.isArray) {
+                    const itemsSchema = { ...propertySchema };
+                    propertySchema.type = 'array';
+                    propertySchema.items = itemsSchema;
+                    delete propertySchema.enum;
+                    return propertySchema;
+                }
+                else {
+                    return propertySchema;
+                }
+            }
+        }
+        return undefined;
+    }
     getSchemaFromPrimitive(property) {
+        if (property.isEnum) {
+            const enumSchema = this.getSchemaFromEnum(property);
+            if (enumSchema) {
+                return enumSchema;
+            }
+        }
         const propertySchema = { type: 'object' };
         const propertyType = property.type.toLowerCase().replace('[]', '').trim();
         let isFile = false;
@@ -742,8 +887,40 @@ class SchemaTransformer {
             ts.isTypeReferenceNode(typeNode) // Omit, Pick, Partial, etc.
         );
     }
-    //Todo: implement properly
-    applyEnumDecorator(decorator, schema) { }
+    applyEnumDecorator(decorator, schema) {
+        if (decorator.arguments.length === 0)
+            return;
+        const arg = decorator.arguments[0];
+        if (arg && typeof arg === 'object' && 'kind' in arg) {
+            const type = this.checker.getTypeAtLocation(arg);
+            if (type.symbol && type.symbol.exports) {
+                const values = [];
+                type.symbol.exports.forEach(member => {
+                    const declaration = member.valueDeclaration;
+                    if (declaration && ts.isEnumMember(declaration)) {
+                        const value = this.checker.getConstantValue(declaration);
+                        if (value !== undefined) {
+                            values.push(value);
+                        }
+                    }
+                });
+                if (values.length > 0) {
+                    schema.enum = values;
+                    const isString = values.every(v => typeof v === 'string');
+                    const isNumber = values.every(v => typeof v === 'number');
+                    if (isString) {
+                        schema.type = 'string';
+                    }
+                    else if (isNumber) {
+                        schema.type = 'number';
+                    }
+                    else {
+                        schema.type = 'string';
+                    }
+                }
+            }
+        }
+    }
     applyDecorators(property, schema) {
         for (const decorator of property.decorators) {
             const decoratorName = decorator.name;
@@ -807,22 +984,22 @@ class SchemaTransformer {
                     property.isOptional = true;
                     break;
                 case constants.validatorDecorators.MinLength.name:
-                    schema.minLength = decorator.arguments[0];
+                    schema.minLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.MaxLength.name:
-                    schema.maxLength = decorator.arguments[0];
+                    schema.maxLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.Length.name:
-                    schema.minLength = decorator.arguments[0];
+                    schema.minLength = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     if (decorator.arguments[1]) {
-                        schema.maxLength = decorator.arguments[1];
+                        schema.maxLength = this.getSafeDecoratorArgument(decorator.arguments[1]);
                     }
                     break;
                 case constants.validatorDecorators.Min.name:
-                    schema.minimum = decorator.arguments[0];
+                    schema.minimum = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.Max.name:
-                    schema.maximum = decorator.arguments[0];
+                    schema.maximum = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.IsPositive.name:
                     schema.minimum = 0;
@@ -835,13 +1012,18 @@ class SchemaTransformer {
                     property.isOptional = false;
                     break;
                 case constants.validatorDecorators.ArrayMinSize.name:
-                    schema.minItems = decorator.arguments[0];
+                    schema.minItems = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.ArrayMaxSize.name:
-                    schema.maxItems = decorator.arguments[0];
+                    schema.maxItems = this.getSafeDecoratorArgument(decorator.arguments[0]);
                     break;
                 case constants.validatorDecorators.IsEnum.name:
-                    this.applyEnumDecorator(decorator, schema);
+                    if (!property.isArray) {
+                        this.applyEnumDecorator(decorator, schema);
+                    }
+                    else if (schema.items) {
+                        this.applyEnumDecorator(decorator, schema.items);
+                    }
                     break;
             }
         }