cry-synced-db-client 0.1.156 → 0.1.157

package/dist/index.js

@@ -2724,15 +2724,18 @@ function hasArrayIndexPath(key) {
   return /\.\d+(\.|$)/.test(key);
 }
 function fixDotnetArrays(changes, serverRev, baseRev) {
-  if (typeof serverRev !== "number" || typeof baseRev !== "number") {
-    return changes;
-  }
-  if (serverRev <= baseRev) {
-    return changes;
+  const topLevelArrays = /* @__PURE__ */ new Set();
+  for (const [k, v] of Object.entries(changes)) {
+    if (Array.isArray(v)) topLevelArrays.add(k);
   }
+  const isStale = typeof serverRev === "number" && typeof baseRev === "number" && serverRev > baseRev;
   const cleaned = {};
   for (const [key, value] of Object.entries(changes)) {
-    if (hasArrayIndexPath(key)) continue;
+    if (hasArrayIndexPath(key)) {
+      const arrayField = key.split(".")[0];
+      if (arrayField && topLevelArrays.has(arrayField)) continue;
+      if (isStale) continue;
+    }
     cleaned[key] = value;
   }
   return cleaned;
@@ -2989,6 +2992,7 @@ var _SyncEngine = class _SyncEngine {
         dirtyChangesMap.set(String(dirtyItem._id), dirtyItem);
       }
       const updates = [];
+      const skipped = [];
       const ids = dirtyChanges.map((dc) => dc._id);
       const fullItems = await this.dexieDb.getByIds(collectionName, ids);
       for (let i = 0; i < fullItems.length; i++) {
@@ -2999,6 +3003,8 @@ var _SyncEngine = class _SyncEngine {
           if (delta) {
             const currentServerRev = typeof fullItem._rev === "number" ? fullItem._rev : void 0;
             updates.push({ _id: fullItem._id, delta, currentServerRev, fullItem });
+          } else {
+            skipped.push({ _id: String(fullItem._id), reason: "no-delta-for-fullitem" });
           }
         } else if (id != null) {
           const delta = dirtyChangesMap.get(String(id));
@@ -3006,15 +3012,50 @@ var _SyncEngine = class _SyncEngine {
             const reconstructed = __spreadProps(__spreadValues({}, delta), { _id: id });
             await this.dexieDb.save(collectionName, id, reconstructed);
             updates.push({ _id: id, delta });
+          } else {
+            skipped.push({ _id: String(id), reason: "no-delta-for-orphan" });
           }
+        } else {
+          skipped.push({ _id: "<null>", reason: "no-fullitem-no-id" });
         }
       }
       if (updates.length === 0) {
         console.warn(
-          `uploadDirtyItems: ${collectionName} has ${dirtyChanges.length} dirty entries but 0 resolvable items`
+          `uploadDirtyItems: ${collectionName} has ${dirtyChanges.length} dirty entries but 0 resolvable items`,
+          skipped
         );
+        if (this.callbacks.onUploadSkip) {
+          try {
+            this.callbacks.onUploadSkip({
+              collection: collectionName,
+              reason: "no-resolvable-items",
+              dirtyCount: dirtyChanges.length,
+              skippedIds: skipped.slice(0, 20).map((s) => s._id),
+              skipReasons: skipped.slice(0, 20),
+              calledFrom,
+              timestamp: /* @__PURE__ */ new Date()
+            });
+          } catch (err) {
+            console.error("onUploadSkip callback failed:", err);
+          }
+        }
         continue;
       }
+      if (skipped.length > 0 && this.callbacks.onUploadSkip) {
+        try {
+          this.callbacks.onUploadSkip({
+            collection: collectionName,
+            reason: "no-resolvable-items",
+            dirtyCount: dirtyChanges.length,
+            skippedIds: skipped.slice(0, 20).map((s) => s._id),
+            skipReasons: skipped.slice(0, 20),
+            calledFrom,
+            timestamp: /* @__PURE__ */ new Date()
+          });
+        } catch (err) {
+          console.error("onUploadSkip callback failed:", err);
+        }
+      }
       collectionBatches.push([{
         collection: collectionName,
         batch: {
@@ -3932,6 +3973,8 @@ var _SyncedDb = class _SyncedDb {
     this.onWakeSync = config.onWakeSync;
     this.onEvictionStart = config.onEvictionStart;
     this.onEviction = config.onEviction;
+    this.onSaveIdMismatch = config.onSaveIdMismatch;
+    this.onUploadSkip = config.onUploadSkip;
     this.evictStaleRecordsEveryHrs = (_e = config.evictStaleRecordsEveryHrs) != null ? _e : 0;
     this.scopeExitLookbehindMs = (_f = config.scopeExitLookbehindMs) != null ? _f : 0;
     this.evictOnWake = (_g = config.evictOnWake) != null ? _g : false;
@@ -4068,7 +4111,8 @@ var _SyncedDb = class _SyncedDb {
         onServerWriteRequest: config.onServerWriteRequest,
         onServerWriteResult: config.onServerWriteResult,
         onFindNewerManyCall: config.onFindNewerManyCall,
-        onFindNewerManyResult: config.onFindNewerManyResult
+        onFindNewerManyResult: config.onFindNewerManyResult,
+        onUploadSkip: config.onUploadSkip
       },
       deps: {
         getSyncMetaCache: () => this.syncMetaCache,
@@ -4679,6 +4723,28 @@ var _SyncedDb = class _SyncedDb {
       );
       delete update._id;
     }
+    if ("_id" in update && update._id && String(update._id) !== String(id)) {
+      const updateKeys = Object.keys(update);
+      const stack = (() => {
+        try {
+          return new Error().stack;
+        } catch (e) {
+          return void 0;
+        }
+      })();
+      console.error(
+        `SyncedDb.save("${collection}", "${String(id)}"): update._id (${JSON.stringify(update._id)}) does NOT match id (${JSON.stringify(String(id))}). Stripped from update to prevent stuck-dirty bug. The caller likely passed a stale this._id while building update from a freshly-generated record. Data keys: [${updateKeys.join(", ")}]`
+      );
+      this.safeCallback(this.onSaveIdMismatch, {
+        collection,
+        id: String(id),
+        updateId: String(update._id),
+        updateKeys,
+        stack,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+      delete update._id;
+    }
     update = _SyncedDb.stringifyObjectIds(update);
     const existing = await this.dexieDb.getById(collection, id);
     if (!existing && !((_a = this.collections.get(collection)) == null ? void 0 : _a.writeOnly)) {

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

@@ -52,6 +52,8 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly onWakeSync?;
     private readonly onEvictionStart?;
     private readonly onEviction?;
+    private readonly onSaveIdMismatch?;
+    private readonly onUploadSkip?;
     private readonly evictStaleRecordsEveryHrs;
     private readonly scopeExitLookbehindMs;
     private readonly evictOnWake;

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

@@ -261,6 +261,7 @@ export interface SyncEngineCallbacks {
     onServerWriteResult?: (info: ServerWriteResultInfo) => void;
     onFindNewerManyCall?: (info: FindNewerManyCallInfo) => void;
     onFindNewerManyResult?: (info: FindNewerManyResultInfo) => void;
+    onUploadSkip?: (info: import("../../types/I_SyncedDb").UploadSkipInfo) => void;
 }
 export interface SyncEngineDeps {
     getSyncMetaCache: () => Map<string, SyncMeta>;

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

@@ -35,6 +35,62 @@ export interface InfrastructureErrorInfo {
     /** Timestamp when error occurred */
     timestamp: Date;
 }
+/**
+ * Payload za upload-skip callback. Sproži se, ko `uploadDirtyItems` najde
+ * dirty zapise v Dexie `_dirty_changes`, ampak iz njih ne more zgraditi
+ * resolve-able update batch (npr. fullItem manjka in `id` je null/undefined,
+ * ali `dirtyChangesMap.get` vrne undefined zaradi key mismatch-a).
+ *
+ * Production incident 2026-05-08 (etv/prvak/studenci/tackakp racuni stuck):
+ * 14 dirty zapisov nikoli ne pride na server, brez napake na rdb2/errors,
+ * `lastDirtySyncAt: null` (sentCount=0). Ta callback razkrije za katere
+ * konkretne `_id`-je se to dogaja.
+ */
+export interface UploadSkipInfo {
+    /** Collection kjer je skip nastal */
+    collection: string;
+    /** Razlog za skip */
+    reason: "no-resolvable-items" | "no-batches";
+    /** Število dirty zapisov v Dexie pred skip-om */
+    dirtyCount: number;
+    /** Konkretni _id-ji, ki so šli skozi skip pot (do 20) */
+    skippedIds: string[];
+    /** Razlog za vsak skipped _id (do 20) */
+    skipReasons: {
+        _id: string;
+        reason: "no-fullitem-no-id" | "no-delta-for-fullitem" | "no-delta-for-orphan";
+    }[];
+    /** calledFrom iz sync flow-a */
+    calledFrom?: string;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Payload za save() id-mismatch callback. Sproži se, ko caller pokliče
+ * `save(collection, id, update)` z `update._id` ki se NE ujema z `id`.
+ *
+ * Brez popravka bi addDirtyChange shranil entry.id = id, entry.changes._id =
+ * update._id; pri uploadu bi server dobil update._id, vrnil ack pod update._id,
+ * client bi poskušal clear pod id → ne ujema → dirty stuck forever.
+ *
+ * Library v save() avtomatsko strip-a `_id` iz update preden pokliče
+ * addDirtyChange. Callback je samo za telemetry/syslog/alerting — caller bug
+ * mora biti popravljen v aplikaciji.
+ */
+export interface SaveIdMismatchInfo {
+    /** Collection name */
+    collection: string;
+    /** id parameter passed to save() */
+    id: string;
+    /** _id field present in update object (mismatched) */
+    updateId: string;
+    /** Top-level keys of the update object (no values, no PII) */
+    updateKeys: string[];
+    /** Stack trace at the call site */
+    stack?: string;
+    /** Timestamp when mismatch detected */
+    timestamp: Date;
+}
 /**
  * Callback payload for server write requests (before sending)
  */
@@ -462,6 +518,29 @@ export interface SyncedDbConfig {
      * Client code can use this to show warnings, log telemetry, or adjust behavior.
      */
     onInfrastructureError?: (info: InfrastructureErrorInfo) => void;
+    /**
+     * Callback when `uploadDirtyItems` skips dirty entries (silent skip without
+     * sending to server). Used to diagnose stuck-dirty pattern where dirty
+     * exists but `sentCount === 0` (lastDirtySyncAt stays null).
+     *
+     * Production incident 2026-05-08 — 14 stuck racuni/protokoli on prod.
+     * Server has no record, no rdb2 error, dirty stays forever. This callback
+     * reveals which dirty entries hit which skip path.
+     */
+    onUploadSkip?: (info: UploadSkipInfo) => void;
+    /**
+     * Callback when `save(collection, id, update)` is called with `update._id`
+     * that does NOT match `id`. Library auto-strips `_id` from update to prevent
+     * the stuck-dirty bug, but the caller bug should be fixed in the app code.
+     *
+     * Use this callback for telemetry/syslog/alerting — the mismatch is silent
+     * data corruption (dirty stays forever) without observability.
+     *
+     * Production incident 2026-05-08 (zvitorepka, 3 stuck protokoli) was caused
+     * by `pages/protokol.vue` calling `save("protokoli", this._id, this.protokol)`
+     * where `this._id` and `this.protokol._id` had drifted apart.
+     */
+    onSaveIdMismatch?: (info: SaveIdMismatchInfo) => void;
     /**
      * Enable in-memory object metadata feature.
      * When true, collections with hasMetadata=true will have their metadata callbacks invoked

package/package.json

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