@anfenn/dync 1.0.1 → 1.0.3

package/README.md

@@ -10,11 +10,11 @@ Start with a Website or PWA using IndexedDB, sync with your existing REST API, a
 
 1. Frictionless upgrade path from an offline-first PWA targeting IndexedDB, to when:
 
-    **A)** Full text search is required on many records (IndexedDB doesn't support this so will do a full table scan in the JS VM, which is slow on many records)
+    **A) Full text search is required on many records** (IndexedDB doesn't support this so will do a full table scan in the JS VM, which is slow on many records)
 
     **_and/or_**
 
-    **B)** Encryption is required (Browsers can't store the encryption key securely)
+    **B) Encryption is required** (Browsers can't store the encryption key securely)
 
     ... you can simply add CapacitorJs or move to React Native which have sqlite & secure enclave storage, and only change the adapter Dync uses
 

package/dist/{chunk-LGHOZECP.js → chunk-66PSQW4D.js}

@@ -152,7 +152,7 @@ var StateManager = class {
   }
   addPendingChange(change) {
     const next = clonePersistedState(this.persistedState);
-    const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.stateKey === change.stateKey);
+    const queueItem = next.pendingChanges.find((p) => p.localId === change.localId && p.tableName === change.tableName);
     const omittedChanges = omitFields(change.changes, LOCAL_ONLY_SYNC_FIELDS);
     const omittedBefore = omitFields(change.before, LOCAL_ONLY_SYNC_FIELDS);
     const omittedAfter = omitFields(change.after, LOCAL_ONLY_SYNC_FIELDS);
@@ -173,7 +173,7 @@ var StateManager = class {
       next.pendingChanges = [...next.pendingChanges];
       next.pendingChanges.push({
         action,
-        stateKey: change.stateKey,
+        tableName: change.tableName,
         localId: change.localId,
         id: change.id,
         version: 1,
@@ -185,18 +185,18 @@ var StateManager = class {
     this.persistedState = next;
     return this.persist();
   }
-  samePendingVersion(stateKey, localId, version) {
-    return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.stateKey === stateKey)?.version === version;
+  samePendingVersion(tableName, localId, version) {
+    return this.persistedState.pendingChanges.find((p) => p.localId === localId && p.tableName === tableName)?.version === version;
   }
-  removePendingChange(localId, stateKey) {
+  removePendingChange(localId, tableName) {
     const next = clonePersistedState(this.persistedState);
-    next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.stateKey === stateKey));
+    next.pendingChanges = next.pendingChanges.filter((p) => !(p.localId === localId && p.tableName === tableName));
     this.persistedState = next;
     return this.persist();
   }
-  updatePendingChange(stateKey, localId, action, id) {
+  updatePendingChange(tableName, localId, action, id) {
     const next = clonePersistedState(this.persistedState);
-    const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+    const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && p.localId === localId);
     if (changeItem) {
       changeItem.action = action;
       if (id) changeItem.id = id;
@@ -205,9 +205,9 @@ var StateManager = class {
     }
     return Promise.resolve();
   }
-  setPendingChangeBefore(stateKey, localId, before) {
+  setPendingChangeBefore(tableName, localId, before) {
     const next = clonePersistedState(this.persistedState);
-    const changeItem = next.pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localId);
+    const changeItem = next.pendingChanges.find((p) => p.tableName === tableName && p.localId === localId);
     if (changeItem) {
       changeItem.before = { ...changeItem.before ?? {}, ...before };
       this.persistedState = next;
@@ -278,7 +278,7 @@ function cloneConflicts(conflicts) {
   const next = {};
   for (const [key, value] of Object.entries(conflicts)) {
     next[key] = {
-      stateKey: value.stateKey,
+      tableName: value.tableName,
       fields: value.fields.map((field) => ({ ...field }))
     };
   }
@@ -389,7 +389,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
       result = await rawAdd(syncedItem);
       await state.addPendingChange({
         action: "create" /* Create */,
-        stateKey: tableName,
+        tableName,
         localId,
         changes: syncedItem,
         before: null,
@@ -417,7 +417,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
       result = await rawPut(syncedItem);
       await state.addPendingChange({
         action: isUpdate ? "update" /* Update */ : "create" /* Create */,
-        stateKey: tableName,
+        tableName,
         localId,
         id: existingRecord?.id,
         changes: syncedItem,
@@ -444,7 +444,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
       if (result > 0) {
         await state.addPendingChange({
           action: "update" /* Update */,
-          stateKey: tableName,
+          tableName,
           localId: key,
           id: record.id,
           changes: updatedChanges,
@@ -468,7 +468,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
         deletedLocalId = record._localId;
         await state.addPendingChange({
           action: "remove" /* Remove */,
-          stateKey: tableName,
+          tableName,
           localId: record._localId,
           id: record.id,
           changes: null,
@@ -497,7 +497,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
       for (const syncedItem of syncedItems) {
         await state.addPendingChange({
           action: "create" /* Create */,
-          stateKey: tableName,
+          tableName,
           localId: syncedItem._localId,
           changes: syncedItem,
           before: null,
@@ -535,7 +535,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
         const existing = existingMap.get(syncedItem._localId);
         await state.addPendingChange({
           action: existing ? "update" /* Update */ : "create" /* Create */,
-          stateKey: tableName,
+          tableName,
           localId: syncedItem._localId,
           id: existing?.id,
           changes: syncedItem,
@@ -576,7 +576,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
           updatedKeys.push(record._localId);
           await state.addPendingChange({
             action: "update" /* Update */,
-            stateKey: tableName,
+            tableName,
             localId: record._localId,
             id: record.id,
             changes,
@@ -603,7 +603,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
           deletedLocalIds.push(record._localId);
           await state.addPendingChange({
             action: "remove" /* Remove */,
-            stateKey: tableName,
+            tableName,
             localId: record._localId,
             id: record.id,
             changes: null,
@@ -627,7 +627,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
           deletedLocalIds.push(record._localId);
           await state.addPendingChange({
             action: "remove" /* Remove */,
-            stateKey: tableName,
+            tableName,
             localId: record._localId,
             id: record.id,
             changes: null,
@@ -656,33 +656,33 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
 async function pullAll(ctx) {
   let firstSyncError;
   const changedTables = [];
-  for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+  for (const [tableName, api] of Object.entries(ctx.syncApis)) {
     try {
-      const lastPulled = ctx.state.getState().lastPulled[stateKey];
+      const lastPulled = ctx.state.getState().lastPulled[tableName];
       const since = lastPulled ? new Date(lastPulled) : /* @__PURE__ */ new Date(0);
-      ctx.logger.debug(`[dync] pull:start stateKey=${stateKey} since=${since.toISOString()}`);
+      ctx.logger.debug(`[dync] pull:start tableName=${tableName} since=${since.toISOString()}`);
       const serverData = await api.list(since);
-      const changed = await processPullData(stateKey, serverData, since, ctx);
-      if (changed) changedTables.push(stateKey);
+      const changed = await processPullData(tableName, serverData, since, ctx);
+      if (changed) changedTables.push(tableName);
     } catch (err) {
       firstSyncError = firstSyncError ?? err;
-      ctx.logger.error(`[dync] pull:error stateKey=${stateKey}`, err);
+      ctx.logger.error(`[dync] pull:error tableName=${tableName}`, err);
     }
   }
   return { error: firstSyncError, changedTables };
 }
-async function handleRemoteItemUpdate(table, stateKey, localItem, remote, ctx) {
-  const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.stateKey === stateKey && p.localId === localItem._localId);
+async function handleRemoteItemUpdate(table, tableName, localItem, remote, ctx) {
+  const pendingChange = ctx.state.getState().pendingChanges.find((p) => p.tableName === tableName && p.localId === localItem._localId);
   const conflictStrategy = ctx.conflictResolutionStrategy;
   if (pendingChange) {
-    ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} stateKey=${stateKey} id=${remote.id}`);
+    ctx.logger.debug(`[dync] pull:conflict-strategy:${conflictStrategy} tableName=${tableName} id=${remote.id}`);
     switch (conflictStrategy) {
       case "local-wins":
         break;
       case "remote-wins": {
         const merged = { ...remote, _localId: localItem._localId };
         await table.raw.update(localItem._localId, merged);
-        await ctx.state.removePendingChange(localItem._localId, stateKey);
+        await ctx.state.removePendingChange(localItem._localId, tableName);
         break;
       }
       case "try-shallow-merge": {
@@ -695,7 +695,7 @@ async function handleRemoteItemUpdate(table, stateKey, localItem, remote, ctx) {
             ...syncState,
             conflicts: {
               ...syncState.conflicts || {},
-              [localItem._localId]: { stateKey, fields }
+              [localItem._localId]: { tableName, fields }
             }
           }));
         } else {
@@ -718,7 +718,7 @@ async function handleRemoteItemUpdate(table, stateKey, localItem, remote, ctx) {
   } else {
     const merged = { ...localItem, ...remote };
     await table.raw.update(localItem._localId, merged);
-    ctx.logger.debug(`[dync] pull:merge-remote stateKey=${stateKey} id=${remote.id}`);
+    ctx.logger.debug(`[dync] pull:merge-remote tableName=${tableName} id=${remote.id}`);
   }
 }
 async function pullAllBatch(ctx) {
@@ -732,17 +732,17 @@ async function pullAllBatch(ctx) {
     }
     ctx.logger.debug(`[dync] pull:batch:start tables=${[...ctx.batchSync.syncTables].join(",")}`, sinceMap);
     const serverDataByTable = await ctx.batchSync.pull(sinceMap);
-    for (const [stateKey, serverData] of Object.entries(serverDataByTable)) {
-      if (!ctx.batchSync.syncTables.includes(stateKey)) {
-        ctx.logger.warn(`[dync] pull:batch:unknown-table stateKey=${stateKey}`);
+    for (const [tableName, serverData] of Object.entries(serverDataByTable)) {
+      if (!ctx.batchSync.syncTables.includes(tableName)) {
+        ctx.logger.warn(`[dync] pull:batch:unknown-table tableName=${tableName}`);
         continue;
       }
       try {
-        const changed = await processPullData(stateKey, serverData, sinceMap[stateKey], ctx);
-        if (changed) changedTables.push(stateKey);
+        const changed = await processPullData(tableName, serverData, sinceMap[tableName], ctx);
+        if (changed) changedTables.push(tableName);
       } catch (err) {
         firstSyncError = firstSyncError ?? err;
-        ctx.logger.error(`[dync] pull:batch:error stateKey=${stateKey}`, err);
+        ctx.logger.error(`[dync] pull:batch:error tableName=${tableName}`, err);
       }
     }
   } catch (err) {
@@ -751,40 +751,40 @@ async function pullAllBatch(ctx) {
   }
   return { error: firstSyncError, changedTables };
 }
-async function processPullData(stateKey, serverData, since, ctx) {
+async function processPullData(tableName, serverData, since, ctx) {
   if (!serverData?.length) return false;
-  ctx.logger.debug(`[dync] pull:process stateKey=${stateKey} count=${serverData.length}`);
+  ctx.logger.debug(`[dync] pull:process tableName=${tableName} count=${serverData.length}`);
   let newest = since;
   let hasChanges = false;
-  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[stateKey];
+  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[tableName];
     const pendingRemovalById = new Set(
-      ctx.state.getState().pendingChanges.filter((p) => p.stateKey === stateKey && p.action === "remove" /* Remove */).map((p) => p.id)
+      ctx.state.getState().pendingChanges.filter((p) => p.tableName === tableName && p.action === "remove" /* Remove */).map((p) => p.id)
     );
     for (const remote of serverData) {
       const remoteUpdated = new Date(remote.updated_at);
       if (remoteUpdated > newest) newest = remoteUpdated;
       if (pendingRemovalById.has(remote.id)) {
-        ctx.logger.debug(`[dync] pull:skip-pending-remove stateKey=${stateKey} id=${remote.id}`);
+        ctx.logger.debug(`[dync] pull:skip-pending-remove tableName=${tableName} id=${remote.id}`);
         continue;
       }
       const localItem = await txTable.where("id").equals(remote.id).first();
       if (remote.deleted) {
         if (localItem) {
           await txTable.raw.delete(localItem._localId);
-          ctx.logger.debug(`[dync] pull:remove stateKey=${stateKey} id=${remote.id}`);
+          ctx.logger.debug(`[dync] pull:remove tableName=${tableName} id=${remote.id}`);
           hasChanges = true;
         }
         continue;
       }
       delete remote.deleted;
       if (localItem) {
-        await handleRemoteItemUpdate(txTable, stateKey, localItem, remote, ctx);
+        await handleRemoteItemUpdate(txTable, tableName, localItem, remote, ctx);
         hasChanges = true;
       } else {
         const newLocalItem = { ...remote, _localId: createLocalId() };
         await txTable.raw.add(newLocalItem);
-        ctx.logger.debug(`[dync] pull:add stateKey=${stateKey} id=${remote.id}`);
+        ctx.logger.debug(`[dync] pull:add tableName=${tableName} id=${remote.id}`);
         hasChanges = true;
       }
     }
@@ -792,7 +792,7 @@ async function processPullData(stateKey, serverData, since, ctx) {
       ...syncState,
       lastPulled: {
         ...syncState.lastPulled,
-        [stateKey]: newest.toISOString()
+        [tableName]: newest.toISOString()
       }
     }));
   });
@@ -801,35 +801,35 @@ async function processPullData(stateKey, serverData, since, ctx) {
 
 // src/core/pushOperations.ts
 async function handleRemoveSuccess(change, ctx) {
-  const { stateKey, localId, id } = change;
-  ctx.logger.debug(`[dync] push:remove:success stateKey=${stateKey} localId=${localId} id=${id}`);
-  await ctx.state.removePendingChange(localId, stateKey);
+  const { tableName, localId, id } = change;
+  ctx.logger.debug(`[dync] push:remove:success tableName=${tableName} localId=${localId} id=${id}`);
+  await ctx.state.removePendingChange(localId, tableName);
 }
 async function handleUpdateSuccess(change, ctx) {
-  const { stateKey, localId, version, changes } = change;
-  ctx.logger.debug(`[dync] push:update:success stateKey=${stateKey} localId=${localId} id=${change.id}`);
-  if (ctx.state.samePendingVersion(stateKey, localId, version)) {
-    await ctx.state.removePendingChange(localId, stateKey);
+  const { tableName, localId, version, changes } = change;
+  ctx.logger.debug(`[dync] push:update:success tableName=${tableName} localId=${localId} id=${change.id}`);
+  if (ctx.state.samePendingVersion(tableName, localId, version)) {
+    await ctx.state.removePendingChange(localId, tableName);
   } else {
-    await ctx.state.setPendingChangeBefore(stateKey, localId, changes);
+    await ctx.state.setPendingChangeBefore(tableName, localId, changes);
   }
 }
 async function handleCreateSuccess(change, serverResult, ctx) {
-  const { stateKey, localId, version, changes, id } = change;
-  ctx.logger.debug(`[dync] push:create:success stateKey=${stateKey} localId=${localId} id=${id ?? serverResult.id}`);
-  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[stateKey];
+  const { tableName, localId, version, changes, id } = change;
+  ctx.logger.debug(`[dync] push:create:success tableName=${tableName} localId=${localId} id=${id ?? serverResult.id}`);
+  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[tableName];
     const wasChanged = await txTable.raw.update(localId, serverResult) ?? 0;
-    if (wasChanged && ctx.state.samePendingVersion(stateKey, localId, version)) {
-      await ctx.state.removePendingChange(localId, stateKey);
+    if (wasChanged && ctx.state.samePendingVersion(tableName, localId, version)) {
+      await ctx.state.removePendingChange(localId, tableName);
     } else {
       const nextAction = wasChanged ? "update" /* Update */ : "remove" /* Remove */;
-      await ctx.state.updatePendingChange(stateKey, localId, nextAction, serverResult.id);
+      await ctx.state.updatePendingChange(tableName, localId, nextAction, serverResult.id);
       if (nextAction === "remove" /* Remove */) return;
     }
   });
   const finalItem = { ...changes, ...serverResult, _localId: localId };
-  ctx.syncOptions.onAfterRemoteAdd?.(stateKey, finalItem);
+  ctx.syncOptions.onAfterRemoteAdd?.(tableName, finalItem);
 }
 async function pushAll(ctx) {
   let firstSyncError;
@@ -845,15 +845,15 @@ async function pushAll(ctx) {
   return firstSyncError;
 }
 async function pushOne(change, ctx) {
-  const api = ctx.syncApis[change.stateKey];
+  const api = ctx.syncApis[change.tableName];
   if (!api) return;
-  ctx.logger.debug(`[dync] push:attempt action=${change.action} stateKey=${change.stateKey} localId=${change.localId}`);
-  const { action, stateKey, localId, id, changes, after } = change;
+  ctx.logger.debug(`[dync] push:attempt action=${change.action} tableName=${change.tableName} localId=${change.localId}`);
+  const { action, tableName, localId, id, changes, after } = change;
   switch (action) {
     case "remove" /* Remove */:
       if (!id) {
-        ctx.logger.warn(`[dync] push:remove:no-id stateKey=${stateKey} localId=${localId}`);
-        await ctx.state.removePendingChange(localId, stateKey);
+        ctx.logger.warn(`[dync] push:remove:no-id tableName=${tableName} localId=${localId}`);
+        await ctx.state.removePendingChange(localId, tableName);
         return;
       }
       await api.remove(id);
@@ -861,7 +861,7 @@ async function pushOne(change, ctx) {
       break;
     case "update" /* Update */: {
       if (ctx.state.hasConflicts(localId)) {
-        ctx.logger.warn(`[dync] push:update:skipping-with-conflicts stateKey=${stateKey} localId=${localId} id=${id}`);
+        ctx.logger.warn(`[dync] push:update:skipping-with-conflicts tableName=${tableName} localId=${localId} id=${id}`);
         return;
       }
       const exists = await api.update(id, changes, after);
@@ -877,9 +877,9 @@ async function pushOne(change, ctx) {
       if (result) {
         await handleCreateSuccess(change, result, ctx);
       } else {
-        ctx.logger.warn(`[dync] push:create:no-result stateKey=${stateKey} localId=${localId} id=${id}`);
-        if (ctx.state.samePendingVersion(stateKey, localId, change.version)) {
-          await ctx.state.removePendingChange(localId, stateKey);
+        ctx.logger.warn(`[dync] push:create:no-result tableName=${tableName} localId=${localId} id=${id}`);
+        if (ctx.state.samePendingVersion(tableName, localId, change.version)) {
+          await ctx.state.removePendingChange(localId, tableName);
         }
       }
       break;
@@ -887,21 +887,21 @@ async function pushOne(change, ctx) {
   }
 }
 async function handleMissingRemoteRecord(change, ctx) {
-  const { stateKey, localId } = change;
+  const { tableName, localId } = change;
   const strategy = ctx.syncOptions.missingRemoteRecordDuringUpdateStrategy;
   let localItem;
-  await ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[stateKey];
+  await ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[tableName];
     localItem = await txTable.get(localId);
     if (!localItem) {
-      ctx.logger.warn(`[dync] push:missing-remote:no-local-item stateKey=${stateKey} localId=${localId}`);
-      await ctx.state.removePendingChange(localId, stateKey);
+      ctx.logger.warn(`[dync] push:missing-remote:no-local-item tableName=${tableName} localId=${localId}`);
+      await ctx.state.removePendingChange(localId, tableName);
       return;
     }
     switch (strategy) {
       case "delete-local-record":
         await txTable.raw.delete(localId);
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${localItem.id}`);
         break;
       case "insert-remote-record": {
         const newItem = {
@@ -913,36 +913,36 @@ async function handleMissingRemoteRecord(change, ctx) {
         await txTable.raw.delete(localId);
         await ctx.state.addPendingChange({
           action: "create" /* Create */,
-          stateKey,
+          tableName,
           localId: newItem._localId,
           changes: newItem,
           before: null
         });
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${newItem.id}`);
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${newItem.id}`);
         break;
       }
       case "ignore":
-        ctx.logger.debug(`[dync] push:missing-remote:${strategy} stateKey=${stateKey} id=${localItem.id}`);
+        ctx.logger.debug(`[dync] push:missing-remote:${strategy} tableName=${tableName} id=${localItem.id}`);
         break;
       default:
-        ctx.logger.error(`[dync] push:missing-remote:unknown-strategy stateKey=${stateKey} id=${localItem.id} strategy=${strategy}`);
+        ctx.logger.error(`[dync] push:missing-remote:unknown-strategy tableName=${tableName} id=${localItem.id} strategy=${strategy}`);
         break;
     }
-    await ctx.state.removePendingChange(localId, stateKey);
+    await ctx.state.removePendingChange(localId, tableName);
   });
   ctx.syncOptions.onAfterMissingRemoteRecordDuringUpdate?.(strategy, localItem);
 }
 async function pushAllBatch(ctx) {
   let firstSyncError;
   try {
-    const changesSnapshot = [...ctx.state.getState().pendingChanges].filter((change) => ctx.batchSync.syncTables.includes(change.stateKey)).sort((a, b) => orderFor(a.action) - orderFor(b.action));
+    const changesSnapshot = [...ctx.state.getState().pendingChanges].filter((change) => ctx.batchSync.syncTables.includes(change.tableName)).sort((a, b) => orderFor(a.action) - orderFor(b.action));
     if (changesSnapshot.length === 0) {
       ctx.logger.debug("[dync] push:batch:no-changes");
       return void 0;
     }
     const changesToPush = changesSnapshot.filter((change) => {
       if (change.action === "update" /* Update */ && ctx.state.hasConflicts(change.localId)) {
-        ctx.logger.warn(`[dync] push:batch:skipping-with-conflicts stateKey=${change.stateKey} localId=${change.localId}`);
+        ctx.logger.warn(`[dync] push:batch:skipping-with-conflicts tableName=${change.tableName} localId=${change.localId}`);
         return false;
       }
       return true;
@@ -952,7 +952,7 @@ async function pushAllBatch(ctx) {
       return void 0;
     }
     const payloads = changesToPush.map((change) => ({
-      table: change.stateKey,
+      table: change.tableName,
       action: change.action === "create" /* Create */ ? "add" : change.action === "update" /* Update */ ? "update" : "remove",
       localId: change.localId,
       id: change.id,
@@ -984,12 +984,12 @@ async function pushAllBatch(ctx) {
   return firstSyncError;
 }
 async function processBatchPushResult(change, result, ctx) {
-  const { action, stateKey, localId } = change;
+  const { action, tableName, localId } = change;
   if (!result.success) {
     if (action === "update" /* Update */) {
       await handleMissingRemoteRecord(change, ctx);
     } else {
-      ctx.logger.warn(`[dync] push:batch:failed stateKey=${stateKey} localId=${localId} error=${result.error}`);
+      ctx.logger.warn(`[dync] push:batch:failed tableName=${tableName} localId=${localId} error=${result.error}`);
     }
     return;
   }
@@ -1021,13 +1021,13 @@ async function startFirstLoad(ctx) {
     return;
   }
   let error;
-  for (const [stateKey, api] of Object.entries(ctx.syncApis)) {
+  for (const [tableName, api] of Object.entries(ctx.syncApis)) {
     if (!api.firstLoad) {
-      ctx.logger.error(`[dync] firstLoad:no-api-function stateKey=${stateKey}`);
+      ctx.logger.error(`[dync] firstLoad:no-api-function tableName=${tableName}`);
       continue;
     }
     try {
-      ctx.logger.info(`[dync] firstLoad:start stateKey=${stateKey}`);
+      ctx.logger.info(`[dync] firstLoad:start tableName=${tableName}`);
       let lastId;
       let isEmptyTable = true;
       let batchCount = 0;
@@ -1037,19 +1037,19 @@ async function startFirstLoad(ctx) {
         const batch = await api.firstLoad(lastId);
         if (!batch?.length) break;
         batchCount++;
-        const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, lastId === void 0);
+        const { inserted, updated } = await processBatchInChunks(ctx, tableName, batch, isEmptyTable, lastId === void 0);
         totalInserted += inserted;
         totalUpdated += updated;
         if (ctx.onProgress) {
           ctx.onProgress({
-            table: stateKey,
+            table: tableName,
             inserted: totalInserted,
             updated: totalUpdated,
             total: totalInserted + totalUpdated
           });
         }
         if (lastId === void 0) {
-          isEmptyTable = await ctx.table(stateKey).count() === batch.length;
+          isEmptyTable = await ctx.table(tableName).count() === batch.length;
         }
         if (lastId !== void 0 && lastId === batch[batch.length - 1].id) {
           throw new Error(`Duplicate records downloaded, stopping to prevent infinite loop`);
@@ -1059,10 +1059,10 @@ async function startFirstLoad(ctx) {
           await yieldToEventLoop();
         }
       }
-      ctx.logger.info(`[dync] firstLoad:done stateKey=${stateKey} inserted=${totalInserted} updated=${totalUpdated}`);
+      ctx.logger.info(`[dync] firstLoad:done tableName=${tableName} inserted=${totalInserted} updated=${totalUpdated}`);
     } catch (err) {
       error = error ?? err;
-      ctx.logger.error(`[dync] firstLoad:error stateKey=${stateKey}`, err);
+      ctx.logger.error(`[dync] firstLoad:error tableName=${tableName}`, err);
     }
   }
   await ctx.state.setState((syncState) => ({
@@ -1072,10 +1072,10 @@ async function startFirstLoad(ctx) {
   }));
   ctx.logger.debug("[dync] First load completed");
 }
-async function processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstBatch) {
-  let newest = new Date(ctx.state.getState().lastPulled[stateKey] || 0);
-  return ctx.withTransaction("rw", [stateKey, DYNC_STATE_TABLE], async (tables) => {
-    const txTable = tables[stateKey];
+async function processBatchInChunks(ctx, tableName, batch, isEmptyTable, isFirstBatch) {
+  let newest = new Date(ctx.state.getState().lastPulled[tableName] || 0);
+  return ctx.withTransaction("rw", [tableName, DYNC_STATE_TABLE], async (tables) => {
+    const txTable = tables[tableName];
     let tableIsEmpty = isEmptyTable;
     if (isFirstBatch) {
       const count = await txTable.count();
@@ -1110,7 +1110,7 @@ async function processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstB
       ...syncState,
       lastPulled: {
         ...syncState.lastPulled,
-        [stateKey]: newest.toISOString()
+        [tableName]: newest.toISOString()
       }
     }));
     return { inserted, updated };
@@ -1175,23 +1175,23 @@ async function startFirstLoadBatch(ctx) {
         break;
       }
       batchCount++;
-      for (const [stateKey, batch] of Object.entries(result.data)) {
-        if (!ctx.batchSync.syncTables.includes(stateKey)) {
-          ctx.logger.warn(`[dync] firstLoad:batch:unknown-table stateKey=${stateKey}`);
+      for (const [tableName, batch] of Object.entries(result.data)) {
+        if (!ctx.batchSync.syncTables.includes(tableName)) {
+          ctx.logger.warn(`[dync] firstLoad:batch:unknown-table tableName=${tableName}`);
           continue;
         }
         if (!batch?.length) continue;
-        const isFirstBatch = progress[stateKey].inserted === 0 && progress[stateKey].updated === 0;
-        const isEmptyTable = isFirstBatch && await ctx.table(stateKey).count() === 0;
-        const { inserted, updated } = await processBatchInChunks(ctx, stateKey, batch, isEmptyTable, isFirstBatch);
-        progress[stateKey].inserted += inserted;
-        progress[stateKey].updated += updated;
+        const isFirstBatch = progress[tableName].inserted === 0 && progress[tableName].updated === 0;
+        const isEmptyTable = isFirstBatch && await ctx.table(tableName).count() === 0;
+        const { inserted, updated } = await processBatchInChunks(ctx, tableName, batch, isEmptyTable, isFirstBatch);
+        progress[tableName].inserted += inserted;
+        progress[tableName].updated += updated;
         if (ctx.onProgress) {
           ctx.onProgress({
-            table: stateKey,
-            inserted: progress[stateKey].inserted,
-            updated: progress[stateKey].updated,
-            total: progress[stateKey].inserted + progress[stateKey].updated
+            table: tableName,
+            inserted: progress[tableName].inserted,
+            updated: progress[tableName].updated,
+            total: progress[tableName].inserted + progress[tableName].updated
           });
         }
       }
@@ -1203,8 +1203,8 @@ async function startFirstLoadBatch(ctx) {
         break;
       }
     }
-    for (const [stateKey, p] of Object.entries(progress)) {
-      ctx.logger.info(`[dync] firstLoad:batch:done stateKey=${stateKey} inserted=${p.inserted} updated=${p.updated}`);
+    for (const [tableName, p] of Object.entries(progress)) {
+      ctx.logger.info(`[dync] firstLoad:batch:done tableName=${tableName} inserted=${p.inserted} updated=${p.updated}`);
     }
   } catch (err) {
     error = err;
@@ -1574,8 +1574,8 @@ var DyncBase = class {
       this.logger.warn(`[dync] No conflict found for localId: ${localId}`);
       return;
     }
-    await this.withTransaction("rw", [conflict.stateKey, DYNC_STATE_TABLE], async (tables) => {
-      const txTable = tables[conflict.stateKey];
+    await this.withTransaction("rw", [conflict.tableName, DYNC_STATE_TABLE], async (tables) => {
+      const txTable = tables[conflict.tableName];
       if (!keepLocal) {
         const item = await txTable.get(localId);
         if (item) {
@@ -1588,7 +1588,7 @@ var DyncBase = class {
         }
         await this.state.setState((syncState) => ({
           ...syncState,
-          pendingChanges: syncState.pendingChanges.filter((p) => !(p.localId === localId && p.stateKey === conflict.stateKey))
+          pendingChanges: syncState.pendingChanges.filter((p) => !(p.localId === localId && p.tableName === conflict.tableName))
         }));
       }
       await this.state.setState((syncState) => {
@@ -3881,4 +3881,4 @@ export {
   SqliteQueryContext,
   SQLiteAdapter2 as SQLiteAdapter
 };
-//# sourceMappingURL=chunk-LGHOZECP.js.map
+//# sourceMappingURL=chunk-66PSQW4D.js.map