ts-class-to-openapi 1.0.4 → 1.0.5

package/README.md

@@ -8,7 +8,6 @@ A powerful library that automatically converts your TypeScript classes into Open
 >
 > - **Pure TypeScript classes** without requiring any decorators or external dependencies!
 > - **Full enum support** with `@IsEnum` decorator for string, numeric, and object enums
-> - Perfect for transforming existing codebases instantly.
 
 ## 🚀 Key Features
 
@@ -793,7 +792,16 @@ const schema = transform(User)
         "format": "binary"
       }
     },
-    "required": ["id", "name", "email", "tags", "createdAt", "role", "files", "avatar"]
+    "required": [
+      "id",
+      "name",
+      "email",
+      "tags",
+      "createdAt",
+      "role",
+      "files",
+      "avatar"
+    ]
   }
 }
 ```
@@ -802,19 +810,19 @@ const schema = transform(User)
 
 ## 📊 Pure TypeScript vs Enhanced Mode Comparison
 
-| Feature                | Pure TypeScript                       | Enhanced (class-validator)           |
-| ---------------------- | ------------------------------------- | ------------------------------------ |
-| **Dependencies**       | Zero                                  | Requires `class-validator`           |
-| **Configuration**      | None                                  | `experimentalDecorators: true`       |
-| **Type Detection**     | Automatic                             | Automatic + Decorators               |
-| **Validation Rules**   | Basic types only                      | Rich validation constraints          |
+| Feature                | Pure TypeScript                             | Enhanced (class-validator)                |
+| ---------------------- | ------------------------------------------- | ----------------------------------------- |
+| **Dependencies**       | Zero                                        | Requires `class-validator`                |
+| **Configuration**      | None                                        | `experimentalDecorators: true`            |
+| **Type Detection**     | Automatic                                   | Automatic + Decorators                    |
+| **Validation Rules**   | Basic types only                            | Rich validation constraints               |
 | **Required Fields**    | Based on TypeScript optional operator (`?`) | TypeScript optional operator + decorators |
-| **String Constraints** | None                                  | Min/max length, patterns             |
-| **Number Constraints** | None                                  | Min/max values, positive             |
-| **Array Constraints**  | None                                  | Min/max items, non-empty             |
-| **Email Validation**   | None                                  | Email format validation              |
-| **Date Handling**      | `date-time` format                    | `date-time` format                   |
-| **Use Case**           | Existing codebases, rapid prototyping | APIs with validation, robust schemas |
+| **String Constraints** | None                                        | Min/max length, patterns                  |
+| **Number Constraints** | None                                        | Min/max values, positive                  |
+| **Array Constraints**  | None                                        | Min/max items, non-empty                  |
+| **Email Validation**   | None                                        | Email format validation                   |
+| **Date Handling**      | `date-time` format                          | `date-time` format                        |
+| **Use Case**           | Existing codebases, rapid prototyping       | APIs with validation, robust schemas      |
 
 ### Example Comparison
 
@@ -822,9 +830,9 @@ const schema = transform(User)
 
 ```typescript
 class User {
-  name: string    // Required (no ? operator)
-  email: string   // Required (no ? operator)  
-  age: number     // Required (no ? operator)
+  name: string // Required (no ? operator)
+  email: string // Required (no ? operator)
+  age: number // Required (no ? operator)
 }
 // Generates: All properties required (no ? operator), basic types
 ```
@@ -1139,10 +1147,10 @@ The presence or absence of the TypeScript optional operator (`?`) determines if
 
 ```typescript
 class User {
-  name: string    // ✅ REQUIRED (no ? operator)
-  email: string   // ✅ REQUIRED (no ? operator)
-  age?: number    // ❌ OPTIONAL (has ? operator)
-  bio?: string    // ❌ OPTIONAL (has ? operator)
+  name: string // ✅ REQUIRED (no ? operator)
+  email: string // ✅ REQUIRED (no ? operator)
+  age?: number // ❌ OPTIONAL (has ? operator)
+  bio?: string // ❌ OPTIONAL (has ? operator)
 }
 
 // Generated schema:
@@ -1158,12 +1166,12 @@ import { IsNotEmpty, IsOptional } from 'class-validator'
 
 class User {
   @IsNotEmpty()
-  requiredField?: string  // ✅ REQUIRED (@IsNotEmpty overrides ?)
-  
+  requiredField?: string // ✅ REQUIRED (@IsNotEmpty overrides ?)
+
   @IsOptional()
-  optionalField: string   // ❌ OPTIONAL (@IsOptional overrides no ?)
-  
-  normalField: string     // ✅ REQUIRED (no ? operator)
+  optionalField: string // ❌ OPTIONAL (@IsOptional overrides no ?)
+
+  normalField: string // ✅ REQUIRED (no ? operator)
   normalOptional?: string // ❌ OPTIONAL (has ? operator)
 }
 
@@ -1179,12 +1187,12 @@ Array properties follow the same rules, with additional decorators:
 import { ArrayNotEmpty } from 'class-validator'
 
 class User {
-  tags: string[]           // ✅ REQUIRED (no ? operator)
-  
+  tags: string[] // ✅ REQUIRED (no ? operator)
+
   @ArrayNotEmpty()
-  categories?: string[]    // ✅ REQUIRED (@ArrayNotEmpty overrides ?)
-  
-  optionalTags?: string[]  // ❌ OPTIONAL (has ? operator)
+  categories?: string[] // ✅ REQUIRED (@ArrayNotEmpty overrides ?)
+
+  optionalTags?: string[] // ❌ OPTIONAL (has ? operator)
 }
 
 // Generated schema:

package/dist/__test__/circular-reference.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/entities/circular.entity.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Example entity demonstrating circular reference issue
+ * User -> Role -> User (circular)
+ */
+export declare class CircularUser {
+    id: string;
+    name: string;
+    role: CircularRole;
+    organization: CircularOrganization;
+    organizations: CircularOrganization[];
+}
+export declare class CircularRole {
+    id: string;
+    name: string;
+    assignedBy: CircularUser;
+    organization: CircularOrganization;
+    usersWithRole: CircularUser[];
+}
+/**
+ * Example entity demonstrating complex circular references
+ * Organization -> User, Role, Organization (multiple circular references)
+ */
+export declare class CircularOrganization {
+    id: string;
+    name: string;
+    owner: CircularUser;
+    defaultRole: CircularRole;
+    members: CircularUser[];
+    availableRoles: CircularRole[];
+    parentOrganization?: CircularOrganization;
+    childOrganizations: CircularOrganization[];
+}
+/**
+ * Example demonstrating deep circular reference chain
+ * A -> B -> C -> D -> A (complex chain)
+ */
+export declare class DeepCircularA {
+    id: string;
+    reference: DeepCircularB;
+}
+export declare class DeepCircularB {
+    id: string;
+    reference: DeepCircularC;
+}
+export declare class DeepCircularC {
+    id: string;
+    reference: DeepCircularD;
+}
+export declare class DeepCircularD {
+    id: string;
+    reference: DeepCircularA;
+    allReferences: {
+        a: DeepCircularA;
+        b: DeepCircularB;
+        c: DeepCircularC;
+        selfRef: DeepCircularD;
+    };
+    arrayReferences: (DeepCircularA | DeepCircularB | DeepCircularC | DeepCircularD)[];
+}

package/dist/__test__/index.d.ts

@@ -4,3 +4,6 @@ import './plain.test';
 import './optional-properties.test';
 import './generic-types.test';
 import './enum.test';
+import './circular-reference.test';
+import './ref-pattern.test';
+import './singleton-behavior.test';

package/dist/__test__/ref-pattern.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/singleton-behavior.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { transform } from './transformer';
-import { SchemaType } from './types';
-export { transform, type SchemaType };
+import { transform, SchemaTransformer } from './transformer';
+import { SchemaType, TransformerOptions } from './types';
+export { transform, SchemaTransformer, type SchemaType, type TransformerOptions, };