Merge pull request #62 from sheiidan/skip-circular-check

Add skipCircularCheck option

Author: pleerock

package.json

@@ -30,6 +30,7 @@
     "@types/es6-shim": "^0.31.32",
     "@types/mocha": "^2.2.33",
     "@types/node": "0.0.2",
+    "@types/sinon": "^2.2.2",
     "chai": "^3.4.1",
     "chai-as-promised": "^6.0.0",
     "del": "^2.2.1",

src/ClassTransformOptions.ts

@@ -56,4 +56,10 @@ export interface ClassTransformOptions {
      */
     targetMaps?: TargetMap[];
 
+
+    /**
+     * If set to true then class transformer will perform a circular check. (circular check is turned off by default)
+     * This option is useful when you know for sure that your types might have a circular dependency.
+     */
+    enableCircularCheck?: boolean;
 }

src/TransformOperationExecutor.ts

@@ -11,7 +11,7 @@ export class TransformOperationExecutor {
     // Private Properties
     // -------------------------------------------------------------------------
 
-    private transformedTypes: { level: number, object: Object }[] = [];
+    private transformedTypesMap = new Map<Object, { level: number, object: Object }>();
 
     // -------------------------------------------------------------------------
     // Constructor
@@ -36,7 +36,7 @@ export class TransformOperationExecutor {
             const newValue = arrayType && this.transformationType === "plainToClass" ? new (arrayType as any)() : [];
             (value as any[]).forEach((subValue, index) => {
                 const subSource = source ? source[index] : undefined;
-                if (!this.isCircular(subValue, level)) {
+                if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
                     const value = this.transform(subSource, subValue, targetType, undefined, subValue instanceof Map, level + 1);
                     if (newValue instanceof Set) {
                         newValue.add(value);
@@ -77,8 +77,10 @@ export class TransformOperationExecutor {
             if (!targetType && value.constructor !== Object/* && operationType === "classToPlain"*/) targetType = value.constructor;
             if (!targetType && source) targetType = source.constructor;
 
-            // add transformed type to prevent circular references
-            this.transformedTypes.push({ level: level, object: value });
+            if (this.options.enableCircularCheck) {
+                // add transformed type to prevent circular references
+                this.transformedTypesMap.set(value, { level: level, object: value });
+            }
 
             const keys = this.getKeys(targetType, value);
             let newValue: any = source ? source : {};
@@ -157,7 +159,7 @@ export class TransformOperationExecutor {
                         continue;
                 }
 
-                if (!this.isCircular(subValue, level)) {
+                if (!this.options.enableCircularCheck || !this.isCircular(subValue, level)) {
                     let transformKey = this.transformationType === "plainToClass" ? newValueKey : key;
                     let finalValue = this.transform(subSource, subValue, type, arrayType, isSubValueMap, level + 1);
                     finalValue = this.applyCustomTransformations(finalValue, targetType, transformKey);
@@ -222,7 +224,8 @@ export class TransformOperationExecutor {
 
     // preventing circular references
     private isCircular(object: Object, level: number) {
-        return !!this.transformedTypes.find(transformed => transformed.object === object && transformed.level < level);
+        const transformed = this.transformedTypesMap.get(object);
+        return transformed !== undefined && transformed.level < level;
     }
 
     private getReflectedType(target: Function, propertyName: string) {

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

@@ -1,6 +1,9 @@
 import "reflect-metadata";
-import {classToPlain, classToClass} from "../../src/index";
+import {classToPlain, classToClass, plainToClass} from "../../src/index";
 import {defaultMetadataStorage} from "../../src/storage";
+import {TransformOperationExecutor} from "../../src/TransformOperationExecutor";
+import {assert} from "chai";
+import * as sinon from "sinon";
 
 describe("circular reference problem", () => {
 
@@ -37,7 +40,7 @@ describe("circular reference problem", () => {
         photo1.users = [user];
         photo2.users = [user];
 
-        const plainUser = classToPlain(user);
+        const plainUser = classToPlain(user, { enableCircularCheck: true });
         plainUser.should.be.eql({
             firstName: "Umed Khudoiberdiev",
             photos: [{
@@ -86,11 +89,49 @@ describe("circular reference problem", () => {
         photo1.users = [user];
         photo2.users = [user];
 
-        const classUser = classToClass(user);
+        const classUser = classToClass(user, { enableCircularCheck: true });
         classUser.should.not.be.equal(user);
         classUser.should.be.instanceOf(User);
         classUser.should.be.eql(user);
 
     });
 
+    describe("enableCircularCheck option", () => {
+        class Photo {
+            id: number;
+            filename: string;
+        }
+
+        class User {
+            id: number;
+            firstName: string;
+            photos: Photo[];
+        }
+        let isCircularSpy: sinon.SinonSpy;
+        const photo1 = new Photo();
+        photo1.id = 1;
+        photo1.filename = "me.jpg";
+
+        const user = new User();
+        user.firstName = "Umed Khudoiberdiev";
+        user.photos = [photo1];
+
+        beforeEach(() => {
+            isCircularSpy = sinon.spy(TransformOperationExecutor.prototype, "isCircular");
+        });
+
+        afterEach(() => {
+            isCircularSpy.restore();
+        });
+
+        it("enableCircularCheck option is undefined (default)", () => {
+            const result = plainToClass<User, Object>(User, user); 
+            sinon.assert.notCalled(isCircularSpy);
+        });
+
+        it("enableCircularCheck option is true", () => {
+            const result = plainToClass<User, Object>(User, user, { enableCircularCheck: true }); 
+            sinon.assert.called(isCircularSpy);
+        });
+    });
 });