json ref replacement improved

Author: RNEvok

__tests__/helpers/helperFunctions.test.ts

@@ -1,5 +1,5 @@
 import { test, expect } from '@jest/globals';
-import { stringifyIfNotString, jsonStringifyKeepMeta, wrapInObjectIfNotObject, jsonStringifyPossiblyCircular, removeCircularReferencesFromObject } from './../../helpers/helperFunctions';
+import { stringifyIfNotString, jsonStringifyKeepMeta, wrapInObjectIfNotObject, jsonReplacerWithPath, jsonRefReplacer, parseRefJSON, jsonStringifyPossiblyCircular, removeCircularReferencesFromObject } from './../../helpers/helperFunctions';
 import { makeRandomString } from './../../helpers/random';
 import { CONFIG } from '../../config';
 
@@ -67,6 +67,47 @@ test("wrapInObjectIfNotObject test", () => {
   expect(test7).toEqual({a: 1, b: 2, c: 3});
 });
 
+test("jsonReplacerWithPath test", () => {
+  const a = { a1: 1, a2: 1 };
+  const b = { b1: 2, b2: [1, a] };
+  const c = { c1: 3, c2: b };
+
+  const test1: string[] = [];
+  const s = JSON.stringify(c, jsonReplacerWithPath(function(this: any, field: string, value: any, path: string) {
+    test1.push(path);
+    return value;
+  }));
+
+  expect(test1).toEqual(["", "c1", "c2", "c2.b1", "c2.b2", "c2.b2[0]", "c2.b2[1]", "c2.b2[1].a1", "c2.b2[1].a2"])
+  expect(s).toEqual(JSON.stringify(c));
+});
+
+test("jsonRefReplacer test", () => {
+  // Creating object with duplicate references
+  const a: any = { a1: 1, a2: 2 };
+  const b: any = { b1: 3, b2: "4" };
+  const obj: any = { o1: { o2:  a  }, b, a }; // duplicate reference
+  a.a3 = [1 ,2, b]; // circular reference
+  b.b3 = a; // circular reference
+
+  const test1 = JSON.stringify(obj, jsonRefReplacer());
+  expect(test1).toEqual(`{"o1":{"o2":{"a1":1,"a2":2,"a3":[1,2,{"b1":3,"b2":"4","b3":"#REF:$.o1.o2"}]}},"b":"#REF:$.o1.o2.a3[2]","a":"#REF:$.o1.o2"}`);
+});
+
+test("parseRefJSON test", () => {
+  // Creating object with duplicate references
+  const a: any = { a1: 1, a2: 2 };
+  const b: any = { b1: 3, b2: "4" };
+  const obj: any = { o1: { o2:  a  }, b, a }; // duplicate reference
+  a.a3 = [1, 2, b]; // circular reference
+  b.b3 = a; // circular reference
+
+  const s = JSON.stringify(obj, jsonRefReplacer());
+
+  const test1 = parseRefJSON(s);
+  expect(test1).toEqual(obj);
+});
+
 test("jsonStringifyPossiblyCircular test", () => {
   const test1 = jsonStringifyPossiblyCircular([]);
   const test2 = jsonStringifyPossiblyCircular({});
@@ -84,7 +125,7 @@ test("jsonStringifyPossiblyCircular test", () => {
   expect(test3).toEqual(`{"a":1,"b":2,"c":3}`);
   expect(test4).toEqual(`{"a":{"x":1,"y":2},"b":{"x":0,"y":-1}}`);
   expect(test4Reversed).toEqual(data4);
-  expect(test5).toEqual(`{"data":"123"}`);
+  expect(test5).toEqual(`{"data":"123","circ":"#REF:$"}`);
 });
 
 test("removeCircularReferencesFromObject test", () => {
@@ -110,12 +151,17 @@ test("removeCircularReferencesFromObject test", () => {
 
   const test6 = removeCircularReferencesFromObject(innerRecursiveLinksObject);
 
+  // console.log("test6", test6);
+
   expect(test1).toEqual(a);
   expect(test2).toEqual(b);
   expect(test3).toEqual(c);
   expect(test4).toEqual(d);
-  expect(test5).toEqual({data: "123"});
-  expect(test6).toEqual({aRefersToB: { x: 10, linkB: { y: 100 } }});
+  expect(test5).toEqual({data: "123", circ: "#REF:$"});
+  expect(test6).toEqual({
+    aRefersToB: { x: 10, linkB: { linkA: "#REF:$.aRefersToB", y: 100 } },
+    bRefersToA: "#REF:$.aRefersToB.linkB"
+  });
 });
 
 test("jsonStringifyKeepMeta test", () => {
@@ -153,5 +199,5 @@ test("jsonStringifyKeepMeta test", () => {
 
   const test4 = jsonStringifyKeepMeta(data3, true);
   expect(test4.ok).toBe(true);
-  expect(test4.result).toEqual(`{"a":101,"b":"abc","c":true,"d":null,"f":[1,2,3],"g":{"x":10,"y":12},"circularObject":{"data":"123"}}`);
+  expect(test4.result).toEqual(`{"a":101,"b":"abc","c":true,"d":null,"f":[1,2,3],"g":{"x":10,"y":12},"circularObject":{"data":"123","circ":"#REF:$.circularObject"}}`);
 });

helpers/helperFunctions.ts

@@ -51,19 +51,106 @@ export const emptyMobxStoreMonitor: MobxStoreMonitor = [
   () => {}
 ];
 
-export const jsonStringifyPossiblyCircular = (data: ObjectT<any>) => {
-  const seen = new WeakSet();
+// JSON.stringify replacer function constructor that adds full path to current position as last arg of replacer
+// Explanation fo replacerWithPath decorator:
+// > 'this' inside 'return function' point to field parent object
+//   (JSON.stringify execute replacer like that)
+// > 'path' contains path to current field based on parent ('this') path
+//   previously saved in Map
+// > during path generation we check is parent ('this') array or object
+//   and chose: "[field]" or ".field"
+// > in Map we store current 'path' for given 'field' only if it 
+//   is obj or arr in this way path to each parent is stored in Map. 
+//   We don't need to store path to simple types (number, bool, ...) because they never will have children
+// > value === Object(value) -> is true if value is object or array
+// > path for main object parent is set as 'undefined.' so we cut out that
+//   prefix at the end ad call replacer with that path
+// Test example:
+// let a = { a1: 1, a2: 1 };
+// let b = { b1: 2, b2: [1, a] };
+// let c = { c1: 3, c2: b };
+
+// let s = JSON.stringify(c, replacerWithPath(function(field, value, path) {
+//   // "this" has same value as in replacer without decoration
+//   console.log(path);
+//   return value;
+// })); 
+export const jsonReplacerWithPath = (replacer: ((this: any, key: string, value: any, path: string) => any)) => {
+  const m = new Map();
+
+  return function(this: any, field: string, value: any) {
+    const path = m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field); 
+
+    if (value === Object(value)) 
+      m.set(value, path);
+
+    // @ts-ignore (4th arg is additional one, thats a whole point)
+    return replacer.call(this, field, value, path.replace(/undefined\.\.?/,''));
+  }
+}
+
+// JSON.stringify replacer function constructor for ref replacing (uses same idea as replacerWithPathDecorator)
+export const jsonRefReplacer = () => {
+  const m = new Map();
+  const v = new Map();
+  let init: any = null;
+
+  return function(this: any, field: string, value: any) {
+    const p = m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field); 
+    const isComplex = value === Object(value);
+    
+    if (isComplex) 
+      m.set(value, p);  
+    
+    const pp = v.get(value) || '';
+    const path = p.replace(/undefined\.\.?/,'');
+    let val = pp ? `#REF:${pp[0] == '[' ? '$' : '$.'}${pp}` : value;
+    
+    !init ? (init = value) : (val === init ? val = "#REF:$" : 0);
+    if (!pp && isComplex)
+      v.set(value, path);
+   
+    return val;
+  }
+}
+
+// JSON.parse but for objects that were stringified with jsonRefReplacer
+export const parseRefJSON = (json: string) => {
+  const objToPath = new Map();
+  const pathToObj = new Map();
+  let o = JSON.parse(json);
+  
+  const traverse = (parent: any, field?: string) => {
+    let obj = parent;
+    let path = '#REF:$';
+
+    if (field !== undefined) {
+      obj = parent[field];
+      path = objToPath.get(parent) + (Array.isArray(parent) ? `[${field}]` : `${field ? '.' + field : ''}`);
+    }
+
+    objToPath.set(obj, path);
+    pathToObj.set(path, obj);
+    
+    let ref = pathToObj.get(obj);
+    // @ts-ignore
+    if (ref) parent[field] = ref;
+
+    for (let f in obj)
+      if (obj === Object(obj))
+        traverse(obj, f);
+  }
+  
+  traverse(o);
+
+  return o;
+}
 
+
+export const jsonStringifyPossiblyCircular = (data: ObjectT<any>) => {
   return JSON.stringify(
     data, 
-    (k, v) => {
-      if (typeof v === 'object' && v) {
-        if (seen.has(v)) 
-          return;
-        seen.add(v);
-      }
-      return v;
-    }
+    jsonRefReplacer()
   );
 }