@anfenn/dync 1.0.3 → 1.0.5

package/README.md

@@ -52,10 +52,11 @@ And see how Dync compares to the alternatives [below](#hasnt-this-already-been-d
             ...,
             {
                 // Only add an entry here for tables that should be synced
+                // Pseudocode here, see examples for working code
                 items: {
                     add: (item) => fetch('/api/items'),
                     update: (id, changes) => fetch(`/api/items/${id}`),
-                    remove: (id) => fetch(`/api/items/${id}`),
+                    delete: (id) => fetch(`/api/items/${id}`),
                     list: (since) => fetch(`/api/items?since=${since}`),
                 },
             },
@@ -69,8 +70,21 @@ And see how Dync compares to the alternatives [below](#hasnt-this-already-been-d
             ...,
             {
                 syncTables: ['items'], // Only add tables to this array that should be synced
-                push: (changes) => fetch('/api/sync/push'),
-                pull: (since) => fetch(`/api/sync/pull?since=${since}`),
+                push: async (changes) => {
+                    const res = await fetch('/api/sync/push', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(changes),
+                    });
+                    return res.json();
+                },
+                pull: async (since) => {
+                    const params = new URLSearchParams(
+                        Object.entries(since).map(([table, date]) => [table, date.toISOString()])
+                    );
+                    const res = await fetch(`/api/sync/pull?${params}`);
+                    return res.json();
+                },
             },
         );
         ```
@@ -81,8 +95,8 @@ And see how Dync compares to the alternatives [below](#hasnt-this-already-been-d
 
     ```ts
     const { syncState, db } = useDync();
-    syncState.conflicts; // Record<id, Conflict> Use to show user conflicts
-    db.sync.resolveConflict(id, true);
+    syncState.conflicts; // Record<localId, Conflict>
+    db.sync.resolveConflict(localId, true);
     ```
 
 - Optional first load data download before periodic sync is enabled
@@ -90,10 +104,14 @@ And see how Dync compares to the alternatives [below](#hasnt-this-already-been-d
 - Reactive updates when data changes via `useLiveQuery()` React hook:
 
     ```ts
-    useLiveQuery(async (db) => {
-        const items = await db.items.toArray();
-        setItems(items);
-    }, []);
+    useLiveQuery(
+        async (db) => {
+            const items = await db.items.toArray(); // toArray() executes the query
+            setTodos(items);
+        },
+        [], // Re-run when variables change
+        ['items'], // Re-run when tables change
+    );
     ```
 
 - Sqlite schema migration
@@ -159,11 +177,11 @@ Your server records **must** have these fields. If it does but they're named dif
 
 Dync auto-injects these fields into your local table schema:
 
-| Field        | Description                                                                                                                       |
-| ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
-| `_localId`   | Stable local identifier, never sent to the server. Ideal for React keys. Generate with `createLocalId()` or use any unique value. |
-| `id`         | Unique identifier (any datatype). Can be assigned by client or server.                                                            |
-| `updated_at` | Assigned from the server's `updated_at` after sync. You may set it optimistically, but it's always overwritten on sync.           |
+| Field        | Description                                                                                                                                  |
+| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| `_localId`   | Stable local identifier, never sent to the server. Ideal for React keys. Auto-generated UUID, but can be set manually with any unique value. |
+| `id`         | Unique identifier (any datatype). Can be assigned by client or server.                                                                       |
+| `updated_at` | Assigned from the server's `updated_at` after sync. You may set it optimistically, but it's always overwritten on sync.                      |
 
 Note: `deleted` doesn't exist on the client, as it's removed during sync.
 

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

@@ -24,7 +24,7 @@ var UPDATED_AT = "updated_at";
 var SyncAction = /* @__PURE__ */ ((SyncAction2) => {
   SyncAction2["Create"] = "create";
   SyncAction2["Update"] = "update";
-  SyncAction2["Remove"] = "remove";
+  SyncAction2["Delete"] = "delete";
   return SyncAction2;
 })(SyncAction || {});
 
@@ -56,7 +56,7 @@ function orderFor(a) {
       return 1;
     case "update" /* Update */:
       return 2;
-    case "remove" /* Remove */:
+    case "delete" /* Delete */:
       return 3;
   }
 }
@@ -159,17 +159,17 @@ var StateManager = class {
     const hasChanges = Object.keys(omittedChanges || {}).length > 0;
     const action = change.action;
     if (queueItem) {
-      if (queueItem.action === "remove" /* Remove */) {
+      if (queueItem.action === "delete" /* Delete */) {
         return Promise.resolve();
       }
       queueItem.version += 1;
-      if (action === "remove" /* Remove */) {
-        queueItem.action = "remove" /* Remove */;
+      if (action === "delete" /* Delete */) {
+        queueItem.action = "delete" /* Delete */;
       } else if (hasChanges) {
         queueItem.changes = { ...queueItem.changes, ...omittedChanges };
         queueItem.after = { ...queueItem.after, ...omittedAfter };
       }
-    } else if (action === "remove" /* Remove */ || hasChanges) {
+    } else if (action === "delete" /* Delete */ || hasChanges) {
       next.pendingChanges = [...next.pendingChanges];
       next.pendingChanges.push({
         action,
@@ -467,7 +467,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
       if (record) {
         deletedLocalId = record._localId;
         await state.addPendingChange({
-          action: "remove" /* Remove */,
+          action: "delete" /* Delete */,
           tableName,
           localId: record._localId,
           id: record.id,
@@ -481,7 +481,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
     }
   };
   const wrappedBulkAdd = async (items) => {
-    if (items.length === 0) return;
+    if (items.length === 0) return [];
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const syncedItems = items.map((item) => {
       const localId = item._localId || createLocalId();
@@ -509,7 +509,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
     return result;
   };
   const wrappedBulkPut = async (items) => {
-    if (items.length === 0) return;
+    if (items.length === 0) return [];
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const syncedItems = items.map((item) => {
       const localId = item._localId || createLocalId();
@@ -602,7 +602,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
         if (record) {
           deletedLocalIds.push(record._localId);
           await state.addPendingChange({
-            action: "remove" /* Remove */,
+            action: "delete" /* Delete */,
             tableName,
             localId: record._localId,
             id: record.id,
@@ -626,7 +626,7 @@ function enhanceSyncTable({ table, tableName, withTransaction, state, enhancedTa
         if (record._localId) {
           deletedLocalIds.push(record._localId);
           await state.addPendingChange({
-            action: "remove" /* Remove */,
+            action: "delete" /* Delete */,
             tableName,
             localId: record._localId,
             id: record.id,
@@ -759,20 +759,20 @@ async function processPullData(tableName, serverData, since, ctx) {
   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.tableName === tableName && p.action === "remove" /* Remove */).map((p) => p.id)
+      ctx.state.getState().pendingChanges.filter((p) => p.tableName === tableName && p.action === "delete" /* Delete */).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 tableName=${tableName} id=${remote.id}`);
+        ctx.logger.debug(`[dync] pull:skip-pending-delete 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 tableName=${tableName} id=${remote.id}`);
+          ctx.logger.debug(`[dync] pull:delete tableName=${tableName} id=${remote.id}`);
           hasChanges = true;
         }
         continue;
