Implement circular checks using DFS recursion stack method

Author: guscastro

src/TransformOperationExecutor.ts

@@ -14,7 +14,7 @@ export class TransformOperationExecutor {
     // Private Properties
     // -------------------------------------------------------------------------
 
-    private transformedTypesMap = new Map<Object, {level: number, object: Object}>();
+    private recursionStack = new Set<Object>();
 
     // -------------------------------------------------------------------------
     // Constructor
@@ -39,7 +39,7 @@ export class TransformOperationExecutor {
             const newValue = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS ? new (arrayType as any)() : [];
             (value as any[]).forEach((subValue, index) => {
                 const subSource = source ? source[index] : undefined;
-                if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
+                if (!this.options.enableCircularCheck || !this.isCircular(subValue)) {
                     const value = this.transform(subSource, subValue, targetType, undefined, subValue instanceof Map, level + 1);
                     if (newValue instanceof Set) {
                         newValue.add(value);
@@ -82,7 +82,7 @@ export class TransformOperationExecutor {
 
             if (this.options.enableCircularCheck) {
                 // add transformed type to prevent circular references
-                this.transformedTypesMap.set(value, {level: level, object: value});
+                this.recursionStack.add(value);
             }
 
             const keys = this.getKeys(targetType, value);
@@ -162,7 +162,7 @@ export class TransformOperationExecutor {
                         continue;
                 }
 
-                if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
+                if (!this.options.enableCircularCheck || !this.isCircular(subValue)) {
                     let transformKey = this.transformationType === TransformationType.PLAIN_TO_CLASS ? newValueKey : key;
                     let finalValue = this.transform(subSource, subValue, type, arrayType, isSubValueMap, level + 1);
                     finalValue = this.applyCustomTransformations(finalValue, targetType, transformKey, value, this.transformationType);
@@ -182,6 +182,11 @@ export class TransformOperationExecutor {
                 }
 
             }
+
+            if (this.options.enableCircularCheck) {
+                this.recursionStack.delete(value);
+            }
+
             return newValue;
 
         } else {
@@ -224,9 +229,8 @@ export class TransformOperationExecutor {
     }
 
     // preventing circular references
-    private isCircular(object: Object, level: number) {
-        const transformed = this.transformedTypesMap.get(object);
-        return transformed !== undefined && transformed.level < level;
+    private isCircular(object: Object) {
+        return this.recursionStack.has(object);
     }
 
     private getReflectedType(target: Function, propertyName: string) {

test/functional/circular-reference-problem.spec.ts

@@ -7,19 +7,26 @@ import * as sinon from "sinon";
 
 describe("circular reference problem", () => {
 
-    it("should skip circular reference objects", () => {
+    it("should skip circular reference objects in classToPlain operation", () => {
         defaultMetadataStorage.clear();
 
+        class Caption {
+            text: string;
+        }
+
         class Photo {
             id: number;
             filename: string;
             user: User;
             users: User[];
+
+            caption: Caption;
         }
 
         class User {
             id: number;
             firstName: string;
+            caption: Caption;
             photos: Photo[];
         }
 
@@ -31,7 +38,11 @@ describe("circular reference problem", () => {
         photo2.id = 2;
         photo2.filename = "she.jpg";
 
+        const caption = new Caption();
+        caption.text = "cool photo";
+
         const user = new User();
+        user.caption = caption;
         user.firstName = "Umed Khudoiberdiev";
         user.photos = [photo1, photo2];
 
@@ -40,17 +51,23 @@ describe("circular reference problem", () => {
         photo1.users = [user];
         photo2.users = [user];
 
+        photo1.caption = caption;
+        photo2.caption = caption;
+
         const plainUser = classToPlain(user, { enableCircularCheck: true });
         plainUser.should.be.eql({
             firstName: "Umed Khudoiberdiev",
+            caption: { text: "cool photo" },
             photos: [{
                 id: 1,
                 filename: "me.jpg",
-                users: []
+                users: [],
+                caption: { text: "cool photo" }
             }, {
                 id: 2,
                 filename: "she.jpg",
-                users: []
+                users: [],
+                caption: { text: "cool photo" }
             }]
         });