cry-synced-db-client 0.1.101 → 0.1.104

package/dist/index.js

@@ -2348,6 +2348,7 @@ var _SyncEngine = class _SyncEngine {
     let sentCount = 0;
     let conflictsResolved = 0;
     const collectionStats = {};
+    this.callOnSyncStart({ calledFrom });
     try {
       this.deps.cancelRestUploadTimer();
       await this.deps.awaitRestUpload();
@@ -2373,6 +2374,7 @@ var _SyncEngine = class _SyncEngine {
         configMap.set(collectionName, config);
       }
       this.callOnFindNewerManyCall(syncSpecs, calledFrom);
+      this.callbackSafe(this.callbacks.onServerSyncStart, { calledFrom, collectionCount: syncSpecs.length });
       const findNewerManyStartTime = Date.now();
       const collectionState = /* @__PURE__ */ new Map();
       for (const [name] of configMap) {
@@ -2414,8 +2416,22 @@ var _SyncEngine = class _SyncEngine {
           };
         }
         this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, true, calledFrom);
+        this.callbackSafe(this.callbacks.onServerSyncEnd, {
+          calledFrom,
+          collectionCount: syncSpecs.length,
+          receivedCount,
+          durationMs: Date.now() - findNewerManyStartTime,
+          success: true
+        });
       } catch (err) {
         this.callOnFindNewerManyResult(syncSpecs, {}, findNewerManyStartTime, false, calledFrom, err);
+        this.callbackSafe(this.callbacks.onServerSyncEnd, {
+          calledFrom,
+          collectionCount: syncSpecs.length,
+          receivedCount,
+          durationMs: Date.now() - findNewerManyStartTime,
+          success: false
+        });
         throw err;
       }
       const uploadStats = await this.uploadDirtyItems(calledFrom);
@@ -2430,7 +2446,7 @@ var _SyncEngine = class _SyncEngine {
           };
         }
       }
