cry-synced-db-client 0.1.2 → 0.1.4

package/dist/db/RestProxy.d.ts

@@ -1,6 +1,5 @@
 import type { Timestamp, AggregateOptions } from "mongodb";
-import type { Id } from "../types/DbEntity";
-import type { I_RestInterface, QuerySpec, QueryOpts, GetNewerSpec, UpdateSpec, InsertSpec, BatchSpec } from "../types/I_RestInterface";
+import type { I_RestInterface, QuerySpec, QueryOpts, GetNewerSpec, BatchSpec, CollectionUpdateRequest, CollectionUpdateResult } from "../types/I_RestInterface";
 /** Progress callback for tracking upload progress */
 export type ProgressCallback = (sentBytes: number, totalBytes: number) => void;
 export interface RestProxyConfig {
@@ -99,11 +98,8 @@ export declare class RestProxy implements I_RestInterface {
     ping(): Promise<boolean>;
     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[]>>;
-    latestTimestamp(collection: string): Promise<Timestamp | undefined>;
-    latestTimestamps(collections: string[]): Promise<Record<string, Timestamp>>;
-    save<T>(collection: string, update: UpdateSpec<T>, id?: Id): Promise<T>;
-    insert<T>(collection: string, insert: InsertSpec<T>): Promise<T>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
     aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;
     upsertBatch<T>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
+    updateCollections<T>(collectionsBatches: CollectionUpdateRequest<T>[]): Promise<CollectionUpdateResult[]>;
 }

package/dist/db/SyncedDb.d.ts

@@ -14,9 +14,15 @@ export declare class SyncedDb implements I_SyncedDb {
     private serverUpdateNotifier?;
     private restTimeoutMs;
     private syncTimeoutMs;
-    private debounceMs;
+    private debounceDexieWritesMs;
+    private debounceRestWritesMs;
     private onForcedOffline?;
     private onSync?;
+    private onServerWriteRequest?;
+    private onServerWriteResult?;
+    private onFindNewerManyCall?;
+    private onFindNewerCall?;
+    private autoSyncIntervalMs?;
     private online;
     private syncing;
     private syncLock;
@@ -24,6 +30,12 @@ export declare class SyncedDb implements I_SyncedDb {
     private pendingChanges;
     private unsubscribeServerUpdates?;
     private beforeUnloadHandler?;
+    /** Timer za debounced REST upload */
+    private restUploadTimer?;
+    /** Flag za preprečitev loopa - če je true, ne schedulamo REST uploada */
+    private isUploadingToRest;
+    /** Timer za avtomatsko sinhronizacijo */
+    private autoSyncTimer?;
     /** Unikatni ID te instance za detekcijo loopback */
     private readonly updaterId;
     constructor(config: SyncedDbConfig);
@@ -36,6 +48,15 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private goOffline;
     private tryGoOnline;
+    /**
+     * Zažene avtomatsko periodično sinhronizacijo če je autoSyncIntervalMs konfiguriran.
+     * Safe to call multiple times - bo najprej ustavil obstoječi timer.
+     */
+    private startAutoSync;
+    /**
+     * Ustavi avtomatsko periodično sinhronizacijo.
+     */
+    private stopAutoSync;
     /** Ovije promise s timeout za REST operacije */
     private withRestTimeout;
     /** Ovije promise s timeout za sync operacije (daljši timeout) */
@@ -53,27 +74,49 @@ export declare class SyncedDb implements I_SyncedDb {
     hardDeleteOne<T extends DbEntity>(collection: string, id: Id): Promise<T | null>;
     hardDelete<T extends DbEntity>(collection: string, query: QuerySpec<T>): Promise<number>;
     ping(timeoutMs?: number): Promise<boolean>;
-    sync(): Promise<void>;
+    sync(calledFrom?: string): Promise<void>;
     isSyncing(): boolean;
+    /**
+     * Batch upsert - server only, does NOT update local state.
+     *
+     * This is intentional. If you need local state updated after calling this method,
+     * call sync() afterward. See I_SyncedDb interface for full documentation.
+     */
     upsertBatch<T extends DbEntity>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
     getMemoryCollection<T extends DbEntity>(collection: string): T[];
-    getDebounceMs(): number;
+    getDebounceDexieWritesMs(): number;
+    getDebounceRestWritesMs(): number;
+    getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
     private assertCollection;
     private stripLocalFields;
     private getPendingKey;
     private schedulePendingChange;
     private executePendingChange;
+    /**
+     * Schedulira debounced REST upload dirty objektov
+     * Ne naredi nič če smo offline, že uploadamo, ali je sync v teku
+     */
+    private scheduleRestUpload;
+    /**
+     * Izvede REST upload dirty objektov
+     */
+    private executeRestUpload;
     private flushAllPendingChanges;
     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;
     /**
-     * Sinhronizira kolekcijo s podatki, ki so že bili pridobljeni s serverja
-     * Vrne statistiko: { conflictsResolved, sentCount }
+     * Obdela prihajajoče podatke s serverja - razreši konflikte in shrani v Dexie/inMem
+     * Ne pošilja dirty objektov na server (to naredi uploadDirtyItems)
+     */
+    private processIncomingServerData;
+    /**
+     * Zbere vse dirty objekte iz vseh kolekcij in jih pošlje na server z enim updateCollections klicem
      */
-    private syncCollectionWithData;
+    private uploadDirtyItems;
     private resolveCollectionConflict;
     private compareTimestamps;
     private handleServerUpdate;

package/dist/index.js

@@ -251,7 +251,8 @@ function getPendingWrites(tenant) {
 }
 
 // src/db/SyncedDb.ts
-var DEFAULT_DEBOUNCE_MS = 1000;
+var DEFAULT_DEXIE_DEBOUNCE_MS = 1000;
+var DEFAULT_REST_DEBOUNCE_MS = 2000;
 var DEFAULT_REST_TIMEOUT_MS = 1e4;
 var DEFAULT_SYNC_TIMEOUT_MS = 30000;
 var MAX_RETRY_COUNT = 3;
@@ -265,9 +266,15 @@ class SyncedDb {
   serverUpdateNotifier;
   restTimeoutMs;
   syncTimeoutMs;
-  debounceMs;
+  debounceDexieWritesMs;
+  debounceRestWritesMs;
   onForcedOffline;
   onSync;
+  onServerWriteRequest;
+  onServerWriteResult;
+  onFindNewerManyCall;
+  onFindNewerCall;
+  autoSyncIntervalMs;
   online = false;
   syncing = false;
   syncLock = false;
@@ -275,6 +282,9 @@ class SyncedDb {
   pendingChanges = new Map;
   unsubscribeServerUpdates;
   beforeUnloadHandler;
+  restUploadTimer;
+  isUploadingToRest = false;
+  autoSyncTimer;
   updaterId;
   constructor(config) {
     this.tenant = config.tenant;
@@ -284,9 +294,15 @@ class SyncedDb {
     this.serverUpdateNotifier = config.serverUpdateNotifier;
     this.restTimeoutMs = config.restTimeoutMs ?? DEFAULT_REST_TIMEOUT_MS;
     this.syncTimeoutMs = config.syncTimeoutMs ?? DEFAULT_SYNC_TIMEOUT_MS;
-    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.debounceDexieWritesMs = config.debounceDexieWritesMs ?? DEFAULT_DEXIE_DEBOUNCE_MS;
+    this.debounceRestWritesMs = config.debounceRestWritesMs ?? DEFAULT_REST_DEBOUNCE_MS;
     this.onForcedOffline = config.onForcedOffline;
     this.onSync = config.onSync;
+    this.onServerWriteRequest = config.onServerWriteRequest;
+    this.onServerWriteResult = config.onServerWriteResult;
+    this.onFindNewerManyCall = config.onFindNewerManyCall;
+    this.onFindNewerCall = config.onFindNewerCall;
+    this.autoSyncIntervalMs = config.autoSyncIntervalMs;
     this.updaterId = Math.random().toString(36).substring(2, 15);
     for (const col of config.collections) {
       this.collections.set(col.name, col);
@@ -315,6 +331,11 @@ class SyncedDb {
     this.initialized = true;
   }
   async close() {
+    if (this.restUploadTimer) {
+      clearTimeout(this.restUploadTimer);
+      this.restUploadTimer = undefined;
+    }
+    this.stopAutoSync();
     await this.flushAllPendingChanges();
     if (this.unsubscribeServerUpdates) {
       this.unsubscribeServerUpdates();
@@ -337,10 +358,14 @@ class SyncedDb {
       });
     } else {
       this.online = online;
+      if (!online) {
+        this.stopAutoSync();
+      }
     }
   }
   goOffline(reason) {
     this.online = false;
+    this.stopAutoSync();
     if (this.onForcedOffline) {
       try {
         this.onForcedOffline(reason);
@@ -357,12 +382,31 @@ class SyncedDb {
         return;
       }
       this.online = true;
-      await this.sync();
+      this.startAutoSync();
+      await this.sync("INITIAL SYNC");
     } catch (err) {
       console.warn("Failed to go online (ping failed or timed out):", err);
       this.online = false;
     }
   }
+  startAutoSync() {
+    this.stopAutoSync();
+    if (!this.autoSyncIntervalMs || this.autoSyncIntervalMs <= 0) {
+      return;
+    }
+    const intervalMs = this.autoSyncIntervalMs;
+    this.autoSyncTimer = setInterval(() => {
+      this.sync(`interval ${intervalMs}ms`).catch((err) => {
+        console.error("Auto-sync failed:", err);
+      });
+    }, intervalMs);
+  }
+  stopAutoSync() {
+    if (this.autoSyncTimer) {
+      clearInterval(this.autoSyncTimer);
+      this.autoSyncTimer = undefined;
+    }
+  }
   withRestTimeout(promise, operation) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
@@ -595,7 +639,7 @@ class SyncedDb {
       return false;
     }
   }
-  async sync() {
+  async sync(calledFrom) {
     if (!this.online || this.syncLock)
       return;
     this.syncLock = true;
@@ -618,14 +662,26 @@ class SyncedDb {
         });
         configMap.set(collectionName, config);
       }
+      if (this.onFindNewerManyCall) {
+        try {
+          this.onFindNewerManyCall({
+            specs: syncSpecs,
+            timestamp: new Date,
+            calledFrom
+          });
+        } catch (err) {
+          console.error("onFindNewerManyCall callback failed:", err);
+        }
+      }
       const allServerData = await this.withSyncTimeout(this.restInterface.findNewerMany(syncSpecs), "findNewerMany");
       for (const [collectionName, config] of this.collections) {
         const serverData = allServerData[collectionName] || [];
         receivedCount += serverData.length;
-        const stats = await this.syncCollectionWithData(collectionName, config, serverData);
-        sentCount += stats.sentCount;
+        const stats = await this.processIncomingServerData(collectionName, config, serverData);
         conflictsResolved += stats.conflictsResolved;
       }
+      const uploadStats = await this.uploadDirtyItems(calledFrom);
+      sentCount = uploadStats.sentCount;
       if (this.onSync) {
         try {
           this.onSync({
@@ -633,7 +689,8 @@ class SyncedDb {
             receivedCount,
             sentCount,
             conflictsResolved,
-            success: true
+            success: true,
+            calledFrom
           });
         } catch (err) {
           console.error("onSync callback failed:", err);
@@ -651,7 +708,8 @@ class SyncedDb {
             sentCount,
             conflictsResolved,
             success: false,
-            error: err instanceof Error ? err : new Error(String(err))
+            error: err instanceof Error ? err : new Error(String(err)),
+            calledFrom
           });
         } catch (callbackErr) {
           console.error("onSync callback failed:", callbackErr);
@@ -677,8 +735,19 @@ class SyncedDb {
     this.assertCollection(collection);
     return this.inMemDb.getAll(collection);
   }
-  getDebounceMs() {
-    return this.debounceMs;
+  getDebounceDexieWritesMs() {
+    return this.debounceDexieWritesMs;
+  }
+  getDebounceRestWritesMs() {
+    return this.debounceRestWritesMs;
+  }
+  async getDirty() {
+    const result = {};
+    for (const [collectionName] of this.collections) {
+      const dirtyItems = await this.dexieDb.getDirty(collectionName);
+      result[collectionName] = dirtyItems.map((item) => this.stripLocalFields(item));
+    }
+    return result;
   }
   assertCollection(name) {
     if (!this.collections.has(name)) {
@@ -702,7 +771,7 @@ class SyncedDb {
     savePendingWrite(this.tenant, collection, id, fullData);
     const timer = setTimeout(() => {
       this.executePendingChange(key);
-    }, this.debounceMs);
+    }, this.debounceDexieWritesMs);
     const newRetryCount = retryCount > 0 ? retryCount : existing?.retryCount ?? 0;
     this.pendingChanges.set(key, {
       collection,
@@ -728,6 +797,7 @@ class SyncedDb {
         });
       }
       clearPendingWrite(this.tenant, pending.collection, pending.id);
+      this.scheduleRestUpload();
     } catch (err) {
       console.error("Failed to write to Dexie:", err);
       const newRetryCount = pending.retryCount + 1;
@@ -738,6 +808,30 @@ class SyncedDb {
       this.schedulePendingChange(pending.collection, pending.id, pending.data, newRetryCount);
     }
   }
+  scheduleRestUpload() {
+    if (!this.online || this.isUploadingToRest || this.syncing) {
+      return;
+    }
+    if (this.restUploadTimer) {
+      clearTimeout(this.restUploadTimer);
+    }
+    this.restUploadTimer = setTimeout(() => {
+      this.executeRestUpload();
+    }, this.debounceRestWritesMs);
+  }
+  async executeRestUpload() {
+    if (this.isUploadingToRest || this.syncing || !this.online) {
+      return;
+    }
+    this.isUploadingToRest = true;
+    try {
+      await this.uploadDirtyItems();
+    } catch (err) {
+      console.error("REST upload failed:", err);
+    } finally {
+      this.isUploadingToRest = false;
+    }
+  }
   async flushAllPendingChanges() {
     const promises = [];
     for (const [key, pending] of this.pendingChanges) {
@@ -767,10 +861,23 @@ class SyncedDb {
     if (!config)
       return;
     const meta = await this.dexieDb.getSyncMeta(collectionName);
-    const serverData = await this.restInterface.findNewer(collectionName, meta?.lastSyncTs || 0, config.query, { returnDeleted: true });
-    await this.syncCollectionWithData(collectionName, config, serverData);
+    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 syncCollectionWithData(collectionName, config, serverData) {
+  async processIncomingServerData(collectionName, config, serverData) {
     let maxTs;
     let conflictsResolved = 0;
     const dexieBatch = [];
@@ -827,41 +934,107 @@ class SyncedDb {
     for (const id of inMemDeleteIds) {
       this.inMemDb.deleteOne(collectionName, id);
     }
-    const dirtyItems = await this.dexieDb.getDirty(collectionName);
-    const deletedItems = dirtyItems.filter((item) => item._deleted);
-    const saveItems = dirtyItems.filter((item) => !item._deleted);
-    let sentCount = 0;
-    for (const item of deletedItems) {
-      try {
-        await this.restInterface.deleteOne(collectionName, { _id: item._id });
-        await this.dexieDb.deleteOne(collectionName, item._id);
-        sentCount++;
-      } catch (err) {
-        console.error(`Failed to sync deleted item ${String(item._id)}:`, err);
+    if (maxTs) {
+      await this.dexieDb.setSyncMeta(collectionName, maxTs);
+    }
+    return { conflictsResolved, maxTs };
+  }
+  async uploadDirtyItems(calledFrom) {
+    const collectionBatches = [];
+    const dirtyItemsMap = new Map;
+    for (const [collectionName] of this.collections) {
+      const dirtyItems = await this.dexieDb.getDirty(collectionName);
+      if (dirtyItems.length === 0)
+        continue;
+      const updates = [];
+      const deletes = [];
+      for (const item of dirtyItems) {
+        if (item._deleted) {
+          deletes.push(item);
+        } else {
+          updates.push(item);
+        }
       }
+      dirtyItemsMap.set(collectionName, { updates, deletes });
+      collectionBatches.push([{
+        collection: collectionName,
+        batch: {
+          updates: updates.map((item) => ({
+            _id: item._id,
+            update: this.stripLocalFields(item)
+          })),
+          deletes: deletes.map((item) => ({ _id: item._id }))
+        }
+      }]);
+    }
+    if (collectionBatches.length === 0) {
+      return { sentCount: 0 };
     }
-    for (const item of saveItems) {
+    if (this.onServerWriteRequest) {
       try {
-        const saved = await this.restInterface.save(collectionName, this.stripLocalFields(item), item._id);
-        await this.dexieDb.save(collectionName, item._id, {
-          ...saved,
-          _dirty: false
+        this.onServerWriteRequest({
+          batches: collectionBatches,
+          timestamp: new Date,
+          calledFrom
         });
-        this.inMemDb.save(collectionName, item._id, this.stripLocalFields(saved));
-        if (saved._ts) {
-          if (!maxTs || this.compareTimestamps(saved._ts, maxTs) > 0) {
-            maxTs = saved._ts;
-          }
-        }
-        sentCount++;
       } catch (err) {
-        console.error(`Failed to sync item ${String(item._id)}:`, err);
+        console.error("onServerWriteRequest callback failed:", err);
       }
     }
-    if (maxTs) {
-      await this.dexieDb.setSyncMeta(collectionName, maxTs);
+    const writeStartTime = Date.now();
+    let results;
+    try {
+      results = await this.withSyncTimeout(this.restInterface.updateCollections(collectionBatches), "updateCollections");
+      if (this.onServerWriteResult) {
+        try {
+          this.onServerWriteResult({
+            results,
+            durationMs: Date.now() - writeStartTime,
+            success: true,
+            calledFrom
+          });
+        } catch (err) {
+          console.error("onServerWriteResult callback failed:", err);
+        }
+      }
+    } catch (err) {
+      if (this.onServerWriteResult) {
+        try {
+          this.onServerWriteResult({
+            results: [],
+            durationMs: Date.now() - writeStartTime,
+            success: false,
+            error: err instanceof Error ? err : new Error(String(err)),
+            calledFrom
+          });
+        } catch (callbackErr) {
+          console.error("onServerWriteResult callback failed:", callbackErr);
+        }
+      }
+      throw err;
     }
-    return { conflictsResolved, sentCount };
+    let sentCount = 0;
+    for (const result of results) {
+      const { collection, results: { updatedIds, deletedIds, errors } } = result;
+      const dirtyData = dirtyItemsMap.get(collection);
+      if (!dirtyData)
+        continue;
+      for (const id of updatedIds) {
+        const item = dirtyData.updates.find((u) => String(u._id) === String(id));
+        if (item) {
+          await this.dexieDb.save(collection, id, { _dirty: false });
+          sentCount++;
+        }
+      }
+      for (const id of deletedIds) {
+        await this.dexieDb.deleteOne(collection, id);
+        sentCount++;
+      }
+      if (errors) {
+        console.error(`Sync errors for ${collection}:`, errors);
+      }
+    }
+    return { sentCount };
   }
   resolveCollectionConflict(collectionName, config, local, external) {
     if (config.resolveSyncConflict) {
@@ -885,6 +1058,18 @@ class SyncedDb {
     switch (payload.operation) {
       case "insert":
       case "update": {
+        if (this.onFindNewerCall) {
+          try {
+            this.onFindNewerCall({
+              collection: collectionName,
+              fromTimestamp: 0,
+              query: { _id: payload._id },
+              timestamp: new Date
+            });
+          } catch (err) {
+            console.error("onFindNewerCall callback failed:", err);
+          }
+        }
         const items = await this.restInterface.findNewer(collectionName, 0, { _id: payload._id });
         const serverItem = items[0];
         if (serverItem) {
@@ -902,22 +1087,7 @@ class SyncedDb {
         break;
       }
       case "batch": {
-        const deleteIds = [];
-        const updateIds = [];
-        for (const item of payload.data) {
-          if (item.operation === "delete") {
-            deleteIds.push(item._id);
-          } else {
-            updateIds.push(item._id);
-          }
-        }
-        if (deleteIds.length > 0) {
-          await Promise.all(deleteIds.map((id) => this.handleServerItemDelete(collectionName, id)));
-        }
-        if (updateIds.length > 0) {
-          const serverItems = await Promise.all(updateIds.map((id) => this.restInterface.findNewer(collectionName, 0, { _id: id }).then((items) => items[0])));
-          await Promise.all(serverItems.filter((item) => !!item).map((serverItem) => this.handleServerItemUpdate(collectionName, serverItem)));
-        }
+        await this.syncSingleCollection(collectionName);
         break;
       }
     }
@@ -1298,26 +1468,6 @@ class RestProxy {
   async findNewerMany(spec) {
     return await this.restCall("findNewerMany", { spec });
   }
-  async latestTimestamp(collection) {
-    return await this.restCall("latestTimestamp", {
-      collection
-    });
-  }
-  async latestTimestamps(collections) {
-    return await this.restCall("latestTimestamps", {
-      collections
-    });
-  }
-  async save(collection, update, id) {
-    return await this.restCall("save", {
-      collection,
-      update,
-      id: id ? String(id) : undefined
-    });
-  }
-  async insert(collection, insert) {
-    return await this.restCall("insert", { collection, insert });
-  }
   async deleteOne(collection, query) {
     return await this.restCall("deleteOne", { collection, query });
   }
@@ -1327,6 +1477,11 @@ class RestProxy {
   async upsertBatch(collection, batch) {
     return await this.restCall("upsertBatch", { collection, batch });
   }
+  async updateCollections(collectionsBatches) {
+    return await this.restCall("updateCollections", {
+      batch: collectionsBatches
+    });
+  }
 }
 export {
   resolveConflict,

package/dist/types/I_RestInterface.d.ts

@@ -33,6 +33,38 @@ export interface GetNewerSpec<T> {
     query?: QuerySpec<T>;
     opts?: QueryOpts;
 }
+/**
+ * Request to batch update a collection, used to sync data
+ */
+export type CollectionUpdateRequest<T> = {
+    collection: string;
+    batch: {
+        updates: {
+            _id: Id;
+            update: Partial<T>;
+        }[];
+        deletes: {
+            _id: Id;
+        }[];
+    };
+}[];
+/**
+ * Result of updateCollections()
+ */
+export type CollectionUpdateResult = {
+    collection: string;
+    results: {
+        /** IDs of records actually updated */
+        updatedIds: Id[];
+        /** IDs of records actually deleted */
+        deletedIds: Id[];
+        /** errors returned by object */
+        errors?: {
+            _id: string;
+            error: string;
+        };
+    };
+};
 /**
  * Minimalni interface za komunikacijo s serverjem (cry-db Mongo)
  * Vsebuje samo metode, potrebne za sinhronizacijo
@@ -42,13 +74,11 @@ export interface I_RestInterface {
     ping(): Promise<boolean>;
     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[]>>;
-    latestTimestamp(collection: string): Promise<Timestamp | undefined>;
-    latestTimestamps(collections: string[]): Promise<Record<string, Timestamp>>;
-    save<T>(collection: string, update: UpdateSpec<T>, id?: Id): Promise<T>;
-    insert<T>(collection: string, insert: InsertSpec<T>): Promise<T>;
     deleteOne<T>(collection: string, query: QuerySpec<T>): Promise<T>;
     /** Izvede agregacijo na serverju */
     aggregate<T>(collection: string, pipeline: object[], opts?: AggregateOptions): Promise<T[]>;
     /** Izvede batch upsert na serverju - ne posodablja lokalne baze */
     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[]>;
 }

package/dist/types/I_SyncedDb.d.ts

@@ -1,9 +1,59 @@
-import type { AggregateOptions } from "mongodb";
+import type { AggregateOptions, Timestamp } from "mongodb";
 import type { Id, DbEntity } from "./DbEntity";
-import type { QuerySpec, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface } from "./I_RestInterface";
+import type { QuerySpec, UpdateSpec, InsertSpec, BatchSpec, I_RestInterface, CollectionUpdateRequest, CollectionUpdateResult, GetNewerSpec } from "./I_RestInterface";
 import type { I_DexieDb } from "./I_DexieDb";
 import type { I_InMemDb } from "./I_InMemDb";
 import type { I_ServerUpdateNotifier } from "./I_ServerUpdateNotifier";
+/**
+ * Callback payload for server write requests (before sending)
+ */
+export interface ServerWriteRequestInfo {
+    /** Collections and batches being sent */
+    batches: CollectionUpdateRequest<any>[];
+    /** Timestamp when request started */
+    timestamp: Date;
+    /** Where sync was called from (for debugging) */
+    calledFrom?: string;
+}
+/**
+ * Callback payload for server write results (after receiving)
+ */
+export interface ServerWriteResultInfo {
+    /** Results from server */
+    results: CollectionUpdateResult[];
+    /** 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 findNewerMany calls
+ */
+export interface FindNewerManyCallInfo {
+    /** Specs being requested */
+    specs: GetNewerSpec<any>[];
+    /** Timestamp when request started */
+    timestamp: Date;
+    /** Where sync was called from (for debugging) */
+    calledFrom?: string;
+}
+/**
+ * Callback payload for findNewer calls
+ */
+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;
+}
 /**
  * Informacije o sinhronizaciji za debugging/logging
  */
@@ -20,6 +70,8 @@ export interface SyncInfo {
     success: boolean;
     /** Napaka, če sync ni uspel */
     error?: Error;
+    /** Where sync was called from (for debugging) */
+    calledFrom?: string;
 }
 /**
  * Konfiguracija za posamezno kolekcijo
@@ -55,11 +107,28 @@ export interface SyncedDbConfig {
     /** Timeout za sync REST klice v ms (default: 30000) - daljši ker sync prenaša več podatkov */
     syncTimeoutMs?: number;
     /** Debounce čas za zapis v Dexie v ms (default: 1000) */
-    debounceMs?: number;
+    debounceDexieWritesMs?: number;
+    /** Debounce čas za pošiljanje na REST v ms (default: 2000) - po uspešnem zapisu v Dexie */
+    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 before sending data to server (updateCollections) */
+    onServerWriteRequest?: (info: ServerWriteRequestInfo) => void;
+    /** Callback after receiving result from server (updateCollections) */
+    onServerWriteResult?: (info: ServerWriteResultInfo) => void;
+    /** Callback when findNewerMany is called */
+    onFindNewerManyCall?: (info: FindNewerManyCallInfo) => void;
+    /** Callback when findNewer is called */
+    onFindNewerCall?: (info: FindNewerCallInfo) => void;
+    /**
+     * Interval za avtomatsko sinhronizacijo v ms (opcijsko).
+     * Če je podano, se sync() kliče avtomatsko na ta interval, ko je online.
+     * Auto-sync se izvaja samo ko je online in ne bo interferiral z eksplicitnimi sync() klici
+     * (uporablja isti syncLock mehanizem).
+     */
+    autoSyncIntervalMs?: number;
 }
 /**
  * Glavna logika za sinhronizirano bazo podatkov
@@ -131,19 +200,43 @@ export interface I_SyncedDb {
      * @returns true če je server dosegljiv, false sicer
      */
     ping(timeoutMs?: number): Promise<boolean>;
-    /** Sproži sinhronizacijo s serverjem */
-    sync(): Promise<void>;
+    /**
+     * Sproži sinhronizacijo s serverjem
+     * @param calledFrom Optional string for debugging - identifies where sync was called from
+     */
+    sync(calledFrom?: string): Promise<void>;
     /** Ali je sinhronizacija v teku */
     isSyncing(): boolean;
     /**
      * Izvede batch upsert na serverju
+     *
+     * IMPORTANT: This method intentionally does NOT update local state (Dexie or in-memory).
+     * This is by design - upsertBatch is meant for server-only operations where local
+     * state updates are not needed or will be handled separately.
+     *
+     * If you need local state to reflect the changes after calling upsertBatch(),
+     * call sync() afterward to fetch the updated data from the server.
+     *
+     * Note: Server notifications (via serverUpdateNotifier) for upsertBatch changes
+     * may trigger handleServerUpdate(), which will update local state. However, this
+     * happens asynchronously and may overwrite concurrent local changes if any exist.
+     *
      * - Deluje samo online, offline vrže napako
      * - Ne posodablja dexie ali in-mem baze
      * - Uporabljeno za operacije, ki ne potrebujejo lokalne sinhronizacije
+     *
+     * @example
+     * // If you need local state updated after batch operation:
+     * await syncedDb.upsertBatch('items', batchSpec);
+     * await syncedDb.sync(); // Fetch changes to local state
      */
     upsertBatch<T extends DbEntity>(collection: string, batch: BatchSpec<T>): Promise<T[]>;
     /** Vrne vse objekte iz in-mem baze za dano kolekcijo */
     getMemoryCollection<T extends DbEntity>(collection: string): T[];
-    /** Vrne konfigurirani debounce čas v ms */
-    getDebounceMs(): number;
+    /** Vrne konfigurirani debounce čas za Dexie v ms */
+    getDebounceDexieWritesMs(): number;
+    /** Vrne konfigurirani debounce čas za REST v ms */
+    getDebounceRestWritesMs(): number;
+    /** Vrne vse dirty objekte iz vseh kolekcij */
+    getDirty<T extends DbEntity>(): Promise<Readonly<Record<string, readonly T[]>>>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cry-synced-db-client",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@types/bun": "latest",
     "bson": "^7.0.0",
-    "cry-db": "^2.4.11",
+    "cry-db": "^2.4.12",
     "dexie": "^4.2.1",
     "fake-indexeddb": "^6.2.5",
     "typescript": "^5"

package/README.md

@@ -1,15 +0,0 @@
-# synced-db-client
-
-To install dependencies:
-
-```bash
-bun install
-```
-
-To run:
-
-```bash
-bun run index.ts
-```
-
-This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.