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

package/dist/index.cjs

@@ -42,6 +42,7 @@ __export(index_exports, {
   maxMerge: () => maxMerge,
   mergeAtomicOps: () => mergeAtomicOps,
   mergeField: () => mergeField,
+  mergeObject: () => mergeObject,
   mergeRichtext: () => mergeRichtext,
   minMerge: () => minMerge,
   resolveConstraintViolation: () => resolveConstraintViolation,
@@ -128,6 +129,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) {
@@ -317,6 +421,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 ?? {};
@@ -448,7 +584,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,
@@ -505,6 +648,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) {
@@ -1409,6 +1574,7 @@ function determineAppliedOperation(traces) {
   maxMerge,
   mergeAtomicOps,
   mergeField,
+  mergeObject,
   mergeRichtext,
   minMerge,
   resolveConstraintViolation,