cry-synced-db-client 0.1.102 → 0.1.105

package/dist/index.js

@@ -2348,6 +2348,7 @@ var _SyncEngine = class _SyncEngine {
     let sentCount = 0;
     let conflictsResolved = 0;
     const collectionStats = {};
+    this.callOnSyncStart({ calledFrom, initialSync: false });
     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 {
-        this.callbacks.onSync(info);
+        fn(info);
       } catch (err) {
-        console.error("onSync callback failed:", 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.onSyncEnd(info);
+      } catch (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 ? (info) => config.onSyncStart(__spreadProps(__spreadValues({}, info), { initialSync: !this._lastFullSyncDate })) : void 0,
+        onSyncEnd: config.onSyncEnd,
+        onServerSyncStart: config.onServerSyncStart,
+        onServerSyncEnd: config.onServerSyncEnd,
         onConflictResolved: config.onConflictResolved,
         onServerWriteRequest: config.onServerWriteRequest,
         onServerWriteResult: config.onServerWriteResult,
@@ -3538,8 +3581,14 @@ var SyncedDb = class _SyncedDb {
         newlyAllowed.push(name);
       }
     }
-    for (const name of newlyAllowed) {
-      await this.loadCollectionToInMem(name);
+    if (newlyAllowed.length > 0) {
+      const dexieStart = Date.now();
+      let totalItems = 0;
+      this.safeCallback(this.onDexieSyncStart, { calledFrom: "setSyncOnlyTheseCollections", collectionCount: newlyAllowed.length });
+      for (const name of newlyAllowed) {
+        totalItems += await this.loadCollectionToInMem(name);
+      }
+      this.safeCallback(this.onDexieSyncEnd, { calledFrom: "setSyncOnlyTheseCollections", collectionCount: newlyAllowed.length, totalItems, durationMs: Date.now() - dexieStart });
     }
     if (newlyAllowed.length > 0 && this.connectionManager.canSync()) {
       this.sync("setSyncOnlyTheseCollections").catch(() => {
@@ -3575,11 +3624,16 @@ var SyncedDb = class _SyncedDb {
         "BroadcastChannel API is not available. Cross-tab synchronization disabled."
       );
     }
+    await this._loadLastFullSync();
     await this.pendingChanges.recoverPendingWrites();
-    for (const [name] of this.collections) {
-      if (!this.isSyncAllowed(name)) continue;
-      await this.loadCollectionToInMem(name);
-    }
+    const allowedColls = [...this.collections.keys()].filter((n) => this.isSyncAllowed(n));
+    const dexieStart = Date.now();
+    let totalItems = 0;
+    this.safeCallback(this.onDexieSyncStart, { calledFrom: "init", collectionCount: allowedColls.length });
+    for (const name of allowedColls) {
+      totalItems += await this.loadCollectionToInMem(name);
+    }
+    this.safeCallback(this.onDexieSyncEnd, { calledFrom: "init", collectionCount: allowedColls.length, totalItems, durationMs: Date.now() - dexieStart });
     this.leaderElection.init();
     this.crossTabSync.init();
     (_a = this.wakeSync) == null ? void 0 : _a.init();
@@ -3624,6 +3678,40 @@ var SyncedDb = class _SyncedDb {
     }
     this.initialized = true;
   }
+  /**
+   * Flush all debounced pending writes to Dexie.
+   * Resolves when all data is persisted to IndexedDB.
+   * Does NOT upload to server — call sync() for that.
+   */
+  async flush() {
+    await this.pendingChanges.flushAll();
+  }
+  /**
+   * Returns when all collections were last successfully synced
+   * from the server, or undefined if never.
+   * Value is persisted in Dexie and survives page reload.
+   * Only set when syncOnlyCollections is null (all collections active).
+   * Cleared on dropDatabase.
+   */
+  lastSuccessfulServerSync() {
+    return this._lastFullSyncDate;
+  }
+  /** @internal Update after successful full sync */
+  async _setLastFullSync(date) {
+    this._lastFullSyncDate = date;
+    await this.dexieDb.setSyncMeta("__lastFullSync", date.toISOString());
+  }
+  /** @internal Load cached value from Dexie */
+  async _loadLastFullSync() {
+    const meta = await this.dexieDb.getSyncMeta("__lastFullSync");
+    if (meta == null ? void 0 : meta.lastSyncTs) {
+      this._lastFullSyncDate = new Date(meta.lastSyncTs);
+    }
+  }
+  /** @internal Clear on dropDatabase */
+  _clearLastFullSync() {
+    this._lastFullSyncDate = void 0;
+  }
   async close() {
     var _a, _b;
     this.leaderElection.setClosing(true);
@@ -4125,6 +4213,10 @@ var SyncedDb = class _SyncedDb {
     this.syncing = true;
     try {
       await this.syncEngine.sync(calledFrom);
+      if (!this.syncOnlyCollections) {
+        this._setLastFullSync(/* @__PURE__ */ new Date()).catch(() => {
+        });
+      }
     } finally {
       this.syncing = false;
       this.syncLock = false;
@@ -4266,6 +4358,7 @@ var SyncedDb = class _SyncedDb {
       await this.dexieDb.clearDirtyChanges(collectionName);
     }
     this.syncMetaCache.clear();
+    this._clearLastFullSync();
   }
   // ==================== Object Metadata ====================
   getObjectMetadata(collection, _id) {
@@ -4330,6 +4423,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) => {
@@ -4345,6 +4448,7 @@ var SyncedDb = class _SyncedDb {
     if (meta) {
       this.syncMetaCache.set(name, meta);
     }
+    return allItems.length;
   }
   assertCollection(name) {
     if (!this.collections.has(name)) {

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?;
@@ -65,6 +70,27 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     simulateExternalBroadcast(payload: MetaUpdateBroadcast): void;
     init(): Promise<void>;
+    /**
+     * Flush all debounced pending writes to Dexie.
+     * Resolves when all data is persisted to IndexedDB.
+     * Does NOT upload to server — call sync() for that.
+     */
+    flush(): Promise<void>;
+    private _lastFullSyncDate?;
+    /**
+     * Returns when all collections were last successfully synced
+     * from the server, or undefined if never.
+     * Value is persisted in Dexie and survives page reload.
+     * Only set when syncOnlyCollections is null (all collections active).
+     * Cleared on dropDatabase.
+     */
+    lastSuccessfulServerSync(): Date | undefined;
+    /** @internal Update after successful full sync */
+    _setLastFullSync(date: Date): Promise<void>;
+    /** @internal Load cached value from Dexie */
+    private _loadLastFullSync;
+    /** @internal Clear on dropDatabase */
+    private _clearLastFullSync;
     close(): Promise<void>;
     isOnline(): boolean;
     forceOffline(forced: boolean): void;
@@ -141,6 +167,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,22 @@ export interface I_InMemManager {
     deleteObjectsMetadata(collection: string, ids: Id[]): void;
 }
 export interface SyncEngineCallbacks {
-    onSync?: (info: SyncInfo) => void;
+    onSyncStart?: (info: {
+        calledFrom?: string;
+        initialSync: boolean;
+    }) => 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_SyncedDb.d.ts

@@ -293,8 +293,38 @@ 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. initialSync=true if no full sync has completed yet. */
+    onSyncStart?: (info: {
+        calledFrom?: string;
+        initialSync: boolean;
+    }) => 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;
+        totalItems: 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.102",
+  "version": "0.1.105",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",