fix: Dont mutate original input in decycle util function

Author: kamilogorek

CHANGELOG.md

@@ -3,6 +3,7 @@
 ## Unreleased
 
 - [browser] fix: DOMError and DOMException should be error level events
+- [utils] fix: Dont mutate original input in decycle util function
 - [utils] ref: Update wrap method to hide internal sentry flags
 - [utils] fix: Make internal Sentry flags non-enumerable in fill util
 

packages/utils/src/object.ts

@@ -1,5 +1,5 @@
 import { SentryWrappedFunction } from '@sentry/types';
-import { isNaN, isPlainObject, isPrimitive, isUndefined } from './is';
+import { isArray, isNaN, isPlainObject, isPrimitive, isUndefined } from './is';
 import { Memo } from './memo';
 import { truncate } from './string';
 
@@ -153,7 +153,7 @@ export function serializeObject<T>(value: T, depth: number): T | string | {} {
     });
 
     return serialized;
-  } else if (Array.isArray(value)) {
+  } else if (isArray(value)) {
     const val = (value as any) as T[];
     return val.map(v => serializeObject(v, depth - 1));
   }
@@ -325,19 +325,23 @@ function normalizeValue(value: any, key?: any): any {
  * @param obj Object to be decycled
  * @param memo Optional Memo class handling decycling
  */
-function decycle(obj: any, memo: Memo = new Memo()): any {
+export function decycle(obj: any, memo: Memo = new Memo()): any {
+  // tslint:disable-next-line:no-unsafe-any
+  const copy = isArray(obj) ? [...obj] : isPlainObject(obj) ? { ...obj } : obj;
+
   if (!isPrimitive(obj)) {
     if (memo.memoize(obj)) {
       return '[Circular ~]';
     }
     // tslint:disable-next-line
     for (const key in obj) {
       // tslint:disable-next-line
-      obj[key] = decycle(obj[key], memo);
+      copy[key] = decycle(obj[key], memo);
     }
     memo.unmemoize(obj);
   }
-  return obj;
+
+  return copy;
 }
 
 /**

packages/utils/test/object.test.ts

@@ -1,5 +1,6 @@
 import {
   clone,
+  decycle,
   deserialize,
   fill,
   safeNormalize,
@@ -24,6 +25,93 @@ describe('clone()', () => {
   }
 });
 
+describe('decycle()', () => {
+  test('decycles circular objects', () => {
+    const circular = {
+      foo: 1,
+    };
+    circular.bar = circular;
+
+    const decycled = decycle(circular);
+
+    expect(decycled).toEqual({
+      foo: 1,
+      bar: '[Circular ~]',
+    });
+  });
+
+  test('decycles complex circular objects', () => {
+    const circular = {
+      foo: 1,
+    };
+    circular.bar = [
+      {
+        baz: circular,
+      },
+      circular,
+    ];
+    circular.qux = circular.bar[0].baz;
+
+    const decycled = decycle(circular);
+
+    expect(decycled).toEqual({
+      bar: [
+        {
+          baz: '[Circular ~]',
+        },
+        '[Circular ~]',
+      ],
+      foo: 1,
+      qux: '[Circular ~]',
+    });
+  });
+
+  test('dont mutate original object', () => {
+    const circular = {
+      foo: 1,
+    };
+    circular.bar = circular;
+
+    const decycled = decycle(circular);
+
+    expect(decycled).toEqual({
+      foo: 1,
+      bar: '[Circular ~]',
+    });
+    expect(circular.bar).toEqual(circular);
+  });
+
+  test('dont mutate original complex object', () => {
+    const circular = {
+      foo: 1,
+    };
+    circular.bar = [
+      {
+        baz: circular,
+      },
+      circular,
+    ];
+    circular.qux = circular.bar[0].baz;
+
+    const decycled = decycle(circular);
+
+    expect(decycled).toEqual({
+      bar: [
+        {
+          baz: '[Circular ~]',
+        },
+        '[Circular ~]',
+      ],
+      foo: 1,
+      qux: '[Circular ~]',
+    });
+
+    expect(circular.bar[0].baz).toEqual(circular);
+    expect(circular.bar[1]).toEqual(circular);
+    expect(circular.qux).toEqual(circular.bar[0].baz);
+  });
+});
+
 describe('serialize()', () => {
   for (const entry of MATRIX) {
     test(`serializes a ${entry.name}`, () => {