cry-synced-db-client 0.1.173 → 0.1.175

package/CHANGELOG.md

@@ -2,6 +2,78 @@
 
 ## Unreleased
 
+### `save(coll, id, {field: {}})` clears existing nested children
+
+`computeDiffInto` for plain objects iterated only `Object.keys(update)`,
+so an update like `{cepljenja: {}}` against an existing
+`{cepljenja: {<id>: {…}}}` emitted **zero diff entries** — children were
+preserved silently. Empty-object value is now treated as a full replace
+of the field (symmetric with `{field: []}` array replace and
+`{field: undefined}` delete).
+
+```typescript
+// existing.cepljenja = { "<id>": { …data } }
+await syncedDb.save("pacienti", id, { cepljenja: {} });
+// after: pacient.cepljenja === {} — children physically removed in
+// in-mem, Dexie, and the dirty payload
+```
+
+Implementation in `src/utils/computeDiff.ts:computeDiffInto`: when both
+sides are plain objects and `update` has zero keys while `existing` has
+some, emit `diff[basePath] = {}` instead of falling through to the
+"iterate update keys" loop. The earlier `deepEquals(existing, update)`
+guard still short-circuits the `{} → {}` no-op case.
+
+Regression test: `test/saveEmptyObjectClearsChildren.test.ts` (4 cases:
+in-mem clear, Dexie clear, dirty payload emits wipe, sibling fields
+preserved). 721 pass / 0 fail.
+
+### `findById` / `findByIds` auto-register unconfigured collections as temporary
+
+Calling `findById(collection, id)` or `findByIds(collection, ids)` for a
+collection NOT in the runtime sync config (e.g. boot-time `collections: [...]`)
+no longer throws. Instead the collection is auto-registered as
+**temporary** with `syncConfig.query: () => ({_id: {$in: [<ids>]}})`. The
+call then proceeds through the normal flow — `referToServer` (default
+`true`) loads the row from the server on cache miss and returns it.
+
+Behavior on subsequent calls (inspected against the existing config's
+`syncConfig.query` shape, no extra bookkeeping state):
+
+| Existing config | Action |
+|---|---|
+| none | install `{_id: {$in: [<ids>]}}` (static object) |
+| temporary, query matches `{_id: {$in: [...]}}` | append novel ids to the existing `$in` array |
+| temporary, query is a function / different shape / absent | skip — leave alone |
+| permanent | skip — never touch a permanent config |
+
+`replaceSyncCollection` naturally resets accumulation by overwriting the
+spec; the new config (whatever shape) drives future syncs alone.
+
+Constraints:
+- Dexie schema must already declare the table (Dexie does not support
+  adding tables to an open database). The auto-register handles only the
+  runtime SyncedDb-level config.
+- An active `syncOnlyTheseCollections` filter (non-null — set via
+  `setSyncOnlyTheseCollections([…])` with at least one entry) is extended
+  to include the new temp collection so it participates in future sync
+  ticks. When no filter is set (sync-all mode), this step is a no-op.
+
+```typescript
+// No runtime config for "zivali" — boot only registers "racuni".
+new SyncedDb({ collections: [{ name: "racuni" }], dexieDb /* has zivali */, ... });
+
+// Previously: throws "Collection 'zivali' not configured".
+// Now: auto-registers as temporary, fetches via referToServer, returns.
+const zival = await syncedDb.findById("zivali", id);
+
+// Upgrade to permanent when the app wires up real sync:
+await syncedDb.replaceSyncCollection({
+  name: "zivali",
+  syncConfig: { query: () => ({ vrsta: "pes" }) },
+});
+```
+
 ### `preprocessDirtyItem` callback — per-item filter / transform before upload
 
 New optional config callback fired for **every** dirty item just before it

package/dist/index.js

@@ -440,6 +440,10 @@ function computeDiffInto(existing, update, basePath, diff) {
     diff[basePath] = update;
     return;
   }
