feat: add stripNullValues utility function and integrate it into handlePushRequest for improved object comparison

Author: ImJustChew

src/planner-replication.ts

@@ -8,7 +8,7 @@ import {
     type RxReplicationWriteToMasterRow,
 } from "rxdb/plugins/core";
 import { PrismaClient, Prisma } from "./generated/client";
-import { deepCompare } from "./utils/deepCompare";
+import { deepCompare, stripNullValues } from "./utils/deepCompare";
 import { HTTPException } from "hono/http-exception";
 import type { Bindings } from "./index";
 import prismaClients from "./prisma/client";
@@ -191,8 +191,12 @@ async function handlePushRequest<M extends Model>(
         if (itemInDb && assumedMasterState) {
             const itemAsDocument = handlers.transformItemToDocument(itemInDb);
 
+            // Strip null values from both objects before comparison
+            const strippedItemAsDocument = stripNullValues(itemAsDocument);
+            const strippedAssumedState = stripNullValues(assumedMasterState);
+
             // If we have an assumed state but it doesn't match what's in the DB, it's a conflict
-            if (!deepCompare(itemAsDocument, assumedMasterState)) {
+            if (!deepCompare(strippedItemAsDocument, strippedAssumedState)) {
                 conflicts.push(itemAsDocument);
                 continue;
             }

src/utils/deepCompare.test.ts

@@ -1,4 +1,4 @@
-import { deepCompare } from "./deepCompare";
+import { deepCompare, stripNullValues } from "./deepCompare";
 import { describe, it, expect } from "bun:test";
 
 describe("deepCompare", () => {
@@ -130,3 +130,72 @@ describe("deepCompare", () => {
     expect(deepCompare(obj1, obj2)).toBe(true);
   });
 });
+
+describe("stripNullValues", () => {
+  it("should return the same object if no null values exist", () => {
+    const obj = { a: 1, b: 'test', c: true };
+    expect(stripNullValues(obj)).toEqual(obj);
+  });
+
+  it("should remove null values from an object", () => {
+    const obj = { a: 1, b: null, c: 'test' };
+    expect(stripNullValues(obj)).toEqual({ a: 1, c: 'test' });
+  });
+
+  it("should handle nested objects", () => {
+    const obj = {
+      a: 1,
+      b: {
+        c: null,
+        d: 'test',
+        e: {
+          f: null,
+          g: 42
+        }
+      }
+    };
+
+    // Type assertion is needed to avoid TypeScript errors about missing properties
+    const expected = {
+      a: 1,
+      b: {
+        d: 'test',
+        e: {
+          g: 42
+        }
+      }
+    };
+
+    expect(stripNullValues(obj)).toEqual(expected as any);
+  });
+
+  it("should handle arrays as values", () => {
+    const obj = { a: [1, 2, 3], b: null };
+    expect(stripNullValues(obj)).toEqual({ a: [1, 2, 3] });
+  });
+
+  it("should return empty object when all values are null", () => {
+    const obj = { a: null, b: null };
+    expect(stripNullValues(obj)).toEqual({});
+  });
+
+  it("should handle undefined values", () => {
+    const obj = { a: undefined, b: null };
+    expect(stripNullValues(obj)).toEqual({ a: undefined });
+  });
+
+  it("should not modify the original object", () => {
+    const obj = { a: 1, b: null };
+    const result = stripNullValues(obj);
+    expect(obj).toEqual({ a: 1, b: null });
+    expect(result).toEqual({ a: 1 });
+  });
+
+  it("should work with deepCompare to treat null properties as non-existent", () => {
+    const obj1 = { a: 1, b: null };
+    const obj2 = { a: 1 };
+
+    // Using stripNullValues should make these objects equal for comparison
+    expect(deepCompare(stripNullValues(obj1), stripNullValues(obj2))).toBe(true);
+  });
+});

src/utils/deepCompare.ts

@@ -48,3 +48,25 @@ export function deepCompare(
       deepCompare(a[key], b[key], maxDepth, currentDepth + 1),
   );
 }
+
+/**
+ * Recursively removes null values from an object
+ * Treats { prop: null } and {} as equivalent
+ */
+export function stripNullValues<T extends object>(obj: T): Partial<T> {
+  if (!obj) return obj;
+
+  const result: Partial<T> = {};
+
+  for (const key in obj) {
+    if (obj[key] !== null) {
+      if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+        result[key] = stripNullValues(obj[key] as any) as T[Extract<keyof T, string>];
+      } else {
+        result[key] = obj[key];
+      }
+    }
+  }
+
+  return result;
+}