@korajs/merge 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.d.ts

@@ -233,6 +233,42 @@ declare function lastWriteWins(localValue: unknown, remoteValue: unknown, localT
  */
 declare function addWinsSet(localArray: unknown[], remoteArray: unknown[], baseArray: unknown[]): unknown[];
 
+/**
+ * Convergent merge for `object` and `json` fields.
+ *
+ * Structured values are merged as a 3-way LWW map with add-wins key presence:
+ * two devices that edit different keys of the same object offline both keep
+ * their edits on reconnect, instead of one write clobbering the whole object.
+ *
+ * Per key, each side's action is classified against the base (the value before
+ * either operation):
+ * - wrote (added the key, or changed its value)
+ * - removed (present in base, absent now)
+ * - unchanged
+ *
+ * Resolution:
+ * - unchanged + unchanged      → base value
+ * - wrote + unchanged          → the written value
+ * - removed + unchanged        → absent
+ * - removed + removed          → absent
+ * - wrote + removed            → the write wins (add-wins: never silently drop an edit)
+ * - wrote + wrote              → recurse if both are plain objects; add-wins if both
+ *                                arrays; otherwise last-write-wins by the operations'
+ *                                HLC timestamps
+ *
+ * The result is commutative (swapping local/remote also swaps the HLCs, and HLC
+ * compare is a symmetric total order), idempotent (merging a value with itself
+ * returns it), and deterministic. Absent keys are omitted from the result.
+ *
+ * @param localValue - Local value after the local operation
+ * @param remoteValue - Remote value after the remote operation
+ * @param baseValue - Value before either operation (for 3-way diffing)
+ * @param localTs - HLC timestamp of the local operation
+ * @param remoteTs - HLC timestamp of the remote operation
+ * @returns The merged object
+ */
+declare function mergeObject(localValue: unknown, remoteValue: unknown, baseValue: unknown, localTs: HLCTimestamp, remoteTs: HLCTimestamp): Record<string, unknown>;
+
 /**
  * Result of merging two atomic operations on the same field.
  * If `merged` is false, the caller should fall back to LWW on the resolved values.
@@ -458,4 +494,4 @@ declare class MergeEngine {
     private mergeWithDelete;
 }
 
-export { type AtomicMergeFallback, type AtomicMergeResult, type ConstraintContext, type ConstraintResolution, type ConstraintViolation, type DeleteVsInsertResolution, type FieldMergeResult, type LWWResult, MergeEngine, type MergeIncomingRelation, type MergeInput, type MergeResult, type ReferentialCheckResult, type ReferentialMergeContext, type SideEffectOp, addWinsSet, appendOnlyMerge, applySchemaStrategy, buildMergeRelationLookup, checkConstraints, checkReferentialIntegrityOnDelete, counterMerge, lastWriteWins, maxMerge, mergeAtomicOps, mergeField, mergeRichtext, minMerge, resolveConstraintViolation, resolveDeleteVsInsertConflict, richtextToString, serverAuthoritativeMerge, stringToRichtextUpdate };
+export { type AtomicMergeFallback, type AtomicMergeResult, type ConstraintContext, type ConstraintResolution, type ConstraintViolation, type DeleteVsInsertResolution, type FieldMergeResult, type LWWResult, MergeEngine, type MergeIncomingRelation, type MergeInput, type MergeResult, type ReferentialCheckResult, type ReferentialMergeContext, type SideEffectOp, addWinsSet, appendOnlyMerge, applySchemaStrategy, buildMergeRelationLookup, checkConstraints, checkReferentialIntegrityOnDelete, counterMerge, lastWriteWins, maxMerge, mergeAtomicOps, mergeField, mergeObject, mergeRichtext, minMerge, resolveConstraintViolation, resolveDeleteVsInsertConflict, richtextToString, serverAuthoritativeMerge, stringToRichtextUpdate };

package/dist/index.js

@@ -74,6 +74,109 @@ function addWinsSet(localArray, remoteArray, baseArray) {
   return result;
 }
 
+// src/strategies/object-merge.ts
+function mergeObject(localValue, remoteValue, baseValue, localTs, remoteTs) {
+  const local = asPlainObject(localValue);
+  const remote = asPlainObject(remoteValue);
+  const base = asPlainObject(baseValue);
+  if (local === null || remote === null) {
+    const winner = lastWriteWins(localValue, remoteValue, localTs, remoteTs).value;
+    return asPlainObject(winner) ?? {};
+  }
+  const baseObj = base ?? {};
+  const result = {};
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(local),
+    ...Object.keys(remote),
+    ...Object.keys(baseObj)
+  ]);
+  for (const key of keys) {
+    const inLocal = key in local;
+    const inRemote = key in remote;
+    const inBase = key in baseObj;
+    const localVal = local[key];
+    const remoteVal = remote[key];
+    const baseVal = baseObj[key];
+    const localWrote = inLocal && (!inBase || !valuesEqual(localVal, baseVal));
+    const remoteWrote = inRemote && (!inBase || !valuesEqual(remoteVal, baseVal));
+    const localRemoved = !inLocal && inBase;
+    const remoteRemoved = !inRemote && inBase;
+    if (localWrote && remoteWrote) {
+      result[key] = mergeWrittenValues(localVal, remoteVal, baseVal, localTs, remoteTs);
+      continue;
+    }
+    if (localWrote && !remoteRemoved) {
+      result[key] = localVal;
+      continue;
+    }
+    if (remoteWrote && !localRemoved) {
+      result[key] = remoteVal;
+      continue;
+    }
+    if (localWrote && remoteRemoved) {
+      result[key] = localVal;
+      continue;
+    }
+    if (remoteWrote && localRemoved) {
+      result[key] = remoteVal;
+      continue;
+    }
+    if (localRemoved || remoteRemoved) {
+      continue;
+    }
+    if (inBase) {
+      result[key] = baseVal;
+    }
+  }
+  return result;
+}
+function mergeWrittenValues(localVal, remoteVal, baseVal, localTs, remoteTs) {
+  if (asPlainObject(localVal) !== null && asPlainObject(remoteVal) !== null) {
+    return mergeObject(localVal, remoteVal, baseVal, localTs, remoteTs);
+  }
+  if (Array.isArray(localVal) && Array.isArray(remoteVal)) {
+    const baseArr = Array.isArray(baseVal) ? baseVal : [];
+    return addWinsSet(localVal, remoteVal, baseArr);
+  }
+  return lastWriteWins(localVal, remoteVal, localTs, remoteTs).value;
+}
+function asPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== null && proto !== Object.prototype) {
+    return null;
+  }
+  return value;
+}
+function valuesEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  return stableStringify(a) === stableStringify(b);
+}
+function stableStringify(value) {
+  return JSON.stringify(sortKeysDeep(value));
+}
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeysDeep);
+  }
+  if (typeof value === "object" && value !== null) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype) {
+      const record = value;
+      const sorted = {};
+      for (const key of Object.keys(record).sort()) {
+        sorted[key] = sortKeysDeep(record[key]);
+      }
+      return sorted;
+    }
+  }
+  return value;
+}
+
 // src/strategies/atomic-merge.ts
 function mergeAtomicOps(localAtomicOp, remoteAtomicOp, baseValue) {
   if (localAtomicOp.type !== remoteAtomicOp.type) {
@@ -267,6 +370,38 @@ function applySchemaStrategy(strategy, localValue, remoteValue, baseValue, local
 
 // src/engine/field-merger.ts
 function mergeField(fieldName, localOp, remoteOp, baseState, fieldDescriptor, resolver) {
+  const result = mergeFieldInner(fieldName, localOp, remoteOp, baseState, fieldDescriptor, resolver);
+  if (fieldDescriptor.kind === "secret") {
+    return {
+      value: result.value,
+      trace: {
+        ...result.trace,
+        operationA: redactOperationField(result.trace.operationA, fieldName),
+        operationB: redactOperationField(result.trace.operationB, fieldName),
+        inputA: SECRET_REDACTED,
+        inputB: SECRET_REDACTED,
+        base: result.trace.base == null ? result.trace.base : SECRET_REDACTED,
+        output: SECRET_REDACTED
+      }
+    };
+  }
+  return result;
+}
+var SECRET_REDACTED = "[secret]";
+function redactOperationField(operation, field) {
+  const redactRecord = (record) => {
+    if (record === null || !(field in record)) {
+      return record;
+    }
+    return { ...record, [field]: SECRET_REDACTED };
+  };
+  return {
+    ...operation,
+    data: redactRecord(operation.data),
+    previousData: redactRecord(operation.previousData)
+  };
+}
+function mergeFieldInner(fieldName, localOp, remoteOp, baseState, fieldDescriptor, resolver) {
   const startTime = Date.now();
   const localData = localOp.data ?? {};
   const remoteData = remoteOp.data ?? {};
@@ -398,7 +533,14 @@ function autoMerge(fieldName, localOp, remoteOp, localValue, remoteValue, baseVa
     case "number":
     case "boolean":
     case "enum":
-    case "timestamp": {
+    case "timestamp":
+    // A blob field's value is a small content-addressed reference; concurrent
+    // replacements of the whole reference resolve by last-write-wins (the bytes
+    // themselves are immutable and deduplicated by hash in the blob store).
+    case "blob":
+    // A secret field's stored value (ciphertext or hash) resolves by
+    // last-write-wins; the merge never sees or emits plaintext (redacted below).
+    case "secret": {
       const lwwResult = lastWriteWins(
         localValue,
         remoteValue,
@@ -455,6 +597,28 @@ function autoMerge(fieldName, localOp, remoteOp, localValue, remoteValue, baseVa
         startTime
       );
     }
+    case "object":
+    case "json": {
+      const merged = mergeObject(
+        localValue,
+        remoteValue,
+        baseValue,
+        localOp.timestamp,
+        remoteOp.timestamp
+      );
+      return createResult(
+        merged,
+        fieldName,
+        localOp,
+        remoteOp,
+        localValue,
+        remoteValue,
+        baseValue,
+        "object-lww-map",
+        1,
+        startTime
+      );
+    }
   }
 }
 function createResult(value, field, operationA, operationB, inputA, inputB, base, strategy, tier, startTime) {
@@ -1358,6 +1522,7 @@ export {
   maxMerge,
   mergeAtomicOps,
   mergeField,
+  mergeObject,
   mergeRichtext,
   minMerge,
   resolveConstraintViolation,