-      this.callOnSync({
+      this.callOnSyncEnd({
         durationMs: Date.now() - startTime,
         receivedCount,
         sentCount,
@@ -2443,7 +2459,7 @@ var _SyncEngine = class _SyncEngine {
       const reason = err instanceof Error ? err.message : String(err);
       console.error("Sync failed, going offline:", err);
       this.deps.goOffline(`Sync failed: ${reason}`);
-      this.callOnSync({
+      this.callOnSyncEnd({
         durationMs: Date.now() - startTime,
         receivedCount,
         sentCount,
@@ -2798,12 +2814,31 @@ var _SyncEngine = class _SyncEngine {
   // ============================================================
   // Callback Wrappers
   // ============================================================
-  callOnSync(info) {
-    if (this.callbacks.onSync) {
+  /** Safe callback invocation — swallows errors */
+  callbackSafe(fn, info) {
+    if (fn) {
+      try {
+        fn(info);
+      } catch (err) {
+        console.error("Callback failed:", err);
+      }
+    }
+  }
+  callOnSyncStart(info) {
+    if (this.callbacks.onSyncStart) {
+      try {
+        this.callbacks.onSyncStart(info);
+      } catch (err) {
+        console.error("onSyncStart callback failed:", err);
+      }
+    }
+  }
+  callOnSyncEnd(info) {
+    if (this.callbacks.onSyncEnd) {
       try {
-        this.callbacks.onSync(info);
+        this.callbacks.onSyncEnd(info);
       } catch (err) {
-        console.error("onSync callback failed:", err);
+        console.error("onSyncEnd callback failed:", err);
       }
     }
   }
@@ -3321,7 +3356,12 @@ var SyncedDb = class _SyncedDb {
     const windowId = (_a = config._testWindowId) != null ? _a : this.getOrCreateWindowId();
     this.defaultReturnDeleted = (_b = config.returnDeleted) != null ? _b : false;
     this.defaultReturnArchived = (_c = config.returnArchived) != null ? _c : false;
-    this.onSync = config.onSync;
+    this.onSyncStart = config.onSyncStart;
+    this.onSyncEnd = config.onSyncEnd;
+    this.onDexieSyncStart = config.onDexieSyncStart;
+    this.onDexieSyncEnd = config.onDexieSyncEnd;
+    this.onServerSyncStart = config.onServerSyncStart;
+    this.onServerSyncEnd = config.onServerSyncEnd;
     this.onConflictResolved = config.onConflictResolved;
     this.onWsNotification = config.onWsNotification;
     this.onCrossTabSync = config.onCrossTabSync;
@@ -3435,7 +3475,10 @@ var SyncedDb = class _SyncedDb {
       dexieDb: this.dexieDb,
       restInterface: this.restInterface,
       callbacks: {
-        onSync: config.onSync,
+        onSyncStart: config.onSyncStart,
+        onSyncEnd: config.onSyncEnd,
+        onServerSyncStart: config.onServerSyncStart,
+        onServerSyncEnd: config.onServerSyncEnd,
         onConflictResolved: config.onConflictResolved,
         onServerWriteRequest: config.onServerWriteRequest,
         onServerWriteResult: config.onServerWriteResult,
@@ -3538,8 +3581,13 @@ var SyncedDb = class _SyncedDb {
         newlyAllowed.push(name);
       }
     }
-    for (const name of newlyAllowed) {
-      await this.loadCollectionToInMem(name);
+    if (newlyAllowed.length > 0) {
+      const dexieStart = Date.now();
+      this.safeCallback(this.onDexieSyncStart, { calledFrom: "setSyncOnlyTheseCollections", collectionCount: newlyAllowed.length });
+      for (const name of newlyAllowed) {
+        await this.loadCollectionToInMem(name);
+      }
+      this.safeCallback(this.onDexieSyncEnd, { calledFrom: "setSyncOnlyTheseCollections", collectionCount: newlyAllowed.length, durationMs: Date.now() - dexieStart });
     }
     if (newlyAllowed.length > 0 && this.connectionManager.canSync()) {
       this.sync("setSyncOnlyTheseCollections").catch(() => {
@@ -3576,10 +3624,13 @@ var SyncedDb = class _SyncedDb {
       );
     }
     await this.pendingChanges.recoverPendingWrites();
-    for (const [name] of this.collections) {
-      if (!this.isSyncAllowed(name)) continue;
+    const allowedColls = [...this.collections.keys()].filter((n) => this.isSyncAllowed(n));
+    const dexieStart = Date.now();
+    this.safeCallback(this.onDexieSyncStart, { calledFrom: "init", collectionCount: allowedColls.length });
+    for (const name of allowedColls) {
       await this.loadCollectionToInMem(name);
     }
+    this.safeCallback(this.onDexieSyncEnd, { calledFrom: "init", collectionCount: allowedColls.length, durationMs: Date.now() - dexieStart });
     this.leaderElection.init();
     this.crossTabSync.init();
     (_a = this.wakeSync) == null ? void 0 : _a.init();
@@ -4057,7 +4108,7 @@ var SyncedDb = class _SyncedDb {
       return null;
     }
     await this.connectionManager.withRestTimeout(
-      this.restInterface.deleteOne(collection, { _id: id }),
+      this.restInterface.call("hardDeleteOne", { collection, query: { _id: id } }),
       "hardDeleteOne"
     );
     await this.dexieDb.deleteOne(collection, id);
@@ -4093,7 +4144,7 @@ var SyncedDb = class _SyncedDb {
           if (!item) break;
           try {
             await this.connectionManager.withRestTimeout(
-              this.restInterface.deleteOne(collection, { _id: item.id }),
+              this.restInterface.call("hardDeleteOne", { collection, query: { _id: item.id } }),
               "hardDelete"
             );
             await this.dexieDb.deleteOne(collection, item.id);
@@ -4330,6 +4381,16 @@ var SyncedDb = class _SyncedDb {
    * Accumulates all items first, then does a single initCollection
    * call to minimize reactive update overhead.
    */
+  /** Safe callback invocation — swallows errors */
+  safeCallback(fn, info) {
+    if (fn) {
+      try {
+        fn(info);
+      } catch (err) {
+        console.error("Callback failed:", err);
+      }
+    }
+  }
   async loadCollectionToInMem(name) {
     const allItems = [];
     await this.dexieDb.forEachBatch(name, 2e3, async (chunk) => {

package/dist/src/db/SyncedDb.d.ts

@@ -37,7 +37,12 @@ export declare class SyncedDb implements I_SyncedDb {
     private beforeUnloadHandler?;
     private readonly defaultReturnDeleted;
     private readonly defaultReturnArchived;
-    private readonly onSync?;
+    private readonly onSyncStart?;
+    private readonly onSyncEnd?;
+    private readonly onDexieSyncStart?;
+    private readonly onDexieSyncEnd?;
+    private readonly onServerSyncStart?;
+    private readonly onServerSyncEnd?;
     private readonly onConflictResolved?;
     private readonly onWsNotification?;
     private readonly onCrossTabSync?;
@@ -141,6 +146,8 @@ export declare class SyncedDb implements I_SyncedDb {
      * Accumulates all items first, then does a single initCollection
      * call to minimize reactive update overhead.
      */
+    /** Safe callback invocation — swallows errors */
+    private safeCallback;
     private loadCollectionToInMem;
     private assertCollection;
     /** Stringify an Id parameter (ObjectId → hex string). */

package/dist/src/db/sync/SyncEngine.d.ts

@@ -43,7 +43,10 @@ export declare class SyncEngine implements I_SyncEngine {
     private processIncomingServerData;
     private compareTimestamps;
     private resolveCollectionConflict;
-    private callOnSync;
+    /** Safe callback invocation — swallows errors */
+    private callbackSafe;
+    private callOnSyncStart;
+    private callOnSyncEnd;
     private callOnFindNewerManyCall;
     private callOnFindNewerManyResult;
     private callOnServerWriteRequest;

package/dist/src/db/types/managers.d.ts

@@ -208,7 +208,21 @@ export interface I_InMemManager {
     deleteObjectsMetadata(collection: string, ids: Id[]): void;
 }
 export interface SyncEngineCallbacks {
-    onSync?: (info: SyncInfo) => void;
+    onSyncStart?: (info: {
+        calledFrom?: string;
+    }) => void;
+    onSyncEnd?: (info: SyncInfo) => void;
+    onServerSyncStart?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+    }) => void;
+    onServerSyncEnd?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+        receivedCount: number;
+        durationMs: number;
+        success: boolean;
+    }) => void;
     onConflictResolved?: (report: ConflictResolutionReport) => void;
     onServerWriteRequest?: (info: ServerWriteRequestInfo) => void;
     onServerWriteResult?: (info: ServerWriteResultInfo) => void;

package/dist/src/types/I_RestInterface.d.ts

@@ -1,6 +1,7 @@
 import type { Timestamp, Document, SchemaMember, CollationOptions, ReadPreference, FindOneAndUpdateOptions, AggregateOptions } from "mongodb";
 import type { Types } from "cry-db";
 import type { Id } from "./DbEntity";
+import type { Rdb2CallMap, Rdb2Operation } from "./Rdb2CallMap";
 export type CollectionUpdateResult = Types.CollectionUpdateResult;
 export type Obj = {
     [key: string]: any;
@@ -79,4 +80,9 @@ export interface I_RestInterface {
     upsertBatch<T>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
     /** Pošlje batch update/delete za več kolekcij naenkrat */
     updateCollections<T>(collectionsBatches: CollectionUpdateRequest<T>[]): Promise<CollectionUpdateResult[]>;
+    /** Generic rdb2 operation call for operations beyond the minimal sync interface */
+    call<K extends Rdb2Operation, T = unknown>(operation: K, payload?: Rdb2CallMap[K], options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<T>;
 }

package/dist/src/types/I_SyncedDb.d.ts

@@ -293,8 +293,36 @@ export interface SyncedDbConfig {
     debounceRestWritesMs?: number;
     /** Callback ki se pokliče, ko SyncedDb sam preide v offline stanje (npr. ob sync napaki) */
     onForcedOffline?: (reason: string) => void;
-    /** Callback za debugging/logging - pokliče se po vsaki sinhronizaciji */
-    onSync?: (info: SyncInfo) => void;
+    /** Callback at the start of each sync cycle */
+    onSyncStart?: (info: {
+        calledFrom?: string;
+    }) => void;
+    /** Callback at the end of each sync cycle */
+    onSyncEnd?: (info: SyncInfo) => void;
+    /** Callback when Dexie→inMem loading starts (loadCollectionToInMem) */
+    onDexieSyncStart?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+    }) => void;
+    /** Callback when Dexie→inMem loading ends */
+    onDexieSyncEnd?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+        durationMs: number;
+    }) => void;
+    /** Callback when server download starts (findNewerManyStream) */
+    onServerSyncStart?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+    }) => void;
+    /** Callback when server download ends */
+    onServerSyncEnd?: (info: {
+        calledFrom?: string;
+        collectionCount: number;
+        receivedCount: number;
+        durationMs: number;
+        success: boolean;
+    }) => void;
     /** Callback when a sync conflict is resolved (local vs server data) */
     onConflictResolved?: (report: ConflictResolutionReport) => void;
     /** Callback before sending data to server (updateCollections) */

package/package.json

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