Failsafe for anonymous functions in encode

Author: ajmeese7

src/CryptoUtils.js

@@ -0,0 +1,21 @@
+/**
+ * Helper function that turns a string into a unique 53-bit hash.
+ * @ref https://stackoverflow.com/a/52171480/6456163
+ * @param {string} str
+ * @param {number} seed
+ * @returns {number}
+ */
+export const cyrb53 = (str, seed = 0) => {
+  let h1 = 0xdeadbeef ^ seed, h2 = 0x41c6ce57 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1  = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2  = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};

src/ParseOp.js

@@ -78,7 +78,7 @@ export class SetOp extends Op {
   }
 
   toJSON(offline?: boolean) {
-    return encode(this._value, false, true, undefined, offline);
+    return encode(this._value, false, true, undefined, offline, 0);
   }
 }
 

src/__tests__/ParseObject-test.js

@@ -3878,13 +3878,4 @@ describe('ParseObject pin', () => {
       'Traversing object failed due to high number of recursive calls, likely caused by circular reference within object.'
     );
   });
-
-  it('throws error for infinite recursion', () => {
-    const circularObject = {};
-    circularObject.circularReference = circularObject;
-
-    expect(() => {
-      encode(circularObject, false, false, [], false);
-    }).toThrowError('Encoding object failed due to high number of recursive calls, likely caused by circular reference within object.');
-  });
 });

src/__tests__/encode-test.js

@@ -183,4 +183,13 @@ describe('encode', () => {
       str: 'abc',
     });
   });
+
+  it('handles circular references', () => {
+    const circularObject = {};
+    circularObject.circularReference = circularObject;
+
+    expect(() => {
+      encode(circularObject, false, false, [], false);
+    }).not.toThrow();
+  });
 });

src/encode.js

@@ -9,6 +9,7 @@ import ParsePolygon from './ParsePolygon';
 import ParseObject from './ParseObject';
 import { Op } from './ParseOp';
 import ParseRelation from './ParseRelation';
+import { cyrb53 } from './CryptoUtils';
 
 const MAX_RECURSIVE_CALLS = 999;
 
