@anfenn/zync 0.3.4 → 0.4.1

package/dist/index.js

@@ -23,9 +23,40 @@ function newLogger(base, min) {
 
 // src/helpers.ts
 var SYNC_FIELDS = ["_localId", "updated_at", "deleted"];
-function nextLocalId() {
+function createLocalId() {
   return crypto.randomUUID();
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function changeKeysTo(input, toIdKey, toUpdatedAtKey, toDeletedKey) {
+  if (!input) return input;
+  const isArray = Array.isArray(input);
+  const result = (isArray ? input : [input]).map((item) => {
+    const { id, updated_at, deleted, ...rest } = item;
+    return {
+      [toIdKey]: id,
+      [toUpdatedAtKey]: updated_at,
+      [toDeletedKey]: deleted,
+      ...rest
+    };
+  });
+  return isArray ? result : result[0];
+}
+function changeKeysFrom(input, fromIdKey, fromUpdatedAtKey, fromDeletedKey) {
+  if (!input) return input;
+  const isArray = Array.isArray(input);
+  const result = (isArray ? input : [input]).map((item) => {
+    const { [fromIdKey]: id, [fromUpdatedAtKey]: updated_at, [fromDeletedKey]: deleted, ...rest } = item;
+    return {
+      id,
+      updated_at,
+      deleted,
+      ...rest
+    };
+  });
+  return isArray ? result : result[0];
+}
 function orderFor(a) {
   switch (a) {
     case "create" /* Create */:
@@ -42,8 +73,8 @@ function omitSyncFields(item) {
   return result;
 }
 function samePendingVersion(get, stateKey, localId, version) {
-  const q = get().syncState.pendingChanges || [];
-  const curChange = q.find((p) => p.localId === localId && p.stateKey === stateKey);
+  const pending = get().syncState.pendingChanges || [];
+  const curChange = pending.find((p) => p.localId === localId && p.stateKey === stateKey);
   return curChange?.version === version;
 }
 function removeFromPendingChanges(set, localId, stateKey) {
@@ -77,7 +108,7 @@ function tryAddToPendingChanges(pendingChanges, stateKey, changes) {
         queueItem.changes = { ...queueItem.changes, ...omittedItem };
       }
     } else if (action === "remove" /* Remove */ || hasChanges) {
-      pendingChanges.push({ action, stateKey, localId, id: change.id, version: 1, changes: omittedItem });
+      pendingChanges.push({ action, stateKey, localId, id: change.id, version: 1, changes: omittedItem, before: omitSyncFields(change.currentItem) });
     }
   }
 }
@@ -89,6 +120,30 @@ function setPendingChangeToUpdate(get, stateKey, localId, id) {
     if (id) change.id = id;
   }
 }
+function setPendingChangeBefore(get, stateKey, localId, before) {
+  const pendingChanges = get().syncState.pendingChanges || [];
+  const change = pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+  if (change) {
+    change.before = { ...change.before, ...before };
+  }
+}
+function tryUpdateConflicts(pendingChanges, conflicts) {
+  if (!conflicts) return conflicts;
+  const newConflicts = { ...conflicts };
+  for (const change of pendingChanges) {
+    const conflict = newConflicts[change.localId];
+    if (conflict && change.changes) {
+      const newFields = conflict.fields.map((f) => {
+        if (f.key in change.changes) {
+          return { ...f, localValue: change.changes[f.key] };
+        }
+        return f;
+      });
+      newConflicts[change.localId] = { stateKey: conflict.stateKey, fields: newFields };
+    }
+  }
+  return newConflicts;
+}
 function findApi(stateKey, syncApi) {
   const api = syncApi[stateKey];
   if (!api || !api.add || !api.update || !api.remove || !api.list || !api.firstLoad) {
@@ -130,6 +185,50 @@ function findChanges(current, updated) {
   }
   return changesMap;
 }
+function hasKeysOrUndefined(obj) {
+  return Object.keys(obj).length === 0 ? void 0 : obj;
+}
+function hasConflicts(get, localId) {
+  const state = get();
+  if (state.syncState.conflicts) {
+    return !!state.syncState.conflicts[localId];
+  }
+  return false;
+}
+function resolveConflict(set, localId, keepLocalFields) {
+  set((state) => {
+    const syncState = state.syncState || {};
+    const conflicts = syncState.conflicts || {};
+    const conflict = conflicts[localId];
+    if (conflict) {
+      const items = state[conflict.stateKey];
+      const item = items.find((i) => i._localId === localId);
+      if (!item) {
+        return state;
+      }
+      const resolved = { ...item };
+      let pendingChanges = [...syncState.pendingChanges];
+      if (!keepLocalFields) {
+        for (const field of conflict.fields) {
+          resolved[field.key] = field.remoteValue;
+        }
+        pendingChanges = pendingChanges.filter((p) => !(p.stateKey === conflict.stateKey && p.localId === localId));
+      }
+      const nextItems = items.map((i) => i._localId === localId ? resolved : i);
+      const nextConflicts = { ...conflicts };
+      delete nextConflicts[localId];
+      return {
+        [conflict.stateKey]: nextItems,
+        syncState: {
+          ...syncState,
+          pendingChanges,
+          conflicts: hasKeysOrUndefined(nextConflicts)
+        }
+      };
+    }
+    return state;
+  });
+}
 
 // src/pull.ts
 async function pull(set, get, stateKey, api, logger, conflictResolutionStrategy) {
@@ -140,7 +239,8 @@ async function pull(set, get, stateKey, api, logger, conflictResolutionStrategy)
   if (!serverData?.length) return;
   let newest = lastPulledAt;
   set((state) => {
-    const pendingChanges = state.syncState.pendingChanges || [];
+    let pendingChanges = [...state.syncState.pendingChanges];
+    const conflicts = { ...state.syncState.conflicts };
     const localItems = state[stateKey] || [];
     let nextItems = [...localItems];
     const localById = new Map(localItems.filter((l) => l.id).map((l) => [l.id, l]));
@@ -164,43 +264,43 @@ async function pull(set, get, stateKey, api, logger, conflictResolutionStrategy)
       if (localItem) {
         const pendingChange = pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localItem._localId);
         if (pendingChange) {
+          logger.debug(`[zync] pull:conflict-strategy:${conflictResolutionStrategy} stateKey=${stateKey} id=${remote.id}`);
           switch (conflictResolutionStrategy) {
-            case "local-wins":
-              logger.debug(`[zync] pull:conflict-strategy:${conflictResolutionStrategy} stateKey=${stateKey} id=${remote.id}`);
+            case "client-wins":
               break;
-            case "remote-wins": {
-              const merged = {
-                ...remote,
-                _localId: localItem._localId
-              };
+            case "server-wins": {
+              const merged = { ...remote, _localId: localItem._localId };
               nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
-              logger.debug(`[zync] pull:conflict-strategy:${conflictResolutionStrategy} stateKey=${stateKey} id=${remote.id}`);
+              pendingChanges = pendingChanges.filter((p) => !(p.stateKey === stateKey && p.localId === localItem._localId));
               break;
             }
-            // case 'try-shallow-merge':
-            //     // Try and merge all fields, fail if not possible due to conflicts
-            //     // throw new ConflictError('Details...');
-            //     break;
-            // case 'custom':
-            //     // Hook to allow custom userland logic
-            //     // const error = onConflict(localItem, remote, stateKey, pending);
-            //     // logger.debug(`[zync] pull:conflict-strategy:${conflictResolutionStrategy} stateKey=${stateKey} id=${remote.id} error=${error}`);
-            //     // if (error) throw new ConflictError(error);
-            //     break;
-            default:
-              logger.error(`[zync] pull:conflict-strategy:unknown stateKey=${stateKey} id=${remote.id} strategy=${conflictResolutionStrategy}`);
+            case "try-shallow-merge": {
+              const changes = pendingChange.changes || {};
+              const before = pendingChange.before || {};
+              const fields = Object.entries(changes).filter(([k, localValue]) => k in before && k in remote && before[k] !== remote[k] && localValue !== remote[k]).map(([key, localValue]) => ({ key, localValue, remoteValue: remote[key] }));
+              if (fields.length > 0) {
+                logger.warn(`[zync] pull:${conflictResolutionStrategy}:conflicts-found`, JSON.stringify(fields, null, 4));
+                conflicts[localItem._localId] = { stateKey, fields };
+              } else {
+                const localChangedKeys = Object.keys(changes);
+                const preservedLocal = { _localId: localItem._localId };
+                for (const k of localChangedKeys) {
+                  if (k in localItem) preservedLocal[k] = localItem[k];
+                }
+                const merged = { ...remote, ...preservedLocal };
+                nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
+                delete conflicts[localItem._localId];
+              }
               break;
+            }
           }
         } else {
-          const merged = {
-            ...localItem,
-            ...remote
-          };
+          const merged = { ...localItem, ...remote };
           nextItems = nextItems.map((i) => i._localId === localItem._localId ? merged : i);
           logger.debug(`[zync] pull:merge-remote stateKey=${stateKey} id=${remote.id}`);
         }
       } else {
-        nextItems = [...nextItems, { ...remote, _localId: nextLocalId() }];
+        nextItems = [...nextItems, { ...remote, _localId: createLocalId() }];
         logger.debug(`[zync] pull:add stateKey=${stateKey} id=${remote.id}`);
       }
     }
@@ -208,6 +308,8 @@ async function pull(set, get, stateKey, api, logger, conflictResolutionStrategy)
       [stateKey]: nextItems,
       syncState: {
         ...state.syncState || {},
+        pendingChanges,
+        conflicts: hasKeysOrUndefined(conflicts),
         lastPulled: {
           ...state.syncState.lastPulled || {},
           [stateKey]: newest.toISOString()
@@ -221,7 +323,6 @@ async function pull(set, get, stateKey, api, logger, conflictResolutionStrategy)
 async function pushOne(set, get, change, api, logger, setAndQueueToSync, missingStrategy, onMissingRemoteRecordDuringUpdate, onAfterRemoteAdd) {
   logger.debug(`[zync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
   const { action, stateKey, localId, id, version, changes } = change;
-  const changesClone = { ...changes };
   switch (action) {
     case "remove" /* Remove */:
       if (!id) {
@@ -234,11 +335,17 @@ async function pushOne(set, get, change, api, logger, setAndQueueToSync, missing
       removeFromPendingChanges(set, localId, stateKey);
       break;
     case "update" /* Update */: {
-      const exists = await api.update(id, changesClone);
+      if (hasConflicts(get, change.localId)) {
+        logger.warn(`[zync] push:update:skipping-with-conflicts stateKey=${stateKey} localId=${localId} id=${id}`);
+        return;
+      }
+      const exists = await api.update(id, changes);
       if (exists) {
         logger.debug(`[zync] push:update:success stateKey=${stateKey} localId=${localId} id=${id}`);
         if (samePendingVersion(get, stateKey, localId, version)) {
           removeFromPendingChanges(set, localId, stateKey);
+        } else {
+          setPendingChangeBefore(get, stateKey, localId, changes);
         }
         return;
       } else {
@@ -260,7 +367,7 @@ async function pushOne(set, get, change, api, logger, setAndQueueToSync, missing
           case "insert-remote-record": {
             const newItem = {
               ...item,
-              _localId: nextLocalId(),
+              _localId: createLocalId(),
               updated_at: (/* @__PURE__ */ new Date()).toISOString()
             };
             setAndQueueToSync((s) => ({
@@ -282,7 +389,7 @@ async function pushOne(set, get, change, api, logger, setAndQueueToSync, missing
       break;
     }
     case "create" /* Create */: {
-      const result = await api.add(changesClone);
+      const result = await api.add(changes);
       if (result) {
         logger.debug(`[zync] push:create:success stateKey=${stateKey} localId=${localId} id=${id}`);
         set((s) => ({
@@ -339,7 +446,7 @@ async function startFirstLoad(set, syncApi, logger) {
             } else {
               next.push({
                 ...remote,
-                _localId: nextLocalId()
+                _localId: createLocalId()
               });
             }
           }
@@ -453,17 +560,17 @@ function createIndexedDBStorage(options) {
 }
 
 // src/index.ts
-var SyncAction = /* @__PURE__ */ ((SyncAction2) => {
-  SyncAction2["Create"] = "create";
-  SyncAction2["Update"] = "update";
-  SyncAction2["Remove"] = "remove";
-  return SyncAction2;
+var SyncAction = /* @__PURE__ */ ((SyncAction3) => {
+  SyncAction3["Create"] = "create";
+  SyncAction3["Update"] = "update";
+  SyncAction3["Remove"] = "remove";
+  return SyncAction3;
 })(SyncAction || {});
-var DEFAULT_SYNC_INTERVAL_MILLIS = 5e3;
+var DEFAULT_SYNC_INTERVAL_MILLIS = 2e3;
 var DEFAULT_LOGGER = console;
 var DEFAULT_MIN_LOG_LEVEL = "debug";
 var DEFAULT_MISSING_REMOTE_RECORD_STRATEGY = "ignore";
-var DEFAULT_CONFLICT_RESOLUTION_STRATEGY = "local-wins";
+var DEFAULT_CONFLICT_RESOLUTION_STRATEGY = "client-wins";
 function createWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}) {
   const store = create(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
   return new Promise((resolve) => {
@@ -500,7 +607,8 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
         syncState: {
           firstLoadDone: syncState.firstLoadDone,
           pendingChanges: syncState.pendingChanges,
-          lastPulled: syncState.lastPulled
+          lastPulled: syncState.lastPulled,
+          conflicts: syncState.conflicts
         }
       };
     },
@@ -509,7 +617,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       return {
         ...state,
         syncState: {
-          ...state.syncState,
+          ...state.syncState || {},
           status: "idle"
           // this confirms 'hydrating' is done
         }
@@ -517,13 +625,12 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
     }
   };
   const creator = (set, get, storeApi) => {
-    let syncIntervalId;
+    let syncTimerStarted = false;
     async function syncOnce() {
-      const state = get();
-      if (!state.syncState.enabled || state.syncState.status !== "idle") return;
-      set((state2) => ({
+      if (get().syncState.status !== "idle") return;
+      set((state) => ({
         syncState: {
-          ...state2.syncState || {},
+          ...state.syncState || {},
           status: "syncing"
         }
       }));
@@ -558,24 +665,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
           logger.error(`[zync] push:error change=${change}`, err);
         }
       }
-      set((state2) => ({
+      set((state) => ({
         syncState: {
-          ...state2.syncState || {},
+          ...state.syncState || {},
           status: "idle",
           error: firstSyncError
         }
       }));
-      if (get().syncState.pendingChanges.length > 0 && !firstSyncError) {
-        await syncOnce();
-      }
-    }
-    function setAndSyncOnce(partial) {
-      if (typeof partial === "function") {
-        set((state) => ({ ...partial(state) }));
-      } else {
-        set(partial);
-      }
-      syncOnce();
     }
     function setAndQueueToSync(partial) {
       if (typeof partial === "function") {
@@ -583,7 +679,6 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       } else {
         set((state) => newSyncState(state, partial));
       }
-      syncOnce();
     }
     function newSyncState(state, partial) {
       const pendingChanges = state.syncState.pendingChanges || [];
@@ -593,11 +688,13 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
         const changes = findChanges(current, updated);
         tryAddToPendingChanges(pendingChanges, stateKey, changes);
       });
+      const conflicts = tryUpdateConflicts(pendingChanges, state.syncState.conflicts);
       return {
         ...partial,
         syncState: {
           ...state.syncState || {},
-          pendingChanges
+          pendingChanges,
+          conflicts
         }
       };
     }
@@ -605,18 +702,26 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       set((state) => ({
         syncState: {
           ...state.syncState || {},
-          enabled
+          status: enabled ? "idle" : "disabled"
         }
       }));
-      enableSyncTimer(enabled);
+      startSyncTimer(enabled);
       addVisibilityChangeListener(enabled);
     }
-    function enableSyncTimer(enabled) {
-      clearInterval(syncIntervalId);
-      syncIntervalId = void 0;
-      if (enabled) {
-        syncIntervalId = setInterval(syncOnce, syncInterval);
-        syncOnce();
+    function startSyncTimer(start) {
+      if (start) {
+        tryStart();
+      } else {
+        syncTimerStarted = false;
+      }
+    }
+    async function tryStart() {
+      if (syncTimerStarted) return;
+      syncTimerStarted = true;
+      while (true) {
+        if (!syncTimerStarted) break;
+        await syncOnce();
+        await sleep(syncInterval);
       }
     }
     function addVisibilityChangeListener(add) {
@@ -629,24 +734,25 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
     function onVisibilityChange() {
       if (document.visibilityState === "visible") {
         logger.debug("[zync] sync:start-in-foreground");
-        enableSyncTimer(true);
+        startSyncTimer(true);
       } else {
         logger.debug("[zync] sync:pause-in-background");
-        enableSyncTimer(false);
+        startSyncTimer(false);
       }
     }
     storeApi.sync = {
       enable,
-      startFirstLoad: () => startFirstLoad(set, syncApi, logger)
+      startFirstLoad: () => startFirstLoad(set, syncApi, logger),
+      resolveConflict: (localId, keepLocal) => resolveConflict(set, localId, keepLocal)
     };
-    const userState = stateCreator(setAndSyncOnce, get, setAndQueueToSync);
+    const userState = stateCreator(set, get, setAndQueueToSync);
     return {
       ...userState,
       syncState: {
         // set defaults
         status: "hydrating",
         error: void 0,
-        enabled: false,
+        conflicts: void 0,
         firstLoadDone: false,
         pendingChanges: [],
         lastPulled: {}
@@ -657,9 +763,11 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
 }
 export {
   SyncAction,
+  changeKeysFrom,
+  changeKeysTo,
   createIndexedDBStorage,
+  createLocalId,
   createWithSync,
-  nextLocalId,
   persistWithSync
 };
 //# sourceMappingURL=index.js.map