support objects with circular references (#9)

Author: MustafaHaddara

src/index.js

@@ -10,15 +10,30 @@ function objectValues(obj) {
   });
 }
 
-function camelCaseRecursive(obj) {
+function camelCaseRecursive(obj, cache) {
+  if (!cache) {
+    cache = new WeakMap();
+  }
+  let res;
+  if (obj !== null && isObject(obj)) {
+    if (cache.has(obj)) {
+      return cache.get(obj);
+    }
+    if (Array.isArray(obj)) {
+      res = [];
+    } else {
+      res = {};
+    }
+    cache.set(obj, res);
+  }
 
   const transform = obj == null ? obj : mapObj(obj, (key, val) => {
     const newArray = [];
 
     if (Array.isArray(val)) {
       val.forEach((value) => {
         if (isObject(value) && !Array.isArray(value)) {
-          newArray.push(camelCaseRecursive(value));
+          newArray.push(camelCaseRecursive(value, cache));
         } else {
           newArray.push(value);
         }
@@ -30,13 +45,24 @@ function camelCaseRecursive(obj) {
     } else if (val instanceof Date) {
       return [camelCase(key), val];
     } else if (isObject(val)) {
-      return [camelCase(key), camelCaseRecursive(val)];
+      return [camelCase(key), camelCaseRecursive(val, cache)];
     }
 
     return [camelCase(key), val];
   });
 
-  return (Array.isArray(obj) ? objectValues(transform) : transform);
+  if (obj !== null && isObject(obj)) {
+    // mutate the entry in the cache so that self-references still line up
+    if (Array.isArray(obj)) {
+      objectValues(transform).forEach(entry => res.push(entry));
+    } else {
+      Object.entries(transform).forEach(([k, v]) => res[k] = v);
+    }
+
+    return res;
+  }
+
+  return transform;
 
 }
 

test/index.js

@@ -174,6 +174,76 @@ describe('Nested keys within arrays and objects are camelCased', () => {
 
 });
 
+describe('Circular references', () => {
+  it('Should handle objects with circular references', () => {
+    const parent = {
+      my_name: 'parent',
+    };
+    parent.child = parent;
+
+    const selfReferentialCamel = camelCaseKeys(parent);
+
+    expect(Object.keys(selfReferentialCamel)).deep.equals(['myName', 'child']);
+    expect(Object.keys(selfReferentialCamel.child)).deep.equals(['myName', 'child']);
+    expect(selfReferentialCamel).to.equal(selfReferentialCamel.child);
+  });
+
+  it('Should handle objects with circular references in their children', () => {
+    const parent = {
+      name: 'parent',
+    };
+    const child = {
+      name: 'child',
+      my_own_parent: parent,
+    }
+    parent.child = child;
+
+    const selfReferentialCamel = camelCaseKeys(parent);
+
+    expect(Object.keys(selfReferentialCamel)).deep.equals(['name', 'child']);
+    expect(Object.keys(selfReferentialCamel.child)).deep.equals(['name', 'myOwnParent']);
+    expect(selfReferentialCamel).to.equal(selfReferentialCamel.child.myOwnParent);
+  });
+
+  it('Should handle arrays with objects with circular references in their children', () => {
+    const parent = {
+      name: 'parent',
+    };
+    const child = {
+      name: 'child',
+      my_own_parent: parent,
+    }
+    parent.child = child;
+
+    const selfReferentialCamel = camelCaseKeys([parent]);
+
+    expect(selfReferentialCamel).to.have.lengthOf(1);
+    expect(Object.keys(selfReferentialCamel[0])).deep.equals(['name', 'child']);
+    expect(Object.keys(selfReferentialCamel[0].child)).deep.equals(['name', 'myOwnParent']);
+    expect(selfReferentialCamel[0]).to.equal(selfReferentialCamel[0].child.myOwnParent);
+  });
+
+  it('Should handle objects with circular references in arrays of their children', () => {
+    const parent = {
+      name: 'parent',
+    };
+    const child = {
+      name: 'child',
+      my_own_parent: parent,
+    }
+    parent.children = [child, child];
+
+    const selfReferentialCamel = camelCaseKeys(parent);
+
+    expect(Object.keys(selfReferentialCamel)).deep.equals(['name', 'children']);
+    expect(Object.keys(selfReferentialCamel.children)).to.have.lengthOf(2);
+    expect(Object.keys(selfReferentialCamel.children[0])).deep.equals(['name', 'myOwnParent']);
+    expect(Object.keys(selfReferentialCamel.children[1])).deep.equals(['name', 'myOwnParent']);
+    expect(selfReferentialCamel).to.equal(selfReferentialCamel.children[0].myOwnParent);
+    expect(selfReferentialCamel).to.equal(selfReferentialCamel.children[1].myOwnParent);
+  });
+});
+
 describe('Handling null root object', () => {
 
   it('Should not throw Error', () => {