@@ -800,9 +800,9 @@ async function processPullData(tableName, serverData, since, ctx) {
 }
 
 // src/core/pushOperations.ts
-async function handleRemoveSuccess(change, ctx) {
+async function handleDeleteSuccess(change, ctx) {
   const { tableName, localId, id } = change;
-  ctx.logger.debug(`[dync] push:remove:success tableName=${tableName} localId=${localId} id=${id}`);
+  ctx.logger.debug(`[dync] push:delete:success tableName=${tableName} localId=${localId} id=${id}`);
   await ctx.state.removePendingChange(localId, tableName);
 }
 async function handleUpdateSuccess(change, ctx) {
@@ -823,9 +823,9 @@ async function handleCreateSuccess(change, serverResult, ctx) {
     if (wasChanged && ctx.state.samePendingVersion(tableName, localId, version)) {
       await ctx.state.removePendingChange(localId, tableName);
     } else {
-      const nextAction = wasChanged ? "update" /* Update */ : "remove" /* Remove */;
+      const nextAction = wasChanged ? "update" /* Update */ : "delete" /* Delete */;
       await ctx.state.updatePendingChange(tableName, localId, nextAction, serverResult.id);
-      if (nextAction === "remove" /* Remove */) return;
+      if (nextAction === "delete" /* Delete */) return;
     }
   });
   const finalItem = { ...changes, ...serverResult, _localId: localId };
@@ -850,14 +850,14 @@ async function pushOne(change, ctx) {
   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 */:
+    case "delete" /* Delete */:
       if (!id) {
-        ctx.logger.warn(`[dync] push:remove:no-id tableName=${tableName} localId=${localId}`);
+        ctx.logger.warn(`[dync] push:delete:no-id tableName=${tableName} localId=${localId}`);
         await ctx.state.removePendingChange(localId, tableName);
         return;
       }
-      await api.remove(id);
-      await handleRemoveSuccess(change, ctx);
+      await api.delete(id);
+      await handleDeleteSuccess(change, ctx);
       break;
     case "update" /* Update */: {
       if (ctx.state.hasConflicts(localId)) {
@@ -953,10 +953,10 @@ async function pushAllBatch(ctx) {
     }
     const payloads = changesToPush.map((change) => ({
       table: change.tableName,
-      action: change.action === "create" /* Create */ ? "add" : change.action === "update" /* Update */ ? "update" : "remove",
+      action: change.action === "create" /* Create */ ? "add" : change.action === "update" /* Update */ ? "update" : "delete",
       localId: change.localId,
       id: change.id,
-      data: change.action === "remove" /* Remove */ ? void 0 : change.changes
+      data: change.action === "delete" /* Delete */ ? void 0 : change.changes
     }));
     ctx.logger.debug(`[dync] push:batch:start count=${payloads.length}`);
     const results = await ctx.batchSync.push(payloads);
@@ -994,11 +994,11 @@ async function processBatchPushResult(change, result, ctx) {
     return;
   }
   switch (action) {
-    case "remove" /* Remove */:
-      handleRemoveSuccess(change, ctx);
+    case "delete" /* Delete */:
+      await handleDeleteSuccess(change, ctx);
       break;
     case "update" /* Update */:
-      handleUpdateSuccess(change, ctx);
+      await handleUpdateSuccess(change, ctx);
       break;
     case "create" /* Create */: {
       const serverResult = { id: result.id };
@@ -2015,23 +2015,23 @@ var MemoryTable = class {
     return this.baseBulkAdd(items);
   }
   baseBulkAdd(items) {
-    let lastKey = void 0;
+    const keys = [];
     for (let index = 0; index < items.length; index += 1) {
       const item = items[index];
-      lastKey = this.baseAdd(item);
+      keys.push(this.baseAdd(item));
     }
-    return lastKey;
+    return keys;
   }
   async bulkPut(items) {
     return this.baseBulkPut(items);
   }
   baseBulkPut(items) {
-    let lastKey = void 0;
+    const keys = [];
     for (let index = 0; index < items.length; index += 1) {
       const item = items[index];
-      lastKey = this.basePut(item);
+      keys.push(this.basePut(item));
     }
-    return lastKey;
+    return keys;
   }
   async bulkGet(keys) {
     return Promise.all(keys.map((key) => this.get(key)));
@@ -3251,12 +3251,12 @@ var SQLiteTable = class {
     return this.baseBulkAdd(items);
   }
   async baseBulkAdd(items) {
-    if (!items.length) return void 0;
+    if (!items.length) return [];
     const columns = this.columnNames;
     const columnCount = columns.length;
     const maxParamsPerBatch = 500;
     const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
-    let lastKey = void 0;
+    const allKeys = [];
     for (let i = 0; i < items.length; i += batchSize) {
       const batch = items.slice(i, i + batchSize);
       const records = batch.map((item) => this.prepareRecordForWrite(item));
@@ -3265,25 +3265,25 @@ var SQLiteTable = class {
       const values = [];
       for (const record of records) {
         values.push(...this.extractColumnValues(record));
+        allKeys.push(record[LOCAL_PK]);
       }
       await this.adapter.run(
         `INSERT INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES ${placeholders}`,
         values
       );
-      lastKey = records[records.length - 1][LOCAL_PK];
     }
-    return lastKey;
+    return allKeys;
   }
   async bulkPut(items) {
     return this.baseBulkPut(items);
   }
   async baseBulkPut(items) {
-    if (!items.length) return void 0;
+    if (!items.length) return [];
     const columns = this.columnNames;
     const columnCount = columns.length;
     const maxParamsPerBatch = 500;
     const batchSize = Math.max(1, Math.floor(maxParamsPerBatch / columnCount));
-    let lastKey = void 0;
+    const allKeys = [];
     for (let i = 0; i < items.length; i += batchSize) {
       const batch = items.slice(i, i + batchSize);
       const records = batch.map((item) => this.prepareRecordForWrite(item));
@@ -3292,14 +3292,14 @@ var SQLiteTable = class {
       const values = [];
       for (const record of records) {
         values.push(...this.extractColumnValues(record));
+        allKeys.push(record[LOCAL_PK]);
       }
       await this.adapter.run(
         `INSERT OR REPLACE INTO ${quoteIdentifier(this.name)} (${columns.map((c) => quoteIdentifier(c)).join(", ")}) VALUES ${placeholders}`,
         values
       );
-      lastKey = records[records.length - 1][LOCAL_PK];
     }
-    return lastKey;
+    return allKeys;
   }
   async bulkGet(keys) {
     if (!keys.length) return [];
@@ -3881,4 +3881,4 @@ export {
   SqliteQueryContext,
   SQLiteAdapter2 as SQLiteAdapter
 };
-//# sourceMappingURL=chunk-66PSQW4D.js.map
+//# sourceMappingURL=chunk-YAAFAS64.js.map