+  if (Object.keys(update).length === 0 && Object.keys(existing).length > 0) {
+    diff[basePath] = update;
+    return;
+  }
   for (const key of Object.keys(update)) {
     const childPath = basePath ? `${basePath}.${key}` : key;
     computeDiffInto(existing[key], update[key], childPath, diff);
@@ -4871,6 +4875,7 @@ var _SyncedDb = class _SyncedDb {
   // ==================== Read Operations ====================
   async findById(collection, id, opts) {
     var _a;
+    this._autoRegisterTemporaryForFind(collection, [id]);
     this.assertCollection(collection);
     if (!id) {
       const err = new Error(`[SyncedDb] findById ${collection} no id ${id}`);
@@ -4928,6 +4933,7 @@ var _SyncedDb = class _SyncedDb {
   }
   async findByIds(collection, ids, opts) {
     var _a;
+    this._autoRegisterTemporaryForFind(collection, ids);
     this.assertCollection(collection);
     ids = ids.map((id) => this.normalizeId(id, "findByIds", collection));
     opts = this.resolveOpts(opts);
@@ -6262,6 +6268,44 @@ var _SyncedDb = class _SyncedDb {
         }
       }
     });
+    const dirty = await this.dexieDb.getDirty(name);
+    if (dirty.length > 0) {
+      const itemById = /* @__PURE__ */ new Map();
+      for (let i = 0; i < allItems.length; i++) {
+        itemById.set(String(allItems[i]._id), allItems[i]);
+      }
+      let orphanCount = 0;
+      for (const dirtyItem of dirty) {
+        const id = dirtyItem._id;
+        if (id == null) continue;
+        const idStr = String(id);
+        const existing = itemById.get(idStr);
+        const diff = {};
+        for (const key of Object.keys(dirtyItem)) {
+          if (key === "_id" || key === "_ts" || key === "_rev") continue;
+          diff[key] = dirtyItem[key];
+        }
+        const merged = _SyncedDb.applyDiffLocally(
+          existing != null ? existing : null,
+          diff,
+          id,
+          name
+        );
+        if (merged._deleted || merged._archived) {
+          itemById.delete(idStr);
+          continue;
+        }
+        if (!existing) orphanCount++;
+        itemById.set(idStr, merged);
+      }
+      if (orphanCount > 0) {
+        console.warn(
+          `[SyncedDb] init(${name}): ${orphanCount} dirty record(s) had no matching Dexie main row \u2014 included in in-mem pending next sync.`
+        );
+      }
+      allItems.length = 0;
+      for (const item of itemById.values()) allItems.push(item);
+    }
     this.inMemManager.initCollection(name, allItems);
     const meta = await this.dexieDb.getSyncMeta(name);
     if (meta) {
@@ -6293,6 +6337,68 @@ var _SyncedDb = class _SyncedDb {
       throw new Error(`SyncedDb: Collection "${(name == null ? void 0 : name.toString()) || "?"}" not configured`);
     }
   }
+  /**
+   * Auto-register an unconfigured collection as TEMPORARY when `findById` /
+   * `findByIds` is called for it. The collection becomes part of the sync
+   * scope with a `{_id: {$in: <ids>}}` static query so future sync ticks
+   * keep those rows fresh.
+   *
+   * Behavior matrix:
+   *
+   * | Existing config | Action |
+   * |---|---|
+   * | none | install temp with `query: {_id: {$in: [<ids>]}}` |
+   * | temporary, query is `{_id: {$in: [...]}}` | append novel `<ids>` to the existing `$in` array |
+   * | temporary, query is anything else (function, different shape, missing) | skip — leave config untouched |
+   * | permanent | skip — never alter a permanent config |
+   *
+   * No extra state map — accumulation lives in the config's own `$in`
+   * array. `replaceSyncCollection` (or any other path that installs a new
+   * config) naturally resets accumulation by overwriting the config.
+   *
+   * Cheap fast paths: synchronous, no Dexie/server I/O. The regular
+   * `findById` flow (in-mem cache → `referToServer` → `ensureItemsAreLoaded`)
+   * handles the actual data load for THIS call.
+   *
+   * If an `syncOnlyTheseCollections` filter is active (non-null, i.e.
+   * `setSyncOnlyTheseCollections([…])` was called with at least one
+   * entry), a newly-installed temp collection is added to the filter so
+   * it participates in future sync ticks. When no filter is set
+   * (sync-all mode), this step is a no-op.
+   */
+  _autoRegisterTemporaryForFind(name, ids) {
+    var _a;
+    const idStrings = ids.map((id) => String(id));
+    const existing = this.collections.get(name);
+    if (!existing) {
+      this.collections.set(name, {
+        name,
+        temporaryConfig: true,
+        syncConfig: {
+          query: { _id: { $in: idStrings } }
+        }
+      });
+      if (this.syncOnlyCollections) {
+        this.syncOnlyCollections.add(name);
+      }
+      return;
+    }
+    if (!existing.temporaryConfig) return;
+    const query = (_a = existing.syncConfig) == null ? void 0 : _a.query;
+    if (typeof query !== "object" || query === null) return;
+    const idField = query._id;
+    if (typeof idField !== "object" || idField === null) return;
+    const inArr = idField.$in;
+    if (!Array.isArray(inArr)) return;
+    const seen = /* @__PURE__ */ new Set();
+    for (const existingId of inArr) seen.add(String(existingId));
+    for (const id of idStrings) {
+      if (!seen.has(id)) {
+        inArr.push(id);
+        seen.add(id);
+      }
+    }
+  }
   /** Stringify an Id parameter (ObjectId → hex string). */
   normalizeId(id, method, collection) {
     if (!id && id !== void 0) {

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

@@ -426,6 +426,36 @@ export declare class SyncedDb implements I_SyncedDb {
      */
     private preloadAllSyncMetas;
     private assertCollection;
+    /**
+     * Auto-register an unconfigured collection as TEMPORARY when `findById` /
+     * `findByIds` is called for it. The collection becomes part of the sync
+     * scope with a `{_id: {$in: <ids>}}` static query so future sync ticks
+     * keep those rows fresh.
+     *
+     * Behavior matrix:
+     *
+     * | Existing config | Action |
+     * |---|---|
+     * | none | install temp with `query: {_id: {$in: [<ids>]}}` |
+     * | temporary, query is `{_id: {$in: [...]}}` | append novel `<ids>` to the existing `$in` array |
+     * | temporary, query is anything else (function, different shape, missing) | skip — leave config untouched |
+     * | permanent | skip — never alter a permanent config |
+     *
+     * No extra state map — accumulation lives in the config's own `$in`
+     * array. `replaceSyncCollection` (or any other path that installs a new
+     * config) naturally resets accumulation by overwriting the config.
+     *
+     * Cheap fast paths: synchronous, no Dexie/server I/O. The regular
+     * `findById` flow (in-mem cache → `referToServer` → `ensureItemsAreLoaded`)
+     * handles the actual data load for THIS call.
+     *
+     * If an `syncOnlyTheseCollections` filter is active (non-null, i.e.
+     * `setSyncOnlyTheseCollections([…])` was called with at least one
+     * entry), a newly-installed temp collection is added to the filter so
+     * it participates in future sync ticks. When no filter is set
+     * (sync-all mode), this step is a no-op.
+     */
+    private _autoRegisterTemporaryForFind;
     private static readonly STRINGIFIED_FALSY;
     /** Stringify an Id parameter (ObjectId → hex string). */
     private normalizeId;

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

@@ -864,6 +864,13 @@ export interface I_SyncedDb {
      *   jih v ozadju revalidira s serverja (Dexie + in-mem skozi konflikt
      *   resolucijo). Ortogonalno do referToServer; ne povzroči duplikata
      *   server klicev za missing ID-je.
+     *
+     * Auto-registracija: če `collection` ni registrirana v runtime sync
+     * configu, se avtomatsko doda kot **temporary** s queryjem
+     * `{_id: {$in: [<id>]}}`. Dexie schema mora že imeti tabelo
+     * (Dexie ne podpira dodajanja tabel ob runtime-u). Klic nato teče
+     * skozi normalen findById flow — `referToServer` (privzeto `true`)
+     * naloži zapis s serverja ob cache miss-u.
      */
     findById<T extends DbEntity>(collection: string, id: Id, opts?: QueryOpts): Promise<T | null>;
     /**
@@ -873,6 +880,11 @@ export interface I_SyncedDb {
      *   jih v ozadju revalidira s serverja (Dexie + in-mem skozi konflikt
      *   resolucijo). Ortogonalno do referToServer; ne povzroči duplikata
      *   server klicev za missing ID-je.
+     *
+     * Auto-registracija: enako kot `findById` — če `collection` ni v
+     * runtime sync configu, se doda kot temporary s queryjem
+     * `{_id: {$in: [<ids>]}}` (vsi ID-ji iz klica). Dexie schema mora že
+     * imeti tabelo.
      */
     findByIds<T extends DbEntity>(collection: string, ids: Id[], opts?: QueryOpts): Promise<T[]>;
     /**

package/package.json

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