cry-synced-db-client 0.1.157 → 0.1.159

package/dist/index.js

@@ -2723,19 +2723,32 @@ function isPlainObject4(value) {
 function hasArrayIndexPath(key) {
   return /\.\d+(\.|$)/.test(key);
 }
+function pathTargetsArrayElement(key, arrayPathTokens) {
+  const keyTokens = tokenizePath(key);
+  if (keyTokens.length <= arrayPathTokens.length) return false;
+  for (let i = 0; i < arrayPathTokens.length; i++) {
+    if (keyTokens[i] !== arrayPathTokens[i]) return false;
+  }
+  const next = keyTokens[arrayPathTokens.length];
+  return next.startsWith("[") || /^\d+$/.test(next);
+}
 function fixDotnetArrays(changes, serverRev, baseRev) {
-  const topLevelArrays = /* @__PURE__ */ new Set();
+  const arrayPathTokens = [];
   for (const [k, v] of Object.entries(changes)) {
-    if (Array.isArray(v)) topLevelArrays.add(k);
+    if (Array.isArray(v)) arrayPathTokens.push(tokenizePath(k));
   }
   const isStale = typeof serverRev === "number" && typeof baseRev === "number" && serverRev > baseRev;
   const cleaned = {};
   for (const [key, value] of Object.entries(changes)) {
-    if (hasArrayIndexPath(key)) {
-      const arrayField = key.split(".")[0];
-      if (arrayField && topLevelArrays.has(arrayField)) continue;
-      if (isStale) continue;
+    let conflictsWithFullArray = false;
+    for (const tokens of arrayPathTokens) {
+      if (pathTargetsArrayElement(key, tokens)) {
+        conflictsWithFullArray = true;
+        break;
+      }
     }
+    if (conflictsWithFullArray) continue;
+    if (isStale && hasArrayIndexPath(key)) continue;
     cleaned[key] = value;
   }
   return cleaned;
@@ -2789,6 +2802,42 @@ function translateKey(key, entity) {
   return out.join(".");
 }
 
+// src/utils/stripServerManaged.ts
+var SERVER_MANAGED_KEYS = /* @__PURE__ */ new Set(["_ts", "_rev", "_csq"]);
+function isObjectIdLike2(v) {
+  return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || v._bsontype === "ObjectID"));
+}
+function isServerManagedPath(key) {
+  for (const part of tokenizePath(key)) {
+    if (part.startsWith("[")) continue;
+    if (SERVER_MANAGED_KEYS.has(part)) return true;
+  }
+  return false;
+}
+function scrubServerManagedDeep(value) {
+  if (value === null || value === void 0) return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => scrubServerManagedDeep(item));
+  }
+  if (typeof value !== "object") return value;
+  if (value instanceof Date) return value;
+  if (isObjectIdLike2(value)) return value;
+  const out = {};
+  for (const k of Object.keys(value)) {
+    if (SERVER_MANAGED_KEYS.has(k)) continue;
+    out[k] = scrubServerManagedDeep(value[k]);
+  }
+  return out;
+}
+function stripServerManagedFromChanges(changes) {
+  const out = {};
+  for (const [key, value] of Object.entries(changes)) {
+    if (isServerManagedPath(key)) continue;
+    out[key] = scrubServerManagedDeep(value);
+  }
+  return out;
+}
+
 // src/db/sync/SyncEngine.ts
 var _SyncEngine = class _SyncEngine {
   constructor(config) {
@@ -3060,16 +3109,14 @@ var _SyncEngine = class _SyncEngine {
         collection: collectionName,
         batch: {
           updates: updates.map((item) => {
-            const _a2 = item.delta, { _ts, _rev: dirtyBaseRev } = _a2, changes = __objRest(_a2, ["_ts", "_rev"]);
-            const stripped = {};
-            for (const [k, v] of Object.entries(changes)) {
-              if (k.startsWith("_ts.") || k.startsWith("_rev.") || k.startsWith("_csq.")) continue;
-              stripped[k] = v;
-            }
+            const dirtyBaseRev = typeof item.delta._rev === "number" ? item.delta._rev : void 0;
+            const stripped = stripServerManagedFromChanges(
+              item.delta
+            );
             const fixed = fixDotnetArrays(
               stripped,
               item.currentServerRev,
-              typeof dirtyBaseRev === "number" ? dirtyBaseRev : void 0
+              dirtyBaseRev
             );
             const cleanedChanges = translateBracketPathsToIndex(fixed, item.fullItem);
             return {
@@ -3624,6 +3671,11 @@ var ServerUpdateHandler = class {
   async handleServerItemInsert(collection, serverItem) {
     const localItem = await this.dexieDb.getById(collection, serverItem._id);
     if (localItem) {
+      const isStaleSelfEcho = serverItem._lastUpdaterId === this.updaterId && typeof serverItem._rev === "number" && typeof localItem._rev === "number" && serverItem._rev <= localItem._rev;
+      if (isStaleSelfEcho) {
+        await this.dexieDb.clearDirtyChange(collection, serverItem._id);
+        return;
+      }
       const dirtyChange = await this.dexieDb.getDirtyChange(collection, serverItem._id);
       const metaChanged = localItem._rev !== serverItem._rev || !this.timestampsEqual(localItem._ts, serverItem._ts);
       if (metaChanged) {
@@ -3649,12 +3701,13 @@ var ServerUpdateHandler = class {
    * Handle server item update (delta).
    */
   async handleServerItemUpdate(collection, localItem, serverDelta) {
-    const isLoopback = serverDelta._lastUpdaterId === this.updaterId && serverDelta._rev !== void 0 && localItem._rev !== void 0 && serverDelta._rev === localItem._rev + 1;
-    if (isLoopback) {
-      const metaChanged2 = localItem._rev !== serverDelta._rev || !this.timestampsEqual(localItem._ts, serverDelta._ts);
-      if (metaChanged2) {
+    const serverRev = serverDelta._rev;
+    const localRev = localItem._rev;
+    const isSelfEcho = serverDelta._lastUpdaterId === this.updaterId && typeof serverRev === "number" && typeof localRev === "number" && serverRev <= localRev + 1;
+    if (isSelfEcho) {
+      if (serverRev > localRev) {
         await this.dexieDb.save(collection, serverDelta._id, {
-          _rev: serverDelta._rev,
+          _rev: serverRev,
           _ts: serverDelta._ts
         });
       }
@@ -4745,6 +4798,7 @@ var _SyncedDb = class _SyncedDb {
       });
       delete update._id;
     }
+    _SyncedDb.ensureNestedIds(update);
     update = _SyncedDb.stringifyObjectIds(update);
     const existing = await this.dexieDb.getById(collection, id);
     if (!existing && !((_a = this.collections.get(collection)) == null ? void 0 : _a.writeOnly)) {
@@ -4775,6 +4829,7 @@ var _SyncedDb = class _SyncedDb {
   async upsert(collection, query, update) {
     this.assertCollection(collection);
     this.ensureId(update, "upsert", collection);
+    _SyncedDb.ensureNestedIds(update);
     query = _SyncedDb.stringifyObjectIds(query);
     update = _SyncedDb.stringifyObjectIds(update);
     const existing = await this.findOne(collection, query);
@@ -4788,6 +4843,7 @@ var _SyncedDb = class _SyncedDb {
     var _a;
     this.assertCollection(collection);
     this.ensureId(data, "insert", collection);
+    _SyncedDb.ensureNestedIds(data);
     data = _SyncedDb.stringifyObjectIds(data);
     const id = String(data._id);
     const existing = await this.dexieDb.getById(collection, id);
@@ -5889,6 +5945,48 @@ var _SyncedDb = class _SyncedDb {
   static isObjectIdLike(v) {
     return !!(v && typeof v === "object" && (v._bsontype === "ObjectId" || typeof v.toHexString === "function"));
   }
+  /**
+   * Recursively walk `value` and ensure every plain object that appears
+   * as an element of an array carries an `_id`. Missing `_id`s are
+   * generated as `new ObjectId().toHexString()` (string, not BSON instance).
+   *
+   * Mutates the input tree in place — caller sees the freshly-assigned ids
+   * (matches the pattern of `ensureId`).
+   *
+   * Why: `computeDiff` falls back to a full-array replace whenever any
+   * element of an array of objects lacks `_id` (see `allElementsHaveId`).
+   * That defeats element-wise `arr[<_id>].field` paths and re-introduces
+   * the stale-array-overwrite bug. Stamping ids upfront keeps every save
+   * on the per-element bracket path.
+   *
+   * Skipped:
+   *   - primitives (numbers, strings, booleans, null, undefined)
+   *   - `Date`, `ObjectId`-like values
+   *   - top-level objects (only ARRAY ELEMENTS get an auto-id; the entity
+   *     itself is handled by `ensureId`)
+   */
+  static ensureNestedIds(value) {
+    if (value === null || value === void 0) return;
+    if (typeof value !== "object") return;
+    if (value instanceof Date) return;
+    if (_SyncedDb.isObjectIdLike(value)) return;
+    if (Array.isArray(value)) {
+      for (const element of value) {
+        if (element !== null && typeof element === "object" && !Array.isArray(element) && !(element instanceof Date) && !_SyncedDb.isObjectIdLike(element)) {
+          if (element._id == null || element._id === "") {
+            element._id = new ObjectId2().toHexString();
+          } else if (_SyncedDb.isObjectIdLike(element._id)) {
+            element._id = String(element._id);
+          }
+        }
+        _SyncedDb.ensureNestedIds(element);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      _SyncedDb.ensureNestedIds(value[key]);
+    }
+  }
   /**
    * Asserts write-only collection has online connectivity for reads.
    * @throws Error if offline

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

@@ -403,6 +403,27 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private static stringifyObjectIds;
     private static isObjectIdLike;
+    /**
+     * Recursively walk `value` and ensure every plain object that appears
+     * as an element of an array carries an `_id`. Missing `_id`s are
+     * generated as `new ObjectId().toHexString()` (string, not BSON instance).
+     *
+     * Mutates the input tree in place — caller sees the freshly-assigned ids
+     * (matches the pattern of `ensureId`).
+     *
+     * Why: `computeDiff` falls back to a full-array replace whenever any
+     * element of an array of objects lacks `_id` (see `allElementsHaveId`).
+     * That defeats element-wise `arr[<_id>].field` paths and re-introduces
+     * the stale-array-overwrite bug. Stamping ids upfront keeps every save
+     * on the per-element bracket path.
+     *
+     * Skipped:
+     *   - primitives (numbers, strings, booleans, null, undefined)
+     *   - `Date`, `ObjectId`-like values
+     *   - top-level objects (only ARRAY ELEMENTS get an auto-id; the entity
+     *     itself is handled by `ensureId`)
+     */
+    private static ensureNestedIds;
     /**
      * Asserts write-only collection has online connectivity for reads.
      * @throws Error if offline

package/dist/src/utils/fixDotnetArrays.d.ts

@@ -13,6 +13,28 @@
  *   "arr.10"               → true  (multi-digit index)
  */
 export declare function hasArrayIndexPath(key: string): boolean;
+/**
+ * `true` if `key` targets an element of the array at `arrayPath`.
+ *
+ * Both inputs are tokenized via `tokenizePath` (so dot AND bracket-by-_id
+ * segments are normalized). The key targets an element iff:
+ *   1. its first N tokens equal `arrayPath`'s tokens (prefix match), AND
+ *   2. the very next token is a numeric index ("0", "1", …) OR a bracket
+ *      `[<_id>]` segment.
+ *
+ * Examples (with arrayPath = "zaracunaj"):
+ *   "zaracunaj"                      → false (same path, not a child)
+ *   "zaracunaj.0.kolicina"           → true  (child via numeric index)
+ *   "zaracunaj[<_id>].kolicina"      → true  (child via bracket _id)
+ *   "zaracunajX"                     → false (different field)
+ *   "zaracunaj.kolicina"             → false (object field, not element)
+ *
+ * Examples (with arrayPath = "_redundanca.terapije"):
+ *   "_redundanca.terapije[A].postavke[B].x" → true
+ *   "_redundanca.terapije.0.x"              → true
+ *   "_redundanca.terapija"                  → false (different field)
+ */
+export declare function pathTargetsArrayElement(key: string, arrayPathTokens: readonly string[]): boolean;
 /**
  * TEMPORARY mitigation: when server has advanced past client's base _rev
  * (i.e., the dirty was emitted against a stale snapshot of the record),

package/dist/src/utils/stripServerManaged.d.ts

@@ -0,0 +1,33 @@
+/**
+ * `true` if `key` (a dot/bracket-notation path) targets a server-managed
+ * metadata field anywhere along its tokenized path.
+ *
+ * Examples:
+ *   "_ts"                           → true
+ *   "_ts.t"                         → true (token `_ts`)
+ *   "_rev"                          → true
+ *   "field._ts"                     → true
+ *   "arr[<_id>]._rev"               → true
+ *   "_redundanca.terapije[X]._ts.i" → true
+ *   "stranka.gsm"                   → false
+ *   "zaracunaj[<_id>].kolicina"     → false
+ */
+export declare function isServerManagedPath(key: string): boolean;
+/**
+ * Recursively scrub `_ts` / `_rev` / `_csq` from a value tree without
+ * mutating the input. Returns a new tree with the offending keys removed
+ * at every depth, including inside arrays.
+ *
+ * Primitives, Date, and ObjectId-like instances pass through by reference.
+ */
+export declare function scrubServerManagedDeep<T>(value: T): T;
+/**
+ * Strip server-managed metadata from a dirty-changes payload at upload time.
+ *
+ *   1. Drop any path key whose tokenized path includes `_ts`, `_rev`, or `_csq`.
+ *   2. For surviving entries, recursively scrub the value (in case a value is
+ *      a full object/array replace that contains nested `_ts` / `_rev`).
+ *
+ * Returns a new object — input is not mutated.
+ */
+export declare function stripServerManagedFromChanges(changes: Record<string, unknown>): Record<string, unknown>;

package/package.json

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