Add skipCircularCheck option

Author: IDAN SHEINBERG

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 not perform a circular check.
+     * This option is useful when you know for sure that your types can't have a circular dependency. You usually use this option to boost the transform operation.
+     */
+    skipCircularCheck?: boolean;
 }

src/TransformOperationExecutor.ts

@@ -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.skipCircularCheck || !this.isCircular(subValue, level)) {
                     const value = this.transform(subSource, subValue, targetType, undefined, subValue instanceof Map, level + 1);
                     if (newValue instanceof Set) {
                         newValue.add(value);
@@ -157,7 +157,7 @@ export class TransformOperationExecutor {
                         continue;
                 }
 
-                if (!this.isCircular(subValue, level)) {
+                if (this.options.skipCircularCheck || !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);

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", () => {
 
@@ -93,4 +96,42 @@ describe("circular reference problem", () => {
 
     });
 
+    describe("skipCircularCheck 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("skipCircularCheck option is true", () => {
+            const result = plainToClass<User, Object>(User, user, { skipCircularCheck: true}); 
+            sinon.assert.notCalled(isCircularSpy);
+        });
+
+        it("skipCircularCheck option is undefined", () => {
+            const result = plainToClass<User, Object>(User, user); 
+            sinon.assert.called(isCircularSpy);
+        });        
+    });
 });