@multiplatform.one/frappe 6.4.2 → 6.6.0

package/src/collection.ts

@@ -34,6 +34,40 @@ export interface FrappeCollectionOptionsConfig<
   onSyncError?: (error: unknown) => void;
 }
 
+// ---------------------------------------------------------------------------
+// External sync release
+// ---------------------------------------------------------------------------
+//
+// Registered per collection while a Frappe sync session is active. Lets the
+// shared-collection GC in frappeReact free the REAL resources (SyncModule
+// subscription, store listener, realtime room) of a collection that leaked
+// live queries still pin, WITHOUT calling collection.cleanup(): TanStack DB
+// transitions every attached live query to a permanent error state (plus a
+// console.error per query — "Source collection … was manually cleaned up
+// while live query … depends on it") when a depended-on collection is
+// cleaned up. Releasing externally leaves the collection object alive but
+// inert: attached queries keep their last data, no error, no leak beyond
+// the plain object graph the leaked query itself already holds.
+const externalSyncReleases = new WeakMap<object, () => void>();
+
+/**
+ * Releases the Frappe-side sync resources (SyncModule subscription + store
+ * listener → realtime room) of a collection created by
+ * {@link createFrappeCollection}, without touching TanStack DB's lifecycle.
+ * Idempotent; also runs automatically when TanStack stops the sync itself.
+ *
+ * @returns true when an active sync session was released, false when the
+ * collection has no registered session (sync never started, already
+ * stopped, or not a Frappe collection) — callers may fall back to
+ * `collection.cleanup()` in that case.
+ */
+export function releaseFrappeCollectionSync(collection: object): boolean {
+  const release = externalSyncReleases.get(collection);
+  if (!release) return false;
+  release();
+  return true;
+}
+
 /**
  * Creates TanStack DB collection options wired to Frappe's SyncModule.
  *
@@ -74,6 +108,22 @@ export function frappeCollectionOptions<TDoc extends object & { name: string; do
     // (invalid "cleaned-up" → "ready" status transition).
     let cancelled = false;
 
+    // Idempotent resource release shared by TanStack's own sync teardown
+    // and the external escape hatch (releaseFrappeCollectionSync).
+    const releaseResources = () => {
+      cancelled = true;
+      if (storeUnsubscribe) {
+        storeUnsubscribe();
+        storeUnsubscribe = undefined;
+      }
+      if (subscriptionId) {
+        syncModule.unsubscribe(subscriptionId);
+        subscriptionId = undefined;
+      }
+    };
+    const syncedCollection = (params as { collection?: object }).collection;
+    if (syncedCollection) externalSyncReleases.set(syncedCollection, releaseResources);
+
     async function initSync() {
       try {
         // Subscribe to the SyncModule for this doctype
@@ -147,15 +197,10 @@ export function frappeCollectionOptions<TDoc extends object & { name: string; do
 
     // Return cleanup function
     return () => {
-      cancelled = true;
-      if (storeUnsubscribe) {
-        storeUnsubscribe();
-        storeUnsubscribe = undefined;
-      }
-      if (subscriptionId) {
-        syncModule.unsubscribe(subscriptionId);
-        subscriptionId = undefined;
+      if (syncedCollection && externalSyncReleases.get(syncedCollection) === releaseResources) {
+        externalSyncReleases.delete(syncedCollection);
       }
+      releaseResources();
     };
   };
 

package/src/db.spec.ts

@@ -511,6 +511,54 @@ describe("DbModule", () => {
         expect.any(Object),
       );
     });
+
+    it("should unwrap the live server's {message} envelope so the ack surfaces the real name", async () => {
+      // Regression: whitelisted method returns arrive as {message: {...doc}}.
+      // Returning the envelope made created.name undefined, so the mutation
+      // engine's temporary→real reconciliation never ran (optimistic rows
+      // lingered next to their realtime server rows until reload).
+      const createdDoc: TestDoc = {
+        doctype: "TestDocType",
+        name: "SERVER-NAME-001",
+        title: "New Document",
+      };
+
+      (mockHttpClient.post as any).mockResolvedValue({
+        payload: { message: createdDoc },
+        headers: new Headers(),
+        status: 200,
+      });
+
+      const result = await db.createDoc<TestDoc>({
+        doctype: "TestDocType",
+        name: "new-todo-placeholder",
+        title: "New Document",
+      });
+
+      expect(result).toEqual(createdDoc);
+      expect(result.name).toBe("SERVER-NAME-001");
+    });
+
+    it("should not unwrap a document that itself has a message field", async () => {
+      // A doc with a scalar `message` field (e.g. Email Template) must pass
+      // through untouched — only the envelope shape (object message, no
+      // top-level name) unwraps.
+      const docWithMessageField = {
+        doctype: "TestDocType",
+        name: "TEST-004",
+        message: "I am a doc field, not an envelope",
+      };
+
+      (mockHttpClient.post as any).mockResolvedValue({
+        payload: docWithMessageField,
+        headers: new Headers(),
+        status: 200,
+      });
+
+      const result = await db.createDoc(docWithMessageField as any);
+
+      expect(result).toEqual(docWithMessageField);
+    });
   });
 
   describe("updateDoc", () => {
@@ -664,6 +712,28 @@ describe("DbModule", () => {
         expect.any(Object),
       );
     });
+
+    it("should unwrap the live server's {message} envelope", async () => {
+      const updatedDoc: TestDoc = {
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+      };
+
+      (mockHttpClient.post as any).mockResolvedValue({
+        payload: { message: updatedDoc },
+        headers: new Headers(),
+        status: 200,
+      });
+
+      const result = await db.updateDoc<TestDoc>({
+        doctype: "TestDocType",
+        name: "TEST-001",
+        title: "Updated Title",
+      });
+
+      expect(result).toEqual(updatedDoc);
+    });
   });
 
   describe("deleteDoc", () => {

package/src/db.ts

@@ -142,13 +142,14 @@ export class DbModule {
     if (client_mutation_id) {
       headers["Idempotency-Key"] = client_mutation_id;
     }
-    return (
+    const raw = (
       await this.http.post<FrappeDoc<Data>>(
         `/api/method/${this.endpoints.createDoc}`,
         cleanDoc,
         headers,
       )
     ).payload;
+    return unwrapMethodDoc(raw);
   }
 
   async updateDoc<Data extends FrappeDocData>(
@@ -165,13 +166,14 @@ export class DbModule {
     if (base_modified) {
       headers["If-Match"] = base_modified;
     }
-    return (
+    const raw = (
       await this.http.post<FrappeDoc<Data>>(
         `/api/method/${this.endpoints.updateDoc}`,
         { doctype, name, data },
         headers,
       )
     ).payload;
+    return unwrapMethodDoc(raw);
   }
 
   async deleteDoc<Data extends FrappeDocData>(
@@ -291,6 +293,30 @@ function normalizeFilters(
   return Object.entries(filters).map(([k, v]) => [k, "=", v]);
 }
 
+/**
+ * Unwraps Frappe's whitelisted-method response envelope.
+ *
+ * The live server returns the document wrapped as `{ message: {...doc} }`
+ * (every `@frappe.whitelist` return is enveloped). The old code returned the
+ * envelope itself, so `created.name` was always undefined and the mutation
+ * engine's temporary→real name reconciliation was dead code on the live wire
+ * (optimistic rows lingered next to their realtime server rows).
+ *
+ * Mocks and custom endpoints may return the document directly, so only
+ * unwrap when the payload actually looks like an envelope: a `message`
+ * object (a doc's own scalar `message` field or a child-table `message`
+ * array never matches) on a payload that has no `name` of its own.
+ */
+function unwrapMethodDoc<Doc>(raw: Doc): Doc {
+  if (raw && typeof raw === "object" && !("name" in raw)) {
+    const message = (raw as { message?: unknown }).message;
+    if (message && typeof message === "object" && !Array.isArray(message)) {
+      return message as Doc;
+    }
+  }
+  return raw;
+}
+
 export interface BackfillArgs {
   method?: string;
   doctype: string;

package/src/frappeReact.spec.ts

@@ -44,7 +44,13 @@ const { mockCreateFrappeCollection, mockIsBrowser } = vi.hoisted(() => ({
   mockIsBrowser: vi.fn(() => true),
 }));
 
-vi.mock("./collection", () => ({ createFrappeCollection: mockCreateFrappeCollection }));
+vi.mock("./collection", () => ({
+  createFrappeCollection: mockCreateFrappeCollection,
+  // Mocked collections never register a sync session, so the registry's
+  // force-GC falls back to collection.cleanup() (the pre-existing contract
+  // these specs assert).
+  releaseFrappeCollectionSync: () => false,
+}));
 vi.mock("./util", () => ({ isBrowser: mockIsBrowser }));
 vi.mock("./fixtureDb", () => ({ FixtureDbModule: class {} }));
 

package/src/frappeReact.ts

@@ -1,7 +1,11 @@
 import { isWindowDefined } from "@multiplatform.one/platform";
 import type { Collection } from "@tanstack/db";
 import { useCallback, useEffect, useRef, useState } from "react";
-import { createFrappeCollection, type FrappeCollectionOptionsConfig } from "./collection";
+import {
+  createFrappeCollection,
+  releaseFrappeCollectionSync,
+  type FrappeCollectionOptionsConfig,
+} from "./collection";
 import { HttpClient } from "./core/http";
 import type { AuthConfig } from "./core/types";
 import { DbModule } from "./db";
@@ -233,8 +237,20 @@ function scheduleEntryGc(
       // Past the deadline: a leaked query (created by a render that never
       // committed — TanStack DB never GCs a live query that never had a
       // subscriber) is pinning the sync subscription + realtime room.
-      // Force-clean; any consumer that appears later gets a fresh instance
-      // via the stale-entry paths in getOrCreateSharedCollection / the hook.
+      // Calling cleanup() here would transition EVERY attached live query
+      // to a permanent error state with a console.error per query ("Source
+      // collection 'X' was manually cleaned up while live query … depends
+      // on it" — the Workspace console-sweep bug), so release the
+      // Frappe-side resources directly instead and leave the collection
+      // object alive but inert. The entry is still evicted: any consumer
+      // that appears later gets a fresh instance via the stale-entry paths
+      // in getOrCreateSharedCollection / the hook.
+      entry.cleaned = true;
+      entry.gcForceDeadline = undefined;
+      if (cache.get(key) === entry) cache.delete(key);
+      if (releaseFrappeCollectionSync(entry.collection)) return;
+      // No active sync session registered (non-frappe collection or sync
+      // never started) — fall through to the plain cleanup below.
     }
     entry.cleaned = true;
     entry.gcForceDeadline = undefined;
@@ -242,6 +258,7 @@ function scheduleEntryGc(
     // Best-effort: Collection.cleanup() stops the sync (unsubscribes from the
     // SyncModule, leaving the realtime room). A consumer that raced eviction
     // still works — TanStack DB restarts a cleaned-up collection on next use.
+    // Safe here: subscriberCount is 0, so no live query depends on it.
     Promise.resolve(entry.collection.cleanup?.()).catch(() => {});
   }, SHARED_COLLECTION_GC_MS);
 }
