cry-synced-db-client 0.1.176 → 0.1.177

package/CHANGELOG.md

@@ -1,6 +1,62 @@
 # Versions
 
-## Unreleased
+## 0.1.177 (2026-05-13)
+
+Hot-path micro-optimizations from a ts-coding skill audit. Five small wins,
+each verified independently against the actual control flow before applying.
+
+### `$regex` operand cached per pattern
+
+`matchesOperator` for `$regex` used to call `new RegExp(operand)` on every
+record × operator invocation. For in-mem `find` over a large collection
+this recompiled the same pattern thousands of times. Now a module-level
+`Map<string, RegExp>` caches compiled regexes by operand string with a
+bounded FIFO eviction (128 entries) so dynamic patterns don't leak.
+Implementation in `src/utils/localQuery.ts:compileRegex`.
+
+### `SyncedDb.close()` is idempotent
+
+Added a `this.closed` guard that early-returns on the second call. Most
+disposal calls inside `close()` were already idempotent (timer clears,
+listener removes), but `crossTabSync.dispose()`, `wakeSync.dispose()`,
+`networkStatus.dispose()`, and `serverUpdateNotifier.dispose?.()` are not
+internally guarded — calling them twice could throw. Now safe.
+
+### Orphan dirty reconstruction batches into `saveMany`
+
+`SyncEngine.uploadDirtyItems` reconstructs missing main rows when a dirty
+change exists but the main entry was lost (e.g. debounced write didn't
+flush before reload). Previously called `await dexieDb.save(...)` per
+orphan inside the per-item loop. Now collects reconstructed entities and
+issues one `saveMany` at the end. Rare path — minor improvement, no
+behavior change.
+
+### `sentIds` warning path drops intermediate spreads
+
+`SyncEngine.uploadDirtyItems` builds a `sentIds` Set for the
+"unacknowledged items" warning. Previously used
+`new Set([...batches.flat().filter(...).flatMap(...)])` (multiple array
+allocations) and `[...sentIds].filter(...)` (one more spread). Now a
+single for-of pass into a Set, plus a direct iteration to build `unacked`.
+
+### `ServerUpdateHandler` batch case now concurrent
+
+WebSocket batch server-update notifications previously processed each
+insert / update / delete with sequential `await` calls. Each per-item
+handler operates on an independent `_id`; Dexie reads/writes on different
+keys don't conflict, so replaced the loops with `Promise.all` over the
+per-item handlers. On a batch of N items this turns N sequential IDB
+round-trips into N concurrent ones — the dominant latency win for any
+tab subscribed to a busy collection.
+
+The deeper "single `getByIds` + `saveMany` per batch" refactor was
+deferred: the per-item update handler has 5+ semantically distinct
+branches (self-echo A/B/C, pending change merge, dirty merge, clean
+meta-only) and duplicating that logic for the batch path carries
+re-implementation risk that isn't justified by the additional latency
+savings over `Promise.all`.
+
+## 0.1.176 (2026-05-13)
 
 ### Passive transport metrics on `findNewerManyStream` round-trip (rdb2)
 
@@ -104,6 +160,8 @@ Live test (localhost, warm, 20 samples): WS p50 0.30 ms, E2E p50
 4.11 ms. Mock-only unit tests in `test/measureRtt.test.ts` (7 cases —
 delegation, propagated rejection, no-notifier error, shape sanity).
 
+## 0.1.175 (2026-05-13)
+
 ### `save(coll, id, {field: {}})` clears existing nested children
 
 `computeDiffInto` for plain objects iterated only `Object.keys(update)`,
