@anfenn/zync 0.3.4 → 0.4.1

package/README.md

@@ -4,7 +4,7 @@
 
 Simple, unopinionated, bullet-proof, offline-first sync middleware for Zustand.
 
-**_STATUS_**: Actively developed in alpha stage while requirements are being understood. Api may change, requests are welcome.
+**_STATUS_**: Actively developed in beta stage. Core features are complete, Api is stable, requests are welcome.
 
 ## Benefits
 
@@ -12,33 +12,38 @@ Simple, unopinionated, bullet-proof, offline-first sync middleware for Zustand.
 - **"It just works"** philosophy
 - Optimistic UI updates
 - Conflict resolution:
-    - 'local-wins' | 'remote-wins' _**(More in development)**_
+    - 'client-wins' | 'server-wins' | 'try-shallow-merge'
+    - 'try-shallow-merge' allows the user to choose between client and server changes if conflicts are found
 - Missing remote record during update strategy, to prevent accidental server deletion from losing client data:
     - 'ignore' | 'delete-local-record' | 'insert-remote-record'
 - Batteries optionally included:
-    - IndexedDB helper (based on [idb](https://www.npmjs.com/package/idb))
-    - UUID helper
+    - IndexedDB helper (based on [idb](https://www.npmjs.com/package/idb)): `createIndexedDBStorage()`
+    - UUID helper: `createLocalId()`
+    - Object|Array key rename helpers to map endpoint fields to Zync: `changeKeysFrom()` & `changeKeysTo()`
 - Uses the official persist middleware as the local storage (localStorage, IndexedDB, etc.)
 - Zync's persistWithSync() is a drop-in replacement for Zustand's persist()
 - Allows for idiomatic use of Zustand
 - Leaves the api requests up to you (RESTful, GraphQL, etc.), just provide add(), update(), remove() and list()
 - Client or server assigned primary key, of any datatype
+- Fully tested on `localstorage` and `IndexedDB` (>80% code coverage)
+- Client schema migrations are a breeze using Zustand's [migrate](https://zustand.docs.pmnd.rs/middlewares/persist#persisting-a-state-through-versioning-and-migrations) hook
+- All Zync's internal state is accessible via the reactive `state.syncState` object
 
 ## Requirements
 
-- Client records will have a `_localId` field which is stable and never sent to the server. It is ideal for use as a key in JSX. The provided helper function `nextLocalId()` returns a UUID, but you could use any unique value
+- Client records will have a `_localId` field which is stable and never sent to the server. It is ideal for use as a key in JSX. The provided helper function `createLocalId()` returns a UUID, but you could use any unique value
 - Server records must have:
 
     - `id`: Any datatype, can be a server OR client assigned value
     - `updated_at`: Server assigned **_millisecond_** timestamp (db trigger or api layer). The client will never send this as the client clock is unlikely to be in sync with the server, so is never used for change detection. If it has a higher precision than millisecond, like PostgreSQL's microsecond timestampz, updates could be ignored.
     - `deleted`: Boolean, used for soft deletes, to allow other clients to download deleted records to keep their local records in sync
 
-    **_TIP: If your endpoint doesn't have the same names as the 3 fields above, you can map them in your `api.ts` file e.g. `deleted` -> `isDeleted`_**
+    **_TIP: If your endpoint doesn't have the same names as the 3 fields above, you can easily rename them in your `api.ts` file using the included `changeKeysFrom()` & `changeKeysTo()`_**
 
 ## Quickstart
 
 ```bash
-npm install @anfenn/zync
+npm install zustand @anfenn/zync
 ```
 
 _The example below uses server assigned id's, but you can just set the id when creating an object for client assigned id's._
@@ -66,7 +71,7 @@ export const useStore = create<any>()(
 
             facts: [],
             addFact: (item: Fact) => {
-                const updated_at = new Date().toISOString(); // Used as an optimistic UI update only, never sent to server
+                const updated_at = new Date().toISOString(); // Optimistic UI update only, never sent to server
                 const newItem = { ...item, created_at: updated_at, updated_at };
 
                 setAndSync((state: Store) => ({
@@ -108,9 +113,9 @@ export const useStore = create<any>()(
             // Triggered by the api.update() returning true or false confirming the existence of the remote record after an update
             missingRemoteRecordDuringUpdateStrategy: 'ignore',
 
-            // Options: 'local-wins' | 'remote-wins' (More coming soon)
-            // Default: 'local-wins'
-            conflictResolutionStrategy: 'local-wins',
+            // Options: 'client-wins' | 'server-wins' | 'try-shallow-merge'
+            // Default: 'try-shallow-merge' (Conflicts are listed in syncState.conflicts)
+            conflictResolutionStrategy: 'try-shallow-merge',
         },
     ),
 ) as UseStoreWithSync<Store>;
@@ -133,7 +138,7 @@ export const useFacts = () =>
 
 ```ts
 import { useEffect } from 'react';
-import { nextLocalId } from '@anfenn/zync';
+import { createLocalId } from '@anfenn/zync';
 import { useFacts, useStore } from './store';
 
 function App() {
@@ -142,17 +147,18 @@ function App() {
 
     // Zync's internal sync state
     const syncState = useStore((state) => state.syncState);
-    // syncState.status // 'hydrating' | 'syncing' | 'idle'
+    // syncState.status // 'disabled' | 'hydrating' | 'syncing' | 'idle'
     // syncState.error
-    // syncState.enabled
+    // syncState.conflicts
     // syncState.firstLoadDone
     // syncState.pendingChanges
     // syncState.lastPulled
 
     useEffect(() => {
         // Zync's control api
-        useStore.sync.enable(true);       // Defaults to false, enable to start syncing
-        //useStore.sync.startFirstLoad(); // Batch loads from server
+        useStore.sync.enable(true);                     // Defaults to false, enable to start syncing
+        //useStore.sync.startFirstLoad();               // Batch loads from server
+        //useStore.sync.resolveConflict(localId, true); // Keep client or server changes for specific record
     }, []);
 
     return (
@@ -161,7 +167,7 @@ function App() {
             <button
                 onClick={() =>
                     addFact({
-                        _localId: nextLocalId(),
+                        _localId: createLocalId(),
                         title: 'New fact ' + Date.now(),
                     })
                 }
@@ -189,9 +195,8 @@ import { supabase } from './supabase'; // Please include your own :)
 export type Fact = {
     _localId: string;
     fact: string;
-    // Server assigned fields
-    id?: number;
-    updated_at?: string;
+    id?: number; // Client OR server assigned
+    updated_at?: string; // Server assigned
 };
 
 export const factApi: ApiFunctions = { add, update, remove, list, firstLoad };

package/dist/index.cjs

@@ -281,9 +281,11 @@ var init_build = __esm({
 var index_exports = {};
 __export(index_exports, {
   SyncAction: () => SyncAction,
+  changeKeysFrom: () => changeKeysFrom,
+  changeKeysTo: () => changeKeysTo,
   createIndexedDBStorage: () => createIndexedDBStorage,
+  createLocalId: () => createLocalId,
   createWithSync: () => createWithSync,
-  nextLocalId: () => nextLocalId,
   persistWithSync: () => persistWithSync
 });
 module.exports = __toCommonJS(index_exports);
@@ -311,9 +313,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 */:
@@ -330,8 +363,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) {
@@ -365,7 +398,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) });
     }
   }
 }
@@ -377,6 +410,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) {
@@ -418,6 +475,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) {
@@ -428,7 +529,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]));
@@ -452,43 +554,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}`);
       }
     }
@@ -496,6 +598,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()
@@ -509,7 +613,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) {
@@ -522,11 +625,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 {
@@ -548,7 +657,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) => ({
@@ -570,7 +679,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) => ({
@@ -627,7 +736,7 @@ async function startFirstLoad(set, syncApi, logger) {
             } else {
               next.push({
                 ...remote,
-                _localId: nextLocalId()
+                _localId: createLocalId()
               });
             }
           }
@@ -735,17 +844,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 = (0, import_zustand.create)(persistWithSync(stateCreator, persistOptions, syncApi, syncOptions));
   return new Promise((resolve) => {
@@ -782,7 +891,8 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
         syncState: {
           firstLoadDone: syncState.firstLoadDone,
           pendingChanges: syncState.pendingChanges,
-          lastPulled: syncState.lastPulled
+          lastPulled: syncState.lastPulled,
+          conflicts: syncState.conflicts
         }
       };
     },
@@ -791,7 +901,7 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       return {
         ...state,
         syncState: {
-          ...state.syncState,
+          ...state.syncState || {},
           status: "idle"
           // this confirms 'hydrating' is done
         }
@@ -799,13 +909,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"
         }
       }));
@@ -840,24 +949,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") {
@@ -865,7 +963,6 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
       } else {
         set((state) => newSyncState(state, partial));
       }
-      syncOnce();
     }
     function newSyncState(state, partial) {
       const pendingChanges = state.syncState.pendingChanges || [];
@@ -875,11 +972,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
         }
       };
     }
@@ -887,18 +986,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) {
@@ -911,24 +1018,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: {}
@@ -940,9 +1048,11 @@ function persistWithSync(stateCreator, persistOptions, syncApi, syncOptions = {}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SyncAction,
+  changeKeysFrom,
+  changeKeysTo,
   createIndexedDBStorage,
+  createLocalId,
   createWithSync,
-  nextLocalId,
   persistWithSync
 });
 //# sourceMappingURL=index.cjs.map