@@ -366,9 +383,16 @@ function cleanupEntryCollectionWhenIdle(entry: SharedCollectionEntry): void {
   const tick = () => {
     entry.gcTimer = undefined;
     const subscriberCount = (entry.collection as { subscriberCount?: number }).subscriberCount ?? 0;
-    if (subscriberCount > 0 && Date.now() < deadline) {
-      entry.gcTimer = setTimeout(tick, SHARED_COLLECTION_GC_MS);
-      return;
+    if (subscriberCount > 0) {
+      if (Date.now() < deadline) {
+        entry.gcTimer = setTimeout(tick, SHARED_COLLECTION_GC_MS);
+        return;
+      }
+      // Queries are still attached past the force window (leaked queries
+      // from never-committed renders). cleanup() would permanently error
+      // each of them with a console.error — release the sync resources
+      // externally instead; the collection object stays alive but inert.
+      if (releaseFrappeCollectionSync(entry.collection)) return;
     }
     Promise.resolve(entry.collection.cleanup?.()).catch(() => {});
   };

package/src/frappeReactLiveQueryGc.spec.ts

@@ -281,7 +281,7 @@ describe("shared collection GC vs real live queries", () => {
     expect(liveQueryErrors()).toHaveLength(0);
   });
 
-  it("force window: a leaked query cannot pin the collection forever, and a fresh mount recovers", async () => {
+  it("force window: a leaked query releases the sync WITHOUT erroring, and a fresh mount recovers", async () => {
     const config = configFor("leak");
     const hook = renderHook(() => useFrappeCollection<WorkspaceDoc>(config, "Workspace"));
     await flushMicrotasks();
@@ -290,18 +290,29 @@ describe("shared collection GC vs real live queries", () => {
     // A leaked query: created (sync started, source subscribed) but never
     // given a subscriber — the shape a discarded render leaves behind.
     // TanStack DB never arms its GC for it, so only the force window frees
-    // the source collection.
-    createLiveQueryCollection({
+    // the sync resources.
+    const leakedQuery = createLiveQueryCollection({
       query: (q) => q.from({ workspace: collection }),
       startSync: true,
       gcTime: 300_000,
     });
     await flushMicrotasks();
     expect(collection.subscriberCount).toBeGreaterThan(0);
+    const unsubscribesBefore = mockUnsubscribe.mock.calls.length;
 
     hook.unmount();
     await advanceTime(FORCE_WAIT_MS);
-    expect(collection.status).toBe("cleaned-up");
+    // The regression this pins: the force window used to call cleanup() on
+    // the pinned collection, permanently erroring every attached query with
+    // "[Live Query Error] Source collection 'Workspace' was manually cleaned
+    // up while live query … depends on it" (7× in the console sweep).
+    // Now the SyncModule subscription is released externally instead: the
+    // collection is never transitioned to cleaned-up, the leaked query
+    // never errors, and no console error is emitted.
+    expect(mockUnsubscribe.mock.calls.length).toBeGreaterThan(unsubscribesBefore);
+    expect(collection.status).not.toBe("cleaned-up");
+    expect(leakedQuery.status).not.toBe("error");
+    expect(liveQueryErrors()).toHaveLength(0);
 
     // A consumer mounting afterwards gets a FRESH working collection — a new
     // live query over it loads and reaches ready.
@@ -316,5 +327,34 @@ describe("shared collection GC vs real live queries", () => {
     expect(fresh.result.current!.status).toBe("ready");
     expect(freshQuery.status).toBe("ready");
     expect(freshQuery.toArray).toHaveLength(2);
+    expect(liveQueryErrors()).toHaveLength(0);
+  });
+
+  it("errored entry: idle cleanup with a leaked query attached releases sync without erroring", async () => {
+    // The production path from the console sweep: initial sync fails (401),
+    // consumers unmount (error screen), the errored entry is evicted through
+    // cleanupEntryCollectionWhenIdle — which, past the force window, used to
+    // cleanup() the collection while leaked queries were still attached.
+    const config = configFor("error");
+    mockSubscribe.mockRejectedValueOnce(new Error("AuthenticationError"));
+
+    const hook = renderHook(() => useFrappeCollection<WorkspaceDoc>(config, "Workspace"));
+    await flushMicrotasks();
+    const collection = hook.result.current!;
+
+    const leakedQuery = createLiveQueryCollection({
+      query: (q) => q.from({ workspace: collection }),
+      startSync: true,
+      gcTime: 300_000,
+    });
+    await flushMicrotasks();
+    expect(collection.subscriberCount).toBeGreaterThan(0);
+
+    hook.unmount();
+    await advanceTime(FORCE_WAIT_MS);
+
+    expect(collection.status).not.toBe("cleaned-up");
+    expect(leakedQuery.status).not.toBe("error");
+    expect(liveQueryErrors()).toHaveLength(0);
   });
 });

package/src/sync/index.ts

@@ -226,7 +226,16 @@ export class SyncModule {
   }
 
   async mutate(mutation: Mutation<FrappeDocData>) {
-    await this.mutationEngine.mutate(mutation);
+    try {
+      await this.mutationEngine.mutate(mutation);
+    } catch (err) {
+      // The failure path rolled back optimistic state (e.g. a rejected
+      // create's temp row was evicted) — store listeners must see that
+      // rollback too, or consumers that mirrored the optimistic membership
+      // keep rendering a ghost row the engine already dropped.
+      this.emit();
+      throw err;
+    }
     // Broadcast mutation to other tabs for cross-tab sync
     this.persistenceManager.broadcastMutation(mutation);
     this.emit();

package/src/sync/mutationEngine.ts

@@ -147,10 +147,22 @@ export class MutationEngine {
           if (result.data) {
             this.normalizedCache.upsert(result.data);
 
-            // Handle temp ID mapping for creates
-            if (mutation.operation === Operation.Create && mutation.doc.name !== result.data.name) {
-              this.temporaryIdToRealNameMap.set(mutation.doc.name!, result.data.name);
-              this.rehydrationManager.registerTempIdMapping(mutation.doc.name!, result.data.name);
+            // Reconcile optimistic identity for creates — the full remap
+            // (subscription membership + temp cache row eviction), not just
+            // the id maps, or the optimistic row lingers beside the server
+            // row exactly like the non-batched path used to.
+            if (mutation.operation === Operation.Create) {
+              const temporaryName = mutation.temporaryName ?? mutation.doc.name;
+              if (temporaryName && result.data.name && temporaryName !== result.data.name) {
+                this.handleTemporaryToRealMapping(
+                  mutation.doc.doctype,
+                  temporaryName,
+                  result.data.name,
+                );
+                this.rehydrationManager.registerTempIdMapping(temporaryName, result.data.name);
+              } else if (temporaryName) {
+                this.globalOptimisticDocIds.get(mutation.doc.doctype)?.delete(temporaryName);
+              }
             }
           }
 
@@ -244,7 +256,11 @@ export class MutationEngine {
           : mutation.doc;
     this.mutationJournal.add(mutation.mutationId, {
       doctype: doc.doctype,
-      docname: doc.name,
+      // Creates journal the optimistic identity (consumer placeholder or
+      // engine-generated temp id) so page refreshes keep the pending row
+      // and rollback can evict it even when doc.name was never set.
+      docname:
+        mutation.operation === Operation.Create ? (mutation.temporaryName ?? doc.name) : doc.name,
       values,
       operation: mutation.operation,
       version,
@@ -318,6 +334,11 @@ export class MutationEngine {
 
   private async handleOptimisticCreate<Data extends FrappeDocData>(mutation: CreateMutation<Data>) {
     const temporaryName = mutation.doc.name || `tmp_${cryptoRandomId()}`;
+    // Record the optimistic identity on the mutation itself: the server-ack
+    // remap, rollback, and journal paths must all resolve the SAME name.
+    // For engine-generated names, mutation.doc.name stays unset so the
+    // synthetic id is never sent to the server.
+    mutation.temporaryName = temporaryName;
     const optimisticDoc = {
       ...mutation.doc,
       name: temporaryName,
@@ -370,11 +391,27 @@ export class MutationEngine {
   }
 
   private async handleServerCreate<Data extends FrappeDocData>(mutation: CreateMutation<Data>) {
-    const created = await this.db.createDoc<FrappeDoc<Data>>(mutation.doc);
+    // Idempotency-Key rides the first attempt (not just replays) so an
+    // HTTP-level retry after a lost response replays the recorded outcome
+    // instead of double-inserting (live-protocol FRAPPE-EXT-001).
+    const created = await this.db.createDoc<FrappeDoc<Data>>({
+      ...mutation.doc,
+      client_mutation_id: mutation.mutationId,
+    });
     // Authoritative name assigned by the backend (may equal the provided temp name)
     const realName = created?.name;
     // The client-synthesized or user-provided temporary name used during optimism
-    const temporaryName = mutation.doc.name;
+    const temporaryName = mutation.temporaryName ?? mutation.doc.name;
+    // The ack payload IS the authoritative post-insert document (same user
+    // context as any refetch) — seed the cache unconditionally so remapped
+    // membership resolves immediately instead of waiting for the realtime
+    // echo (which used to leave the row blank until the socket delivered).
+    if (realName) {
+      this.normalizedCache.upsert({
+        ...created,
+        doctype: created.doctype || mutation.doc.doctype,
+      });
+    }
     // If backend assigned a different name, remap temporary → real across subscriptions.
     if (realName && temporaryName && realName !== temporaryName) {
       this.handleTemporaryToRealMapping(mutation.doc.doctype, temporaryName, realName);
@@ -387,10 +424,6 @@ export class MutationEngine {
         globalDocs.delete(temporaryName);
       }
     }
-    // When realtime is unhealthy, seed cache with authoritative document.
-    if (!this.realtime?.isHealthy()) {
-      this.normalizedCache.upsert(created);
-    }
   }
 
   private async handleServerUpdate<Data extends FrappeDocData>(
@@ -433,10 +466,16 @@ export class MutationEngine {
       globalDocs.delete(temporaryName);
       // Real name is no longer optimistic, so we don't add it back
     }
-    // replace in subscriptions
+    // Replace in subscriptions. When the realtime event / CDC backfill /
+    // page-refresh reconcile already delivered the server row (the ack lost
+    // the race), a plain map would leave the same name twice — drop the
+    // temporary id instead so exactly one row remains.
     for (const subscription of this.subscriptionManager.getAllSubscriptions().values()) {
       if (subscription.query.doctype !== doctype) continue;
-      subscription.docIds = subscription.docIds.map((x) => (x === temporaryName ? realName : x));
+      if (!subscription.docIds.includes(temporaryName)) continue;
+      subscription.docIds = subscription.docIds.includes(realName)
+        ? subscription.docIds.filter((id) => id !== temporaryName)
+        : subscription.docIds.map((id) => (id === temporaryName ? realName : id));
     }
     // Remove the temporary cached row now that the authoritative name exists
     this.normalizedCache.remove({ doctype, name: temporaryName });
@@ -450,7 +489,12 @@ export class MutationEngine {
     const realName = (docname && this.temporaryIdToRealNameMap.get(docname)) || docname;
     // A deleted doc no longer exists server-side — refetching it would 404
     // and route a server-confirmed delete into the error/rollback path.
-    if (realName && mutation.operation !== Operation.Delete) {
+    // A created doc is the insert-side sibling of the same bug: its cache
+    // copy was already seeded from the authoritative ack response, and
+    // refetching the pre-remap temporary name is a guaranteed 404 that used
+    // to roll back a server-confirmed create. Only updates refetch the
+    // main document here.
+    if (realName && mutation.operation === Operation.Update) {
       targets.push({ doctype, name: realName });
     }
     if (mutation.affected?.length) targets.push(...mutation.affected);
@@ -503,11 +547,9 @@ export class MutationEngine {
     switch (mutation.operation) {
       case Operation.Create:
         // Remove temporary optimistic document from cache and subscriptions
+        // (handleFailedCreate resolves the optimistic identity — consumer
+        // placeholder or engine-generated temp id — and evicts both).
         await this.handleFailedCreate(mutation);
-        // Also remove from cache
-        if (docname) {
-          this.normalizedCache.remove({ doctype, name: docname });
-        }
         break;
 
       case Operation.Update:
@@ -541,7 +583,10 @@ export class MutationEngine {
   }
 
   private async handleFailedCreate<Data extends FrappeDocData>(mutation: Mutation<Data>) {
-    const temporaryName = mutation.doc.name;
+    const temporaryName =
+      mutation.operation === Operation.Create
+        ? (mutation.temporaryName ?? mutation.doc.name)
+        : mutation.doc.name;
     const doctype = mutation.doc.doctype;
 
     if (temporaryName) {
@@ -555,6 +600,9 @@ export class MutationEngine {
         if (subscription.query.doctype !== doctype) continue;
         subscription.docIds = subscription.docIds.filter((id) => id !== temporaryName);
       }
+      // Evict the optimistic cache row (generated temp ids never lived in
+      // mutation.doc.name, so keying off the resolved name matters here).
+      this.normalizedCache.remove({ doctype, name: temporaryName });
     }
   }
 
@@ -788,12 +836,25 @@ export class MutationEngine {
       }
       try {
         if (entry.operation === Operation.Create) {
-          await this.db.createDoc({
+          const created = await this.db.createDoc({
             ...entry.values,
             client_mutation_id: id,
             doctype: entry.doctype,
             name: entry.docname || cryptoRandomId(),
           });
+          // A replayed create acks with the authoritative document (possibly
+          // an idempotent replay of an earlier success) — reconcile the
+          // optimistic identity exactly like the first attempt.
+          if (created?.name) {
+            this.normalizedCache.upsert({
+              ...created,
+              doctype: created.doctype || entry.doctype,
+            });
+            if (entry.docname && created.name !== entry.docname) {
+              this.handleTemporaryToRealMapping(entry.doctype, entry.docname, created.name);
+              this.rehydrationManager.registerTempIdMapping(entry.docname, created.name);
+            }
+          }
         } else if (entry.operation === Operation.Update && entry.docname) {
           await this.db.updateDoc({
             ...entry.values,