@@ -176,6 +234,37 @@ await syncedDb.replaceSyncCollection({
 });
 ```
 
+## 0.1.174 (2026-05-12)
+
+### Fix: overlay `_dirty_changes` onto in-mem on init
+
+After Ctrl+R while a debounced Dexie main write was pending, the in-mem
+cache showed stale Dexie main state instead of the merged dirty diff —
+UI readers saw old field values until the next sync round-trip.
+Production incident, klikvet 2026-05-12 with the server offline.
+
+Root cause: `loadCollectionToInMem` (called from `init()`) read only the
+Dexie main table; it never overlaid `_dirty_changes`.
+`recoverPendingWrites` recovers from `localStorage`, but `localStorage`
+may have been cleared by an earlier partial-debounce success — the
+Dexie-only `_dirty_changes` table is the durable source for those
+writes.
+
+Fix: after loading Dexie main, walk `_dirty_changes` and apply each diff
+to the matching main row via `applyDiffLocally`. Orphan dirty (no
+matching main row) is included in in-mem with a `console.warn`. Dirty
+entries marking `_deleted` / `_archived` remove the record from in-mem.
+
+Scope: in-mem cache only. `findById` uses the in-mem fast path, so its
+results now reflect dirty. `find()` reads Dexie main directly — that's
+a separate Dexie-overlay gap, not addressed here.
+
+Regression test: `test/dirtyOverlayOnInit.test.ts` (5 cases — production
+scenario, orphan, soft-delete via dirty, no-dirty fast path, multiple
+records). 708 pass / 0 fail.
+
+## 0.1.173 (2026-05-12)
+
 ### `preprocessDirtyItem` callback — per-item filter / transform before upload
 
 New optional config callback fired for **every** dirty item just before it
@@ -212,6 +301,8 @@ new SyncedDb({
 Useful for: per-tenant data sanitization, conditional upload gating,
 audit-trail injection.
 
+## 0.1.172 (2026-05-12)
+
 ### Nested-bracket terminal layering in `mergeDirtyPath` Case 2
 
 When a new terminal-bracket whole-element write arrives AFTER pending
@@ -250,6 +341,8 @@ alongside actual upload errors in observability pipelines.
 `SUPRESS_DB_WARNINGS` constant in `SyncEngine.ts` silences them when
 needed (e.g. during noisy migrations).
 
+## 0.1.171 (2026-05-11)
+
 ### Runtime collection registration (`addCollectionToSync`, `replaceSyncCollection`)
 
 Two methods to install / replace collection configs at runtime; both load the
@@ -346,6 +439,8 @@ const sinceMs = isLeader
   : Date.now() - syncedDb.followerSince()!.getTime();
 ```
 
+## 0.1.163 (2026-05-10)
+
 ### `onServerSyncWrite` callback
 
 Single-shot callback that fires once per `restInterface.updateCollections`
@@ -383,7 +478,7 @@ parity across **mongo + Dexie + in-mem** simultaneously after a partial
 `save({ postavke: [{_id: "P1", kolicina: 2}] })` over an existing
 `postavke[0] = {_id: "P1", opis: "postavka 1", kolicina: 1}`.
 
-## 0.1.162
+## 0.1.162 (2026-05-10)
 
 ### Bracket-by-_id paths flow through server unchanged
 
@@ -438,7 +533,7 @@ Replaced with `applyDiffLocally(base, diff, id)`:
 
 `deleteByPath` is now a sibling export of `setByPath` in `computeDiff.ts`.
 
-## 0.1.161
+## 0.1.161 (2026-05-10)
 
 ### Don't auto-stamp `_id` on bracket-array elements
 
@@ -449,7 +544,7 @@ preserved. This allows callers to mix:
 - Bracket-by-_id sub-field path: `update["postavke[<id>].field"] = value`
 in the same payload without the client mutating element identity.
 
-## 0.1.160
+## 0.1.160 (2026-05-09)
 
 ### Composition changes emit precise paths (not full-array replace)
 
@@ -471,7 +566,7 @@ Pre-fix, composition change emitted full-array replace at `basePath`,
 which `mergeDirtyPath` Case 2 then dropped pending sub-field paths on
 the same parent — race-y data-loss strip pattern visible in production.
 
-## 0.1.159
+## 0.1.159 (2026-05-09)
 
 ### Self-echo WS suppression for `_rev <= local._rev`
 
@@ -490,11 +585,11 @@ older snapshot because a self-echo WS arrived after writeback and
 overwrote in-mem with the server's `$set`-iterated copy of postavke
 (missing freshly-set `pop` and `navodilo` fields). Now in-mem is preserved.
 
-## 0.1.158
+## 0.1.158 (2026-05-09)
 
 Internal version bump consolidating 0.1.157 fixes for production publish.
 
