microdiff object diff: working versions (tested 2026-10-16)

{
  "name": "microdiff-object-diff",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "microdiff": "1.6.0"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import diff from "microdiff";

export type DiffEntry = ReturnType<typeof diff>[number];
export type DiffType = DiffEntry["type"];
export type DiffPath = DiffEntry["path"];

export function diffObjects(before: unknown, after: unknown): DiffEntry[] {
  return diff(before, after);
}

export function entriesOfType(entries: DiffEntry[], type: DiffType): DiffEntry[] {
  return entries.filter((entry) => entry.type === type);
}

export function pathsOfType(entries: DiffEntry[], type: DiffType): DiffPath[] {
  return entriesOfType(entries, type).map((entry) => entry.path);
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { diffObjects, entriesOfType, pathsOfType } from "../src/diff.ts";

test("identical nested objects produce an empty diff", () => {
  const before = { user: { id: "1", tags: ["a", "b"] }, active: true };
  const after = { user: { id: "1", tags: ["a", "b"] }, active: true };
  assert.deepEqual(diffObjects(before, after), []);
});

test("emits CREATE entries with paths for added keys", () => {
  const before = { user: { id: "1" } };
  const after = { user: { id: "1", email: "[email protected]" } };
  const result = diffObjects(before, after);
  assert.deepEqual(pathsOfType(result, "CREATE"), [["user", "email"]]);
  assert.equal(entriesOfType(result, "CREATE")[0].value, "[email protected]");
});

test("emits REMOVE entries with paths for deleted keys", () => {
  const before = { user: { id: "1", email: "[email protected]" } };
  const after = { user: { id: "1" } };
  const result = diffObjects(before, after);
  assert.deepEqual(pathsOfType(result, "REMOVE"), [["user", "email"]]);
});

test("emits CHANGE entries with paths for changed values", () => {
  const before = { total: 10, nested: { count: 1 } };
  const after = { total: 20, nested: { count: 2 } };
  const result = diffObjects(before, after);
  assert.deepEqual(pathsOfType(result, "CHANGE"), [["total"], ["nested", "count"]]);
  assert.deepEqual(entriesOfType(result, "CHANGE")[0], {
    type: "CHANGE",
    path: ["total"],
    value: 20,
    oldValue: 10,
  });
});

test("diffs arrays by index and reports the offending element", () => {
  const result = diffObjects({ list: [1, 2, 3] }, { list: [1, 9, 3] });
  assert.deepEqual(result, [
    { type: "CHANGE", path: ["list", 1], value: 9, oldValue: 2 },
  ]);
});

test("reports array growth as a CREATE at the appended index", () => {
  const result = diffObjects({ list: [1, 2] }, { list: [1, 2, 3] });
  assert.deepEqual(pathsOfType(result, "CREATE"), [["list", 2]]);
});

test("reports array shrink as a REMOVE at the dropped index", () => {
  const result = diffObjects({ list: [1, 2, 3] }, { list: [1, 2] });
  assert.deepEqual(pathsOfType(result, "REMOVE"), [["list", 2]]);
});