fix: referential equalities should ignore child nodes

src/index.test.ts

@@ -1126,3 +1126,34 @@ test('superjson instances are independent of one another', () => {
   const res2 = s2.serialize(value);
   expect(res2.json).toEqual(value);
 });
+
+test('regression #245: superjson referential equalities only use the top-most parent node', () => {
+  type Node = {
+    children: Node[];
+  };
+  const root: Node = {
+    children: [],
+  };
+  const input = {
+    a: root,
+    b: root,
+  };
+  const res = SuperJSON.serialize(input);
+
+  expect(res.meta?.referentialEqualities).toHaveProperty(['a']);
+
+  // saying that a.children is equal to b.children is redundant since its already know that a === b
+  expect(res.meta?.referentialEqualities).not.toHaveProperty(['a.children']);
+  expect(res.meta).toMatchInlineSnapshot(`
+    Object {
+      "referentialEqualities": Object {
+        "a": Array [
+          "b",
+        ],
+      },
+    }
+  `);
+
+  const parsed = SuperJSON.deserialize(res);
+  expect(parsed).toEqual(input);
+});

src/plainer.ts

@@ -1,3 +1,5 @@
+import SuperJSON from '.';
+import { getDeep, setDeep } from './accessDeep';
 import {
   isArray,
   isEmptyObject,
@@ -6,17 +8,14 @@ import {
   isPrimitive,
   isSet,
 } from './is';
-import { escapeKey, stringifyPath } from './pathstringifier';
+import { escapeKey, parsePath, stringifyPath } from './pathstringifier';
 import {
+  TypeAnnotation,
   isInstanceOfRegisteredClass,
   transformValue,
-  TypeAnnotation,
   untransformValue,
 } from './transformer';
-import { includes, forEach } from './util';
-import { parsePath } from './pathstringifier';
-import { getDeep, setDeep } from './accessDeep';
-import SuperJSON from '.';
+import { forEach, includes } from './util';
 
 type Tree<T> = InnerNode<T> | Leaf<T>;
 type Leaf<T> = [T];
@@ -135,7 +134,7 @@ export function generateReferentialEqualityAnnotations(
     if (shortestPath.length === 0) {
       rootEqualityPaths = identicalPaths.map(stringifyPath);
     } else {
-      result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
+result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
     }
   });
 
@@ -155,27 +154,40 @@ export const walker = (
   identities: Map<any, any[][]>,
   superJson: SuperJSON,
   path: any[] = [],
-  objectsInThisPath: any[] = []
+  objectsInThisPath: any[] = [],
+  seenObjects = new Map<unknown, Result>()
 ): Result => {
-  if (!isPrimitive(object)) {
+  const primitive = isPrimitive(object);
+
+  if (!primitive) {
     addIdentity(object, path, identities);
+
+    const seen = seenObjects.get(object);
+    if (seen) {
+      // short-circuit result if we've seen this object before
+      return seen;
+    }
   }
 
   if (!isDeep(object, superJson)) {
     const transformed = transformValue(object, superJson);
-    if (transformed) {
-      return {
-        transformedValue: transformed.value,
-        annotations: [transformed.type],
-      };
-    } else {
-      return {
-        transformedValue: object,
-      };
+
+    const result: Result = transformed
+      ? {
+          transformedValue: transformed.value,
+          annotations: [transformed.type],
+        }
+      : {
+          transformedValue: object,
+        };
+    if (!primitive) {
+      seenObjects.set(object, result);
     }
+    return result;
   }
 
   if (includes(objectsInThisPath, object)) {
+    // prevent circular references
     return {
       transformedValue: null,
     };
@@ -184,10 +196,6 @@ export const walker = (
   const transformationResult = transformValue(object, superJson);
   const transformed = transformationResult?.value ?? object;
 
-  if (!isPrimitive(object)) {
-    objectsInThisPath = [...objectsInThisPath, object];
-  }
-
   const transformedValue: any = isArray(transformed) ? [] : {};
   const innerAnnotations: Record<string, Tree<TypeAnnotation>> = {};
 
@@ -197,7 +205,8 @@ export const walker = (
       identities,
       superJson,
       [...path, index],
-      objectsInThisPath
+      [...objectsInThisPath, object],
+      seenObjects
     );
 
     transformedValue[index] = recursiveResult.transformedValue;
@@ -211,19 +220,22 @@ export const walker = (
     }
   });
 
-  if (isEmptyObject(innerAnnotations)) {
-    return {
-      transformedValue,
-      annotations: !!transformationResult
-        ? [transformationResult.type]
-        : undefined,
-    };
-  } else {
-    return {
-      transformedValue,
-      annotations: !!transformationResult
-        ? [transformationResult.type, innerAnnotations]
-        : innerAnnotations,
-    };
+  const result: Result = isEmptyObject(innerAnnotations)
+    ? {
+        transformedValue,
+        annotations: !!transformationResult
+          ? [transformationResult.type]
+          : undefined,
+      }
+    : {
+        transformedValue,
+        annotations: !!transformationResult
+          ? [transformationResult.type, innerAnnotations]
+          : innerAnnotations,
+      };
+  if (!primitive) {
+    seenObjects.set(object, result);
   }
+
+  return result;
 };