-## 0.1.157
+## 0.1.157 (2026-05-08)
 
 ### Recursive server-managed metadata strip at upload boundary
 
@@ -531,7 +626,7 @@ stuck-dirty payload (mixing top-level full arrays with bracket paths)
 into Dexie's `_dirty_changes` and asserts upload succeeds without
 mongo path-conflict errors via a `MongoFaithfulRestInterface` mock.
 
-## 0.1.156
+## 0.1.156 (2026-05-08)
 
 Three related fixes targeting **dirty-payload metadata leak** and
 **concurrent array merge corruption** observed in production
@@ -607,7 +702,7 @@ Temporary upload-time scrubber dropping legacy position-based array
 paths (`field.<digit>(.…)?`) when `serverRev > baseRev`. Marked for
 removal after ~2026-05-15 once all clients have re-synced.
 
-## 0.1.155
+## 0.1.155 (2026-05-08)
 
 Two new `SyncedDbConfig` fields targeting **cross-device scope-exit**
 detection: situations where one device modifies a record so it no longer
@@ -664,7 +759,7 @@ wake.
 - `_collectScopeExitPlan` and single-collection `evictOutOfScopeRecords`
   both route through the new helper.
 
-## Unreleased
+## 0.1.149 (2026-04-27)
 
 ### `SyncSource` flag in `I_InMemDb.saveMany` / `deleteManyByIds`
 
@@ -702,6 +797,8 @@ Tests: `test/syncSource.test.ts` (9 cases) covers initial / incremental
 / refresh propagation across all public write paths. `MockInMemDb`
 exposes `recordedCalls: RecordedInMemCall[]` for assertion.
 
+## 0.1.148 (2026-04-26)
+
 ### `uploadDirtyItems` follow-up pass — drain in-sync writes immediately
 
 Writes that land **during** a sync iteration had their
@@ -732,6 +829,8 @@ first pass — a follow-up failure does not roll back the first pass's
 already-cleared dirty entries; affected items are caught at the next
 sync tick (same retry semantics as before).
 
+## 0.1.147 (2026-04-25)
+
 ### Auto-eviction co-located with sync — one round-trip total
 
 When `evictStaleRecordsEveryHrs > 0` and the interval has elapsed, the
@@ -803,6 +902,8 @@ request carry multiple specs against the same collection without
   library always populates them. Downstream code that constructs mock
   literals (e.g. tests) needs the new fields.
 
+## 0.1.144 (2026-04-24)
+
 ### Fix: filtered-sync tombstone (scope-exit from other writers)
 
 When a collection has `syncConfig.query` (e.g. `{ status: { $ne: "obsolete" } }`)
@@ -837,6 +938,8 @@ predicate (no implicit server policy).
   `$nor` support, required for the negated query to evaluate against the test
   mock and for any client-side filtering that uses logical operators.
 
