korajs 0.6.0 → 1.0.0-beta.0

package/dist/index.cjs

@@ -251,6 +251,7 @@ async function buildSideEffectEntry(ctx, effect, parentOpId, transactionId, muta
 }
 
 // src/apply-pipeline.ts
+var MERGE_APPLY_RETRY_LIMIT = 8;
 var ApplyPipeline = class {
   constructor(deps) {
     this.deps = deps;
@@ -452,15 +453,37 @@ var ApplyPipeline = class {
     if (!collectionDef) {
       return this.deps.store.applyRemoteOperation(op2);
     }
+    let lockError = null;
+    for (let attempt = 0; attempt < MERGE_APPLY_RETRY_LIMIT; attempt++) {
+      try {
+        return await this.applyRemoteUpdateAttempt(op2, collectionDef);
+      } catch (error) {
+        if (!(error instanceof import_store.OptimisticLockError)) {
+          throw error;
+        }
+        lockError = error;
+      }
+    }
+    throw lockError ?? new import_store.OptimisticLockError(op2.collection, op2.recordId);
+  }
+  async applyRemoteUpdateAttempt(op2, collectionDef) {
+    const guard = await this.deps.store.getRowVersionState(
+      op2.collection,
+      op2.recordId
+    ) ?? { version: null, fieldVersions: null };
     const accessor = this.deps.store.collection(op2.collection);
     const currentRecord = await accessor.findById(op2.recordId);
     if (!currentRecord) {
-      const tombstoneResult = await this.applyRemoteUpdateOnDeletedRow(op2, collectionDef);
+      const tombstoneResult = await this.applyRemoteUpdateOnDeletedRow(op2, collectionDef, guard);
       if (tombstoneResult !== null) {
         return tombstoneResult;
       }
       return this.deps.store.applyRemoteOperation(op2);
     }
+    if (!updateNeedsMergeEngine(op2, collectionDef)) {
+      await this.observeScalarMerge(op2, collectionDef);
+      return this.deps.store.applyRemoteOperation(op2);
+    }
     let hasConflict = false;
     for (const field of Object.keys(op2.data ?? {})) {
       const fieldDef = collectionDef.fields[field];
@@ -478,14 +501,50 @@ var ApplyPipeline = class {
       }
     }
     if (!hasConflict) {
-      return this.deps.store.applyRemoteOperation(op2);
+      return this.deps.store.applyRemoteOperation(op2, {
+        forceMaterialize: true,
+        guardRowState: guard
+      });
     }
-    return this.applyMergedUpdate(op2, collectionDef, currentRecord, op2.previousData ?? {});
+    return this.applyMergedUpdate(op2, collectionDef, currentRecord, op2.previousData ?? {}, guard);
   }
   /**
    * Remote update vs local soft-delete: merge before materializing to avoid zombie rows.
    */
-  async applyRemoteUpdateOnDeletedRow(op2, collectionDef) {
+  /**
+   * Emit merge observability (trace + conflict counter) for a scalar update that
+   * concurrently touches a field a local operation also changed.
+   *
+   * The store resolves the actual value by deterministic per-field LWW; this
+   * method exists only so the decision is loggable (CLAUDE.md: every merge
+   * decision must be traceable). It reads the local operation from the append-
+   * only log — which is immutable — rather than the materialized row, so it is
+   * not subject to the read-then-write race the store write path was hardened
+   * against. The merge engine is invoked purely to build an accurate trace; its
+   * timestamps match the store's LWW comparison, so the trace never lies.
+   */
+  async observeScalarMerge(op2, collectionDef) {
+    const localOp = await this.deps.store.getLatestLocalOperationForRecord(
+      op2.collection,
+      op2.recordId
+    );
+    if (!localOp || !localOp.data) {
+      return;
+    }
+    const remoteFields = Object.keys(op2.data ?? {});
+    const sharesField = remoteFields.some((field) => localOp.data?.[field] !== void 0);
+    if (!sharesField) {
+      return;
+    }
+    const mergeResult = await this.deps.mergeEngine.merge({
+      local: localOp,
+      remote: op2,
+      baseState: op2.previousData ?? {},
+      collectionDef
+    });
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
+  }
+  async applyRemoteUpdateOnDeletedRow(op2, collectionDef, guard) {
     const snapshot = await this.deps.store.findMaterializedRow(op2.collection, op2.recordId);
     if (!snapshot?.deleted) {
       return null;
@@ -503,37 +562,41 @@ var ApplyPipeline = class {
       baseState: op2.previousData ?? {},
       collectionDef
     });
-    this.emitMergeLifecycle(op2, localOp, mergeResult);
     if (mergeResult.appliedOperation === "local") {
+      this.emitMergeLifecycle(op2, localOp, mergeResult);
       return "skipped";
     }
-    const mergedOp = {
-      ...op2,
-      data: { ...mergeResult.mergedData },
-      timestamp: maxTimestamp(op2.timestamp, localOp.timestamp)
-    };
-    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, {
-      reactivateIfDeleted: true
+    const applyResult = await this.deps.store.applyRemoteOperation(op2, {
+      reactivateIfDeleted: true,
+      forceMaterialize: true,
+      materializeData: { ...mergeResult.mergedData },
+      materializeTimestamp: maxTimestamp(op2.timestamp, localOp.timestamp),
+      guardRowState: guard
     });
+    this.emitMergeLifecycle(op2, localOp, mergeResult);
     if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
       await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op2.id);
     }
     return applyResult;
   }
-  async applyMergedUpdate(op2, collectionDef, currentRecord, baseState, applyOptions) {
-    const localTimestamp = await resolveLocalTimestamp(
-      this.deps.store,
+  async applyMergedUpdate(op2, collectionDef, currentRecord, baseState, guard, applyOptions) {
+    const latestLocal = await this.deps.store.getLatestLocalOperationForRecord(
       op2.collection,
-      op2.recordId,
+      op2.recordId
+    );
+    const localTimestamp = resolveLocalTimestamp(
+      latestLocal,
       currentRecord,
       this.deps.store.getNodeId()
     );
+    const { atomicOps: _remoteAtomicOps, ...opWithoutAtomic } = op2;
     const localOp = {
-      ...op2,
+      ...opWithoutAtomic,
       data: buildLocalDiff(baseState, currentRecord, Object.keys(op2.data ?? {})),
       previousData: op2.previousData,
       nodeId: this.deps.store.getNodeId(),
-      timestamp: localTimestamp
+      timestamp: localTimestamp,
+      ...latestLocal?.atomicOps !== void 0 ? { atomicOps: latestLocal.atomicOps } : {}
     };
     const constraintContext = createConstraintContext(this.deps.store);
     const mergeResult = await this.deps.mergeEngine.merge(
@@ -545,13 +608,14 @@ var ApplyPipeline = class {
       },
       constraintContext
     );
+    const applyResult = await this.deps.store.applyRemoteOperation(op2, {
+      ...applyOptions,
+      forceMaterialize: true,
+      materializeData: mergeResult.mergedData,
+      materializeTimestamp: maxTimestamp(op2.timestamp, localTimestamp),
+      guardRowState: guard
+    });
     this.emitMergeLifecycle(op2, localOp, mergeResult);
-    const mergedOp = {
-      ...op2,
-      data: mergeResult.mergedData,
-      timestamp: maxTimestamp(op2.timestamp, localTimestamp)
-    };
-    const applyResult = await this.deps.store.applyRemoteOperation(mergedOp, applyOptions);
     if (applyResult === "applied" && mergeResult.sideEffects.length > 0) {
       await applySideEffectOps(this.deps.store, mergeResult.sideEffects, op2.id);
     }
@@ -562,9 +626,27 @@ var ApplyPipeline = class {
     if (!collectionDef || !op2.data) {
       return this.deps.store.applyRemoteOperation(op2);
     }
+    let lockError = null;
+    for (let attempt = 0; attempt < MERGE_APPLY_RETRY_LIMIT; attempt++) {
+      try {
+        return await this.applyRemoteInsertAttempt(op2, collectionDef);
+      } catch (error) {
+        if (!(error instanceof import_store.OptimisticLockError)) {
+          throw error;
+        }
+        lockError = error;
+      }
+    }
+    throw lockError ?? new import_store.OptimisticLockError(op2.collection, op2.recordId);
+  }
+  async applyRemoteInsertAttempt(op2, collectionDef) {
+    const guard = await this.deps.store.getRowVersionState(
+      op2.collection,
+      op2.recordId
+    ) ?? { version: null, fieldVersions: null };
     const snapshot = await this.deps.store.findMaterializedRow(op2.collection, op2.recordId);
     if (!snapshot || snapshot.deleted) {
-      return this.deps.store.applyRemoteOperation(op2);
+      return this.deps.store.applyRemoteOperation(op2, { guardRowState: guard });
     }
     const localOp = await resolveLocalOpForRecord(
       this.deps.store,
@@ -578,13 +660,14 @@ var ApplyPipeline = class {
       baseState: {},
       collectionDef
     });
+    const applyResult = await this.deps.store.applyRemoteOperation(op2, {
+      forceMaterialize: true,
+      materializeData: mergeResult.mergedData,
+      materializeTimestamp: maxTimestamp(op2.timestamp, localOp.timestamp),
+      guardRowState: guard
+    });
     this.emitMergeLifecycle(op2, localOp, mergeResult);
-    const mergedOp = {
-      ...op2,
-      data: mergeResult.mergedData,
-      timestamp: maxTimestamp(op2.timestamp, localOp.timestamp)
-    };
-    return this.deps.store.applyRemoteOperation(mergedOp);
+    return applyResult;
   }
   emitMergeLifecycle(remote, local, mergeResult) {
     this.deps.emitter?.emit({
@@ -676,6 +759,24 @@ async function applySideEffectOps(store, sideEffects, parentOpId) {
     }
   }
 }
+function updateNeedsMergeEngine(op2, collectionDef) {
+  if (collectionDef.constraints.length > 0) {
+    return true;
+  }
+  if (op2.atomicOps && Object.keys(op2.atomicOps).length > 0) {
+    return true;
+  }
+  for (const field of Object.keys(op2.data ?? {})) {
+    const kind = collectionDef.fields[field]?.kind;
+    if (kind === "richtext" || kind === "array") {
+      return true;
+    }
+    if (collectionDef.resolvers[field]) {
+      return true;
+    }
+  }
+  return false;
+}
 function buildLocalDiff(baseState, currentRecord, fields) {
   const diff = {};
   for (const field of fields) {
@@ -683,8 +784,7 @@ function buildLocalDiff(baseState, currentRecord, fields) {
   }
   return diff;
 }
-async function resolveLocalTimestamp(store, collection, recordId, currentRecord, nodeId) {
-  const latestLocal = await store.getLatestLocalOperationForRecord(collection, recordId);
+function resolveLocalTimestamp(latestLocal, currentRecord, nodeId) {
   if (latestLocal) {
     return latestLocal.timestamp;
   }
@@ -775,6 +875,13 @@ var MergeAwareSyncStore = class {
   async applyRemoteOperation(op2) {
     return this.pipeline.applyRemote(op2);
   }
+  /**
+   * Delegates timestamp rebase to the store so the sync engine can re-stamp
+   * never-acknowledged operations after a fast device clock is corrected.
+   */
+  async rebaseUnsyncedOperations(ids, correctedNowMs) {
+    return this.store.rebaseUnsyncedOperations(ids, correctedNowMs);
+  }
 };
 
 // src/store-queue-storage.ts
@@ -1091,7 +1198,8 @@ function createSyncControl(options) {
           lastSyncedAt: null,
           lastSuccessfulPush: null,
           lastSuccessfulPull: null,
-          conflicts: 0
+          conflicts: 0,
+          clockSkewMs: null
         },
         nodeId: "",
         url: config.sync?.url ?? "",
@@ -1100,6 +1208,7 @@ function createSyncControl(options) {
         lastSuccessfulPush: null,
         lastSuccessfulPull: null,
         conflicts: 0,
+        clockSkewMs: null,
         pendingOperations: 0,
         hasInFlightBatch: false,
         reconnecting: false,
@@ -1109,6 +1218,9 @@ function createSyncControl(options) {
   };
 }
 
+// src/sync-lifecycle.ts
+var import_sync6 = require("@korajs/sync");
+
 // src/auth-sync-coordinator.ts
 var AuthSyncCoordinator = class {
   constructor(getEngine, authBinding) {
@@ -1185,7 +1297,6 @@ function createSyncStatusBridge(emitter, getSyncEngine) {
 }
 
 // src/sync-lifecycle.ts
-var import_sync6 = require("@korajs/sync");
 function wireSyncLifecycleAfterReady(config, emitter, state, init) {
   state.syncEngine = init.syncEngine;
   if (!config.sync) {
@@ -1208,6 +1319,9 @@ function wireSyncLifecycleAfterReady(config, emitter, state, init) {
     initialDelay: config.sync.reconnectInterval,
     maxDelay: config.sync.maxReconnectInterval
   });
+  emitter.on("sync:clock-skew", (event) => {
+    init.store.setClockReferenceOffset(event.skewMs);
+  });
   emitter.on("sync:sent", () => state.connectionMonitor?.recordActivity());
   emitter.on("sync:received", () => state.connectionMonitor?.recordActivity());
   emitter.on("sync:acknowledged", () => state.connectionMonitor?.recordActivity());