@@ -18,18 +19,15 @@ function encode(
   forcePointers: boolean,
   seen: Array<mixed>,
   offline: boolean,
-  counter: number = 0
+  counter: number,
+  initialValue: mixed
 ): any {
   counter++;
 
   if (counter > MAX_RECURSIVE_CALLS) {
     const message = 'Encoding object failed due to high number of recursive calls, likely caused by circular reference within object.';
     console.error(message);
-    console.error('Value causing potential infinite recursion:', value);
-    console.error('Disallow objects:', disallowObjects);
-    console.error('Force pointers:', forcePointers);
-    console.error('Seen:', seen);
-    console.error('Offline:', offline);
+    console.error('Value causing potential infinite recursion:', initialValue);
 
     throw new Error(message);
   }
@@ -38,73 +36,90 @@ function encode(
     if (disallowObjects) {
       throw new Error('Parse Objects not allowed here');
     }
-    const seenEntry = value.id ? value.className + ':' + value.id : value;
+    const entryIdentifier = value.id ? value.className + ':' + value.id : value;
     if (
       forcePointers ||
-      !seen ||
-      seen.indexOf(seenEntry) > -1 ||
+      seen.includes(entryIdentifier) ||
       value.dirty() ||
-      Object.keys(value._getServerData()).length < 1
+      Object.keys(value._getServerData()).length === 0
     ) {
       if (offline && value._getId().startsWith('local')) {
         return value.toOfflinePointer();
       }
       return value.toPointer();
     }
-    seen = seen.concat(seenEntry);
+    seen.push(entryIdentifier);
     return value._toFullJSON(seen, offline);
-  }
-  if (
+  } else if (
     value instanceof Op ||
     value instanceof ParseACL ||
     value instanceof ParseGeoPoint ||
     value instanceof ParsePolygon ||
     value instanceof ParseRelation
   ) {
     return value.toJSON();
-  }
-  if (value instanceof ParseFile) {
+  } else if (value instanceof ParseFile) {
     if (!value.url()) {
       throw new Error('Tried to encode an unsaved file.');
     }
     return value.toJSON();
-  }
-  if (Object.prototype.toString.call(value) === '[object Date]') {
+  } else if (Object.prototype.toString.call(value) === '[object Date]') {
     if (isNaN(value)) {
       throw new Error('Tried to encode an invalid date.');
     }
     return { __type: 'Date', iso: (value: any).toJSON() };
-  }
-  if (
+  } else if (
     Object.prototype.toString.call(value) === '[object RegExp]' &&
     typeof value.source === 'string'
   ) {
     return value.source;
-  }
-
-  if (Array.isArray(value)) {
-    return value.map(v => {
-      return encode(v, disallowObjects, forcePointers, seen, offline, counter);
-    });
-  }
-
-  if (value && typeof value === 'object') {
+  } else if (Array.isArray(value)) {
+    return value.map(v => encode(v, disallowObjects, forcePointers, seen, offline, counter, initialValue));
+  } else if (value && typeof value === 'object') {
     const output = {};
     for (const k in value) {
-      output[k] = encode(value[k], disallowObjects, forcePointers, seen, offline, counter);
+      try {
+        // Attempts to get the name of the object's constructor
+        // Ref: https://stackoverflow.com/a/332429/6456163
+        const name = value[k].name || value[k].constructor.name;
+        if (name && name != "undefined") {
+          if (seen.includes(name)) {
+            output[k] = value[k];
+            continue;
+          } else {
+            seen.push(name);
+          }
+        }
+      } catch (e) {
+        // Support anonymous functions by hashing the function body,
+        // preventing infinite recursion in the case of circular references
+        if (value[k] instanceof Function) {
+          const funcString = value[k].toString();
+          if (seen.includes(funcString)) {
+            output[k] = value[k];
+            continue;
+          } else {
+            const hash = cyrb53(funcString);
+            seen.push(hash);
+          }
+        }
+      }
+      output[k] = encode(value[k], disallowObjects, forcePointers, seen, offline, counter, initialValue);
     }
     return output;
+  } else {
+    return value;
   }
-
-  return value;
 }
 
 export default function (
   value: mixed,
   disallowObjects?: boolean,
   forcePointers?: boolean,
   seen?: Array<mixed>,
-  offline?: boolean
+  offline?: boolean,
+  counter?: number,
+  initialValue?: mixed
 ): any {
-  return encode(value, !!disallowObjects, !!forcePointers, seen || [], offline, 0);
+  return encode(value, !!disallowObjects, !!forcePointers, seen || [], !!offline, counter || 0, initialValue || value);
 }

src/unsavedChildren.js

@@ -58,8 +58,8 @@ function traverse(
   if (counter > MAX_RECURSIVE_CALLS) {
     const message = 'Traversing object failed due to high number of recursive calls, likely caused by circular reference within object.';
     console.error(message);
-    console.error('Object causing potential infinite recursion:', obj);
     console.error('Encountered objects:', encountered);
+    console.error('Object causing potential infinite recursion:', obj);
 
     throw new Error(message);
   }
@@ -89,16 +89,11 @@ function traverse(
   if (obj instanceof ParseRelation) {
     return;
   }
-  if (Array.isArray(obj)) {
-    obj.forEach(el => {
-      if (typeof el === 'object') {
-        traverse(el, encountered, shouldThrow, allowDeepUnsaved, counter);
+  if (Array.isArray(obj) || typeof obj === 'object') {
+    for (const k in obj) {
+      if (typeof obj[k] === 'object') {
+        traverse(obj[k], encountered, shouldThrow, allowDeepUnsaved, counter);
       }
-    });
-  }
-  for (const k in obj) {
-    if (typeof obj[k] === 'object') {
-      traverse(obj[k], encountered, shouldThrow, allowDeepUnsaved, counter);
     }
   }
 }