+## 0.1.142 (2026-04-21)
+
 ### `getDirtyMeta()` for lightweight dirty-state inspection
 
 - New `SyncedDb.getDirtyMeta()` returns dirty-entry meta (everything except the
@@ -867,6 +970,8 @@ Two contributing causes, both fixed:
   cache learns of them via the existing shared-Dexie reload path. Reload
   broadcasts (post-full-sync) remain leader-only.
 
+## 0.1.141 (2026-04-21)
+
 ### BREAKING: Self-healing sync/reconnect lifecycle
 
 Fixes a class of bugs where the 60s auto-sync scheduler silently died after a
@@ -897,17 +1002,21 @@ tenants, 62–296 min of dead scheduler with dirty items accumulating.
 `onForcedOffline: (reason) => log(reason)` → `onSyncFailed: (reason) => log(reason)`.
 Signature is identical. No other callback changes.
 
-- Add `refreshInBackground` `QueryOpts` option for `findById` / `findByIds`
-  - Stale-while-revalidate: cache-hit returns local result immediately and
-    triggers a background fetch that updates Dexie + in-mem through conflict
-    resolution (`processCollectionServerData`).
-  - Orthogonal to `referToServer` — does not change miss behaviour. With
-    defaults (`referToServer: true`) misses are still awaited; with
-    `referToServer: false` misses return `null` and bg fetch loads them async.
-  - Dedupes against `referToServer`: IDs fetched blockingly are NOT re-fetched
-    in the background (no double-round-trip).
-  - Noop when offline or on writeOnly collections.
-  - Ignored on `find` / `findOne` (use `referToServer` there).
+## 0.1.139 (2026-04-21)
+
+### `refreshInBackground` `QueryOpts` option for `findById` / `findByIds`
+
+Stale-while-revalidate: cache-hit returns the local result immediately and
+triggers a background fetch that updates Dexie + in-mem through conflict
+resolution (`processCollectionServerData`).
+
+- Orthogonal to `referToServer` — does not change miss behaviour. With
+  defaults (`referToServer: true`) misses are still awaited; with
+  `referToServer: false` misses return `null` and bg fetch loads them async.
+- Dedupes against `referToServer`: IDs fetched blockingly are NOT re-fetched
+  in the background (no double-round-trip).
+- Noop when offline or on writeOnly collections.
+- Ignored on `find` / `findOne` (use `referToServer` there).
 
 ## 0.1.146 (2026-04-25)
 

package/dist/index.js

@@ -37,6 +37,21 @@ import Dexie2 from "dexie";
 import { ObjectId as ObjectId2 } from "bson";
 
 // src/utils/localQuery.ts
+var regexCache = /* @__PURE__ */ new Map();
+var REGEX_CACHE_MAX = 128;
+function compileRegex(operand) {
+  if (operand instanceof RegExp) return operand;
+  const key = String(operand);
+  let r = regexCache.get(key);
+  if (r) return r;
+  r = new RegExp(key);
+  if (regexCache.size >= REGEX_CACHE_MAX) {
+    const oldest = regexCache.keys().next().value;
+    if (oldest !== void 0) regexCache.delete(oldest);
+  }
+  regexCache.set(key, r);
+  return r;
+}
 function matchesQuery(item, query) {
   for (const [key, condition] of Object.entries(query)) {
     if (key === "$and") {
@@ -107,7 +122,7 @@ function matchesOperator(value, operator, operand) {
     case "$exists":
       return operand ? value !== void 0 : value === void 0;
     case "$regex": {
-      const regex = operand instanceof RegExp ? operand : new RegExp(operand);
+      const regex = compileRegex(operand);
       if (typeof value === "string") return regex.test(value);
       if (Array.isArray(value)) {
         return value.some((v) => typeof v === "string" && regex.test(v));
@@ -3253,6 +3268,7 @@ var _SyncEngine = class _SyncEngine {
       const skipped = [];
       const ids = dirtyChanges.map((dc) => dc._id);
       const fullItems = await this.dexieDb.getByIds(collectionName, ids);
+      const orphanReconstructed = [];
       for (let i = 0; i < fullItems.length; i++) {
         const fullItem = fullItems[i];
         const id = ids[i];
@@ -3268,7 +3284,7 @@ var _SyncEngine = class _SyncEngine {
           const delta = dirtyChangesMap.get(String(id));
           if (delta) {
             const reconstructed = __spreadProps(__spreadValues({}, delta), { _id: id });
-            await this.dexieDb.save(collectionName, id, reconstructed);
+            orphanReconstructed.push(reconstructed);
             updates.push({ _id: id, delta });
           } else {
             skipped.push({ _id: String(id), reason: "no-delta-for-orphan" });
@@ -3277,6 +3293,9 @@ var _SyncEngine = class _SyncEngine {
           skipped.push({ _id: "<null>", reason: "no-fullitem-no-id" });
         }
       }
+      if (orphanReconstructed.length > 0) {
+        await this.dexieDb.saveMany(collectionName, orphanReconstructed);
+      }
       if (updates.length === 0) {
         console.warn(
           `[SyncEngine] uploadDirtyItems: ${collectionName} has ${dirtyChanges.length} dirty entries but 0 resolvable items`,
@@ -3536,14 +3555,20 @@ var _SyncEngine = class _SyncEngine {
           );
         }
       }
-      const sentIds = /* @__PURE__ */ new Set([
-        ...collectionBatches.flat().filter((b) => b.collection === collection).flatMap((b) => [
-          ...b.batch.updates.map((u) => String(u._id)),
-          ...b.batch.deletes.map((d) => String(d._id))
-        ])
-      ]);
-      const ackIds = new Set(allSuccessIds.map(String));
-      const unacked = [...sentIds].filter((id) => !ackIds.has(id));
+      const sentIds = /* @__PURE__ */ new Set();
+      for (const batch of collectionBatches) {
+        for (const b of batch) {
+          if (b.collection !== collection) continue;
+          for (const u of b.batch.updates) sentIds.add(String(u._id));
+          for (const d of b.batch.deletes) sentIds.add(String(d._id));
+        }
+      }
+      const ackIds = /* @__PURE__ */ new Set();
+      for (const id of allSuccessIds) ackIds.add(String(id));
+      const unacked = [];
+      for (const id of sentIds) {
+        if (!ackIds.has(id)) unacked.push(id);
+      }
       if (unacked.length > 0) {
         console.warn(
           `[SyncEngine] uploadDirtyItems: ${collection}: ${unacked.length} items sent but not acknowledged:`,
@@ -3977,39 +4002,57 @@ var ServerUpdateHandler = class {
             deletes.push(item.data);
           }
         }
-        for (const serverItem of inserts) {
-          await this.handleServerItemInsert(collectionName, serverItem);
-          updatedIds.push(String(serverItem._id));
+        if (inserts.length > 0) {
+          await Promise.all(
+            inserts.map(
+              (serverItem) => this.handleServerItemInsert(collectionName, serverItem)
+            )
+          );
+          for (const serverItem of inserts) {
+            updatedIds.push(String(serverItem._id));
+          }
         }
         if (updates.length > 0) {
           const updateIds = updates.map((u) => u._id);
           const localItems = await this.dexieDb.getByIds(collectionName, updateIds);
           const missingIds = [];
+          const updatePromises = [];
           for (let i = 0; i < updates.length; i++) {
             const deltaData = updates[i];
             const localItem = localItems[i];
             if (localItem) {
-              await this.handleServerItemUpdate(collectionName, localItem, deltaData);
+              updatePromises.push(
+                this.handleServerItemUpdate(collectionName, localItem, deltaData)
+              );
               updatedIds.push(String(deltaData._id));
             } else {
               missingIds.push(deltaData._id);
             }
           }
+          if (updatePromises.length > 0) await Promise.all(updatePromises);
           if (missingIds.length > 0) {
             const fullItems = await this.restInterface.findByIds(
               collectionName,
               missingIds
             );
+            const insertPromises = [];
             for (const fullItem of fullItems) {
               if (!fullItem) continue;
-              await this.handleServerItemInsert(collectionName, fullItem);
+              insertPromises.push(
+                this.handleServerItemInsert(collectionName, fullItem)
+              );
               updatedIds.push(String(fullItem._id));
             }
+            if (insertPromises.length > 0) await Promise.all(insertPromises);
           }
         }
-        for (const deleteData of deletes) {
-          await this.handleServerItemDelete(collectionName, deleteData._id);
-          updatedIds.push(String(deleteData._id));
+        if (deletes.length > 0) {
+          await Promise.all(
+            deletes.map((d) => this.handleServerItemDelete(collectionName, d._id))
+          );
+          for (const deleteData of deletes) {
+            updatedIds.push(String(deleteData._id));
+          }
         }
         break;
       }
@@ -4346,6 +4389,7 @@ var _SyncedDb = class _SyncedDb {
     this.collections = /* @__PURE__ */ new Map();
     // State
     this.initialized = false;
+    this.closed = false;
     this.syncing = false;
     this.syncLock = false;
     this.wsUpdateQueue = [];
@@ -4884,6 +4928,8 @@ var _SyncedDb = class _SyncedDb {
   }
   async close() {
     var _a, _b;
+    if (this.closed) return;
+    this.closed = true;
     this.leaderElection.setClosing(true);
     this.pendingChanges.cancelRestUploadTimer();
     this.connectionManager.stopTimers();

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

@@ -24,6 +24,7 @@ export declare class SyncedDb implements I_SyncedDb {
     private readonly wakeSync?;
     private readonly networkStatus?;
     private initialized;
+    private closed;
     private syncing;
     private syncLock;
     private wsUpdateQueue;

package/package.json

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