cry-synced-db-client 0.1.33 → 0.1.35

package/dist/index.js

@@ -275,7 +275,7 @@ class SyncedDb {
   onServerWriteRequest;
   onServerWriteResult;
   onFindNewerManyCall;
-  onFindNewerCall;
+  onFindNewerManyResult;
   onDexieWriteRequest;
   onDexieWriteResult;
   onLocalstorageWriteResult;
@@ -326,7 +326,7 @@ class SyncedDb {
     this.onServerWriteRequest = config.onServerWriteRequest;
     this.onServerWriteResult = config.onServerWriteResult;
     this.onFindNewerManyCall = config.onFindNewerManyCall;
-    this.onFindNewerCall = config.onFindNewerCall;
+    this.onFindNewerManyResult = config.onFindNewerManyResult;
     this.onDexieWriteRequest = config.onDexieWriteRequest;
     this.onDexieWriteResult = config.onDexieWriteResult;
     this.onLocalstorageWriteResult = config.onLocalstorageWriteResult;
@@ -911,7 +911,40 @@ class SyncedDb {
           console.error("onFindNewerManyCall callback failed:", err);
         }
       }
-      const allServerData = await this.withSyncTimeout(this.restInterface.findNewerMany(syncSpecs), "findNewerMany");
+      const findNewerManyStartTime = Date.now();
+      let allServerData;
+      try {
+        allServerData = await this.withSyncTimeout(this.restInterface.findNewerMany(syncSpecs), "findNewerMany");
+        if (this.onFindNewerManyResult) {
+          try {
+            this.onFindNewerManyResult({
+              specs: syncSpecs,
+              results: allServerData,
+              durationMs: Date.now() - findNewerManyStartTime,
+              success: true,
+              calledFrom
+            });
+          } catch (err) {
+            console.error("onFindNewerManyResult callback failed:", err);
+          }
+        }
+      } catch (err) {
+        if (this.onFindNewerManyResult) {
+          try {
+            this.onFindNewerManyResult({
+              specs: syncSpecs,
+              results: {},
+              durationMs: Date.now() - findNewerManyStartTime,
+              success: false,
+              error: err instanceof Error ? err : new Error(String(err)),
+              calledFrom
+            });
+          } catch (callbackErr) {
+            console.error("onFindNewerManyResult callback failed:", callbackErr);
+          }
+        }
+        throw err;
+      }
       for (const [collectionName, config] of this.collections) {
         const serverData = allServerData[collectionName] || [];
         receivedCount += serverData.length;
@@ -1278,27 +1311,6 @@ class SyncedDb {
       }
     }
   }
