cry-synced-db-client 0.1.104 → 0.1.106

package/dist/index.js

@@ -2348,7 +2348,7 @@ var _SyncEngine = class _SyncEngine {
     let sentCount = 0;
     let conflictsResolved = 0;
     const collectionStats = {};
-    this.callOnSyncStart({ calledFrom });
+    this.callOnSyncStart({ calledFrom, initialSync: false });
     try {
       this.deps.cancelRestUploadTimer();
       await this.deps.awaitRestUpload();
@@ -3360,6 +3360,7 @@ var SyncedDb = class _SyncedDb {
     this.onSyncEnd = config.onSyncEnd;
     this.onDexieSyncStart = config.onDexieSyncStart;
     this.onDexieSyncEnd = config.onDexieSyncEnd;
+    this.onSyncProgress = config.onSyncProgress;
     this.onServerSyncStart = config.onServerSyncStart;
     this.onServerSyncEnd = config.onServerSyncEnd;
     this.onConflictResolved = config.onConflictResolved;
@@ -3475,7 +3476,7 @@ var SyncedDb = class _SyncedDb {
       dexieDb: this.dexieDb,
       restInterface: this.restInterface,
       callbacks: {
-        onSyncStart: config.onSyncStart,
+        onSyncStart: config.onSyncStart ? (info) => config.onSyncStart(__spreadProps(__spreadValues({}, info), { initialSync: !this._lastFullSyncDate })) : void 0,
         onSyncEnd: config.onSyncEnd,
         onServerSyncStart: config.onServerSyncStart,
         onServerSyncEnd: config.onServerSyncEnd,
@@ -3583,11 +3584,15 @@ var SyncedDb = class _SyncedDb {
     }
     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) {
-        await this.loadCollectionToInMem(name);
+      for (let i = 0; i < newlyAllowed.length; i++) {
+        const name = newlyAllowed[i];
+        const items = await this.loadCollectionToInMem(name);
+        totalItems += items;
+        this.safeCallback(this.onSyncProgress, { collection: name, loaded: i + 1, total: newlyAllowed.length, items });
       }
-      this.safeCallback(this.onDexieSyncEnd, { calledFrom: "setSyncOnlyTheseCollections", collectionCount: newlyAllowed.length, durationMs: Date.now() - dexieStart });
+      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(() => {
@@ -3623,14 +3628,19 @@ var SyncedDb = class _SyncedDb {
         "BroadcastChannel API is not available. Cross-tab synchronization disabled."
       );
     }
+    await this._loadLastFullSync();
     await this.pendingChanges.recoverPendingWrites();
     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) {
-      await this.loadCollectionToInMem(name);
+    for (let i = 0; i < allowedColls.length; i++) {
+      const name = allowedColls[i];
+      const items = await this.loadCollectionToInMem(name);
+      totalItems += items;
+      this.safeCallback(this.onSyncProgress, { collection: name, loaded: i + 1, total: allowedColls.length, items });
     }
-    this.safeCallback(this.onDexieSyncEnd, { calledFrom: "init", collectionCount: allowedColls.length, durationMs: Date.now() - dexieStart });
+    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();
@@ -3675,6 +3685,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);
@@ -4176,6 +4220,12 @@ var SyncedDb = class _SyncedDb {
     this.syncing = true;
     try {
       await this.syncEngine.sync(calledFrom);
+      if (!this.syncOnlyCollections) {
+        const now = /* @__PURE__ */ new Date();
+        this._setLastFullSync(now).catch((err) => {
+          console.error("Failed to persist lastFullSync:", err);
+        });
+      }
     } finally {
       this.syncing = false;
       this.syncLock = false;
@@ -4317,6 +4367,7 @@ var SyncedDb = class _SyncedDb {
       await this.dexieDb.clearDirtyChanges(collectionName);
     }
     this.syncMetaCache.clear();
+    this._clearLastFullSync();
   }
   // ==================== Object Metadata ====================
   getObjectMetadata(collection, _id) {
@@ -4406,6 +4457,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

@@ -41,6 +41,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly onSyncEnd?;
     private readonly onDexieSyncStart?;
     private readonly onDexieSyncEnd?;
+    private readonly onSyncProgress?;
     private readonly onServerSyncStart?;
     private readonly onServerSyncEnd?;
     private readonly onConflictResolved?;
@@ -70,6 +71,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;

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

@@ -210,6 +210,7 @@ export interface I_InMemManager {
 export interface SyncEngineCallbacks {
     onSyncStart?: (info: {
         calledFrom?: string;
+        initialSync: boolean;
     }) => void;
     onSyncEnd?: (info: SyncInfo) => void;
     onServerSyncStart?: (info: {

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

@@ -293,9 +293,10 @@ 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 at the start of each sync cycle */
+    /** 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;
@@ -308,8 +309,16 @@ export interface SyncedDbConfig {
     onDexieSyncEnd?: (info: {
         calledFrom?: string;
         collectionCount: number;
+        totalItems: number;
         durationMs: number;
     }) => void;
+    /** Callback after each collection is loaded during full sync (Dexie→inMem). Fires only during init/setSyncOnlyTheseCollections. */
+    onSyncProgress?: (info: {
+        collection: string;
+        loaded: number;
+        total: number;
+        items: number;
+    }) => void;
     /** Callback when server download starts (findNewerManyStream) */
     onServerSyncStart?: (info: {
         calledFrom?: string;

package/package.json

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