cry-synced-db-client 0.1.193 → 0.1.195

package/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Versions
 
-## 0.1.192 (2026-05-25)
+## 0.1.195 (2026-06-09)
+
+### `ensureItemsAreLoaded` always fetches all IDs from server
+
+`findById` / `findByIds` z `referToServer: true` (privzeto) sedaj **vedno
+awaitata** server klic za vse zahtevane ID-je. Prej je `ensureItemsAreLoaded`
+preverila Dexie in klicala server samo za ID-je, ki v Dexie niso obstajali.
+To je pomenilo, da je ob in-mem cache missu (item ni v in-mem, ampak je v
+Dexie) `referToServer` vrnil stale podatke brez server klica.
+
+Popravek: `ensureItemsAreLoaded` ne preverja več Dexie pred server klicem
+— vedno fetča vse ID-je iz `restInterface.findByIds`, jih shrani v Dexie +
+in-mem. `referToServer` zdaj resnično awaita sveže podatke s serverja.
+
+Internal: `ensureItemsAreLoaded` — odstranjena Dexie pre-check (`getByIds`
+→ `missingIds`).
+
+
+## 0.1.194 (2026-06-09)
+
+### Preload status `ready` fix
+
+`ready` flag na `CollectionPreloadStatus` se sedaj nastavi na `true` že ko
+je `state === "hydrated"`, ne glede na `itemCount` ali `everDownloaded`.
+Prazen (še nikoli sinhroniziran) direktorij je še vedno ready — svežina
+podatkov je globalni koncept (`lastSuccessfulServerSync`).
+
+
+## 0.1.193 (2026-05-25)
 
 Adds per-collection preload status reporting (non-breaking, additive).
 
@@ -11,10 +39,12 @@ New synchronous getter `getPreloadStatus(): PreloadStatus` and config callback
 (non-`writeOnly`), in-scope collection:
 
 - Per-collection `state` (`pending` / `hydrated` / `failed`), `itemCount`,
-  `lastError`, `everDownloaded`, and a derived `ready` flag
-  (`ready = hydrated && (itemCount > 0 || everDownloaded)` — a hydrated-but-empty
-  collection that was never downloaded is **not** ready, so a fresh device
-  doesn't report "full" before its first server sync).
+  `lastError`, `everDownloaded` (informational), and a derived `ready` flag
+  (`ready = (state === "hydrated")` — the local cache is loaded into in-mem;
+  empty is valid). Data *freshness* is a separate, global concern
+  (`lastSuccessfulServerSync`), deliberately **not** folded into `ready`:
+  gating on a per-collection cursor wedged the aggregate at `partial` for
+  genuinely-empty, never-synced collections (every tenant has several).
 - Rolled-up `aggregate`: `idle` / `full` / `partial` / `failed`.
 
 The callback fires on each hydration transition (success/failure), on scope

package/dist/index.js

@@ -5745,17 +5745,9 @@ var _SyncedDb = class _SyncedDb {
     this.assertCollection(collection);
     if ((_a = this.collections.get(collection)) == null ? void 0 : _a.writeOnly) return;
     if (ids.length === 0) return;
-    const localItems = await this.dexieDb.getByIds(collection, ids);
-    const missingIds = [];
-    for (let i = 0; i < ids.length; i++) {
-      if (!localItems[i]) {
-        missingIds.push(ids[i]);
-      }
-    }
-    if (missingIds.length === 0) return;
     if (!this.isOnline()) return;
     const serverItems = await this.connectionManager.withRestTimeout(
-      this.restInterface.findByIds(collection, missingIds),
+      this.restInterface.findByIds(collection, ids),
       "ensureItemsAreLoaded"
     );
     if (!serverItems || serverItems.length === 0) return;
@@ -6971,7 +6963,7 @@ var _SyncedDb = class _SyncedDb {
       if (!this.isSyncAllowed(name)) continue;
       const rec = (_a = this.preloadStatusMap.get(name)) != null ? _a : { state: "pending", itemCount: 0 };
       const everDownloaded = !!((_b = this.syncMetaCache.get(name)) == null ? void 0 : _b.lastSyncTs);
-      const ready = rec.state === "hydrated" && (rec.itemCount > 0 || everDownloaded);
+      const ready = rec.state === "hydrated";
       if (rec.state === "failed") failedCount++;
       else if (ready) readyCount++;
       else pendingCount++;

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

@@ -411,18 +411,21 @@ export interface CollectionPreloadStatus {
     /** In-mem item count after the last successful hydration (0 is valid). */
     itemCount: number;
     /**
-     * Whether the collection is considered ready: hydrated AND either has data
-     * (`itemCount > 0`) or its cursor has advanced via a server download
-     * (`everDownloaded`). A hydrated-but-empty collection that was never
-     * downloaded is NOT ready — we can't tell "genuinely empty" from
-     * "not fetched yet".
+     * Whether the local cache is loaded into in-mem (`state === "hydrated"`).
+     * Empty is valid — a genuinely empty, never-synced collection is still ready.
+     * Data *freshness* is a separate, global concern (`lastSuccessfulServerSync`),
+     * not tracked per-collection.
      */
     ready: boolean;
     /** Timestamp of the last successful Dexie→in-mem hydration. */
     hydratedAt?: Date;
     /** Error message from the last failed hydration (set when `state === "failed"`). */
     lastError?: string;
-    /** True once a server download has advanced this collection's cursor (`lastSyncTs` set). */
+    /**
+     * Informational: true once a server download has advanced this collection's
+     * cursor (`lastSyncTs` set). NOT part of `ready` — an unused collection may
+     * never get a cursor yet is perfectly loadable.
+     */
     everDownloaded: boolean;
 }
 /** Rolled-up preload status across all readable, in-scope collections. */

package/package.json

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