-  async syncSingleCollection(collectionName) {
-    const config = this.collections.get(collectionName);
-    if (!config)
-      return;
-    const meta = await this.dexieDb.getSyncMeta(collectionName);
-    const fromTimestamp = meta?.lastSyncTs || 0;
-    if (this.onFindNewerCall) {
-      try {
-        this.onFindNewerCall({
-          collection: collectionName,
-          fromTimestamp,
-          query: config.query,
-          timestamp: new Date
-        });
-      } catch (err) {
-        console.error("onFindNewerCall callback failed:", err);
-      }
-    }
-    const serverData = await this.restInterface.findNewer(collectionName, fromTimestamp, config.query, { returnDeleted: true });
-    await this.processIncomingServerData(collectionName, config, serverData);
-  }
   async processIncomingServerData(collectionName, config, serverData) {
     let maxTs;
     let conflictsResolved = 0;
@@ -1583,7 +1595,7 @@ class SyncedDb {
       case "insert": {
         const serverItem = payload.data;
         if (serverItem) {
-          await this.handleServerItemUpdate(collectionName, serverItem);
+          await this.handleServerItemInsert(collectionName, serverItem);
           if (serverItem._ts) {
             await this.broadcastMetaUpdate(collectionName, serverItem._ts);
           }
@@ -1595,15 +1607,14 @@ class SyncedDb {
         if (deltaData && deltaData._id) {
           const localItem = await this.dexieDb.getById(collectionName, deltaData._id);
           if (localItem) {
-            await this.handleServerItemUpdate(collectionName, deltaData);
+            await this.handleServerItemUpdate(collectionName, localItem, deltaData);
             if (deltaData._ts) {
               await this.broadcastMetaUpdate(collectionName, deltaData._ts);
             }
           } else {
-            const items = await this.restInterface.findNewer(collectionName, 0, { _id: deltaData._id });
-            const fullItem = items[0];
+            const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
             if (fullItem) {
-              await this.handleServerItemUpdate(collectionName, fullItem);
+              await this.handleServerItemInsert(collectionName, fullItem);
               if (fullItem._ts) {
                 await this.broadcastMetaUpdate(collectionName, fullItem._ts);
               }
@@ -1623,19 +1634,18 @@ class SyncedDb {
           if (item.operation === "insert") {
             const serverItem = item.data;
             if (serverItem) {
-              await this.handleServerItemUpdate(collectionName, serverItem);
+              await this.handleServerItemInsert(collectionName, serverItem);
             }
           } else if (item.operation === "update") {
             const deltaData = item.data;
             if (deltaData && deltaData._id) {
               const localItem = await this.dexieDb.getById(collectionName, deltaData._id);
               if (localItem) {
-                await this.handleServerItemUpdate(collectionName, deltaData);
+                await this.handleServerItemUpdate(collectionName, localItem, deltaData);
               } else {
-                const items = await this.restInterface.findNewer(collectionName, 0, { _id: deltaData._id });
-                const fullItem = items[0];
+                const fullItem = await this.restInterface.findById(collectionName, deltaData._id);
                 if (fullItem) {
-                  await this.handleServerItemUpdate(collectionName, fullItem);
+                  await this.handleServerItemInsert(collectionName, fullItem);
                 }
               }
             }
@@ -1651,61 +1661,69 @@ class SyncedDb {
       }
     }
   }
-  async handleServerItemUpdate(collectionName, serverItem) {
+  async handleServerItemInsert(collectionName, serverItem) {
     const localItem = await this.dexieDb.getById(collectionName, serverItem._id);
-    const pendingKey = this.getPendingKey(collectionName, serverItem._id);
+    if (localItem) {
+      await this.dexieDb.save(collectionName, serverItem._id, {
+        _rev: serverItem._rev,
+        _ts: serverItem._ts,
+        _dirty: false
+      });
+    } else {
+      await this.dexieDb.insert(collectionName, {
+        ...serverItem,
+        _dirty: false
+      });
+      if (!serverItem._deleted) {
+        this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
+      }
+    }
+  }
+  async handleServerItemUpdate(collectionName, localItem, serverDelta) {
+    const isLoopback = serverDelta._lastUpdaterId === this.updaterId && serverDelta._rev !== undefined && localItem._rev !== undefined && serverDelta._rev === localItem._rev + 1;
+    if (isLoopback) {
+      await this.dexieDb.save(collectionName, serverDelta._id, {
+        _rev: serverDelta._rev,
+        _ts: serverDelta._ts,
+        _dirty: false
+      });
+      return;
+    }
+    const pendingKey = this.getPendingKey(collectionName, serverDelta._id);
     const pendingChange = this.pendingChanges.get(pendingKey);
-    const hasPendingChanges = !!pendingChange;
-    if (hasPendingChanges) {
-      const currentMemItem = this.inMemDb.getById(collectionName, serverItem._id);
+    if (pendingChange) {
+      const currentMemItem = this.inMemDb.getById(collectionName, serverDelta._id);
       if (currentMemItem) {
-        const merged = this.mergeLocalWithDelta(currentMemItem, serverItem);
+        const merged = this.mergeLocalWithDelta(currentMemItem, serverDelta);
         if (!merged._deleted) {
-          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(merged));
+          this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
         }
         pendingChange.data = {
           ...pendingChange.data,
-          ...this.getNewFieldsFromServer(currentMemItem, serverItem)
+          ...this.getNewFieldsFromServer(currentMemItem, serverDelta)
         };
       }
       return;
     }
-    if (localItem) {
-      if (serverItem._lastUpdaterId === this.updaterId && serverItem._rev !== undefined && localItem._rev !== undefined && serverItem._rev === localItem._rev + 1) {
-        await this.dexieDb.save(collectionName, serverItem._id, {
-          _rev: serverItem._rev,
-          _ts: serverItem._ts,
-          _dirty: false
-        });
-        return;
-      }
-      if (localItem._dirty) {
-        const merged = this.mergeLocalWithDelta(localItem, serverItem);
-        await this.dexieDb.save(collectionName, serverItem._id, {
-          ...merged,
-          _dirty: true
-        });
-        if (!merged._deleted) {
-          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(merged));
-        }
-      } else {
-        await this.dexieDb.save(collectionName, serverItem._id, {
-          ...serverItem,
-          _dirty: false
-        });
-        if (!serverItem._deleted) {
-          this.inMemDb.save(collectionName, serverItem._id, this.stripLocalFields(serverItem));
-        } else {
-          this.inMemDb.deleteOne(collectionName, serverItem._id);
-        }
+    if (localItem._dirty) {
+      const merged = this.mergeLocalWithDelta(localItem, serverDelta);
+      await this.dexieDb.save(collectionName, serverDelta._id, {
+        ...merged,
+        _dirty: true
+      });
+      if (!merged._deleted) {
+        this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
       }
     } else {
-      await this.dexieDb.insert(collectionName, {
-        ...serverItem,
+      const merged = this.mergeLocalWithDelta(localItem, serverDelta);
+      await this.dexieDb.save(collectionName, serverDelta._id, {
+        ...merged,
         _dirty: false
       });
-      if (!serverItem._deleted) {
-        this.inMemDb.insert(collectionName, this.stripLocalFields(serverItem));
+      if (!merged._deleted) {
+        this.inMemDb.save(collectionName, serverDelta._id, this.stripLocalFields(merged));
+      } else {
+        this.inMemDb.deleteOne(collectionName, serverDelta._id);
       }
     }
   }
@@ -4230,6 +4248,14 @@ class RestProxy {
       return false;
     }
   }
+  async findById(collection, id) {
+    return await this.restCall("findById", { collection, id });
+  }
+  async findByIds(collection, ids) {
+    if (ids.length === 0)
+      return [];
+    return await this.restCall("findByIds", { collection, ids });
+  }
   async findNewer(collection, timestamp, query, opts) {
     return await this.restCall("findNewer", {
       collection,

package/dist/{db → src/db}/RestProxy.d.ts

@@ -1,5 +1,6 @@
 import type { AggregateOptions, Timestamp } from "mongodb";
 import type { I_RestInterface, QuerySpec, QueryOpts, GetNewerSpec, BatchSpec, CollectionUpdateRequest, CollectionUpdateResult } from "../types/I_RestInterface";
+import type { Id } from "../types/DbEntity";
 /** Progress callback for tracking upload progress */
 export type ProgressCallback = (sentBytes: number, totalBytes: number) => void;
 export interface RestProxyConfig {
@@ -96,6 +97,8 @@ export declare class RestProxy implements I_RestInterface {
     /** Combine multiple abort signals into one */
     private combineSignals;
     ping(): Promise<boolean>;
+    findById<T>(collection: string, id: Id): Promise<T | null>;
+    findByIds<T>(collection: string, ids: Id[]): Promise<T[]>;
     findNewer<T>(collection: string, timestamp: Timestamp | number | string | Date, query?: QuerySpec<T>, opts?: QueryOpts): Promise<T[]>;
     findNewerMany<T>(spec?: GetNewerSpec<T>[]): Promise<Record<string, any[]>>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;

package/dist/{db → src/db}/SyncedDb.d.ts

@@ -22,7 +22,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private onServerWriteRequest?;
     private onServerWriteResult?;
     private onFindNewerManyCall?;
-    private onFindNewerCall?;
+    private onFindNewerManyResult?;
     private onDexieWriteRequest?;
     private onDexieWriteResult?;
     private onLocalstorageWriteResult?;
@@ -169,11 +169,6 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private uploadDirtyItemsForCollection;
     private recoverPendingWrites;
-    /**
-     * Sinhronizira eno samo kolekcijo - uporabi se pri handleServerUpdate za updateMany/deleteMany
-     * Samo obdela prihajajoče podatke, ne pošilja dirty objektov nazaj
-     */
-    private syncSingleCollection;
     /**
      * Obdela prihajajoče podatke s serverja - razreši konflikte in shrani v Dexie/inMem
      * Ne pošilja dirty objektov na server (to naredi uploadDirtyItems)
@@ -199,6 +194,16 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private handleCrossTabMetaUpdate;
     private handleServerUpdate;
+    /**
+     * Handle server insert notification.
+     * Insert notifications contain full object data.
+     */
+    private handleServerItemInsert;
+    /**
+     * Handle server update notification (delta).
+     * Update notifications contain only changed fields.
+     * Caller must provide the existing local item.
+     */
     private handleServerItemUpdate;
     private getNewFieldsFromServer;
     /**

package/dist/src/debug/insertOneNote.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/{types → src/types}/I_RestInterface.d.ts

@@ -74,6 +74,10 @@ export type CollectionUpdateResult = {
 export interface I_RestInterface {
     /** Preveri povezljivost s serverjem - vrne true če je server dosegljiv */
     ping(): Promise<boolean>;
+    /** Fetch a single item by ID, returns null if not found */
+    findById<T>(collection: string, id: Id): Promise<T | null>;
+    /** Fetch multiple items by IDs */
+    findByIds<T>(collection: string, ids: Id[]): Promise<T[]>;
     findNewer<T>(collection: string, timestamp: Timestamp | number | string | Date, query?: QuerySpec<T>, opts?: QueryOpts): Promise<T[]>;
     findNewerMany<T>(spec?: GetNewerSpec<T>[]): Promise<Record<string, any[]>>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;

package/dist/{types → src/types}/I_SyncedDb.d.ts

@@ -1,4 +1,4 @@
-import type { AggregateOptions, Timestamp } from "mongodb";
+import type { AggregateOptions } from "mongodb";
 import type { Id, DbEntity, LocalDbEntity } from "./DbEntity";
 import type { QuerySpec, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface, CollectionUpdateRequest, CollectionUpdateResult, GetNewerSpec } from "./I_RestInterface";
 import type { I_DexieDb } from "./I_DexieDb";
@@ -72,17 +72,21 @@ export interface FindNewerManyCallInfo {
     calledFrom?: string;
 }
 /**
- * Callback payload for findNewer calls
+ * Callback payload for findNewerMany results
  */
-export interface FindNewerCallInfo {
-    /** Collection being queried */
-    collection: string;
-    /** Timestamp from which to fetch */
-    fromTimestamp: Timestamp | number | string | Date;
-    /** Query filter if any */
-    query?: QuerySpec<any>;
-    /** Timestamp when request started */
-    timestamp: Date;
+export interface FindNewerManyResultInfo {
+    /** Specs that were requested */
+    specs: GetNewerSpec<any>[];
+    /** Results per collection (collection name -> items) */
+    results: Record<string, any[]>;
+    /** Duration in ms */
+    durationMs: number;
+    /** Whether the request succeeded */
+    success: boolean;
+    /** Error if failed */
+    error?: Error;
+    /** Where sync was called from (for debugging) */
+    calledFrom?: string;
 }
 /**
  * Callback payload for Dexie write requests (before writing)
@@ -243,8 +247,8 @@ export interface SyncedDbConfig {
     onServerWriteResult?: (info: ServerWriteResultInfo) => void;
     /** Callback when findNewerMany is called */
     onFindNewerManyCall?: (info: FindNewerManyCallInfo) => void;
-    /** Callback when findNewer is called */
-    onFindNewerCall?: (info: FindNewerCallInfo) => void;
+    /** Callback when findNewerMany completes */
+    onFindNewerManyResult?: (info: FindNewerManyResultInfo) => void;
     /** Callback before writing to Dexie */
     onDexieWriteRequest?: (info: DexieWriteRequestInfo) => void;
     /** Callback after writing to Dexie */

package/dist/{types → src/types}/index.d.ts

@@ -4,5 +4,5 @@ export type { Obj, QuerySpec, Projection, QueryOpts, KeyOf, InsertKeyOf, InsertS
 export type { I_InMemDb as InMemDb } from "./I_InMemDb";
 export type { I_DexieDb as DexieDb, SyncMeta } from "./I_DexieDb";
 export type { I_ServerUpdateNotifier as ServerUpdateNotifier, ServerUpdateCallback, ServerUpdateNotifierCallbacks } from "./I_ServerUpdateNotifier";
-export type { I_SyncedDb as SyncedDb, SyncedDbConfig, CollectionConfig, SyncInfo, ServerWriteRequestInfo, ServerWriteResultInfo, FindNewerManyCallInfo, FindNewerCallInfo, DexieWriteRequestInfo, DexieWriteResultInfo, LocalstorageWriteResultInfo, WsNotificationInfo, InfrastructureErrorType, InfrastructureErrorInfo, ConflictSource, ConflictResolutionReport, } from "./I_SyncedDb";
+export type { I_SyncedDb as SyncedDb, SyncedDbConfig, CollectionConfig, SyncInfo, ServerWriteRequestInfo, ServerWriteResultInfo, FindNewerManyCallInfo, FindNewerManyResultInfo, DexieWriteRequestInfo, DexieWriteResultInfo, LocalstorageWriteResultInfo, WsNotificationInfo, InfrastructureErrorType, InfrastructureErrorInfo, ConflictSource, ConflictResolutionReport, } from "./I_SyncedDb";
 export type { CollectionConfig as CollectionConfigFull } from "./CollectionConfig";

package/dist/test/testConstants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Test constants for faster test execution
+ */
+/** Debounce time for tests (ms) - much shorter than production default of 1000ms */
+export declare const TEST_DEBOUNCE_MS = 5;
+/** Helper to get wait time for debounce (1.2x debounce time) */
+export declare const getDebounceWaitMs: (debounceMs?: number) => number;
+/** REST endpoint for real-life proxy tests */
+export declare const REST_ENDPOINT = "http://localhost:3002";
+/** Test tenant name for RestProxy tests */
+export declare const TEST_TENANT = "test";
+/** API key for RestProxy tests */
+export declare const API_KEY = "1234";
+/** WebSocket URL for ebus-proxy tests */
+export declare const EBUS_PROXY_WS_URL = "ws://localhost:3033";
+/** API key for ebus-proxy tests */
+export declare const EBUS_PROXY_API_KEY = "123";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",