Fix row document override (#243)

* chore: fix override

* chore: fix override

* chore: lint

Author: appflowy

cypress/e2e/database/board-edit-operations.cy.ts

@@ -288,6 +288,61 @@ describe('Board Operations', () => {
         cy.task('log', '[TEST COMPLETE] Rapid card creation test passed');
       });
     });
+
+    it('should preserve row document content when reopening card multiple times', () => {
+      const testEmail = generateRandomEmail();
+      const cardName = `Reopen-${uuidv4().substring(0, 6)}`;
+      const documentContent = `Content-${uuidv4().substring(0, 8)}`;
+      const reopenCount = 3;
+
+      cy.task('log', `[TEST START] Card reopen test - Email: ${testEmail}`);
+
+      const authUtils = new AuthTestUtils();
+      createBoardAndWait(authUtils, testEmail).then(() => {
+        // Add a new card
+        BoardSelectors.boardContainer().contains('New').first().click({ force: true });
+        waitForReactUpdate(500);
+        cy.focused().type(`${cardName}{enter}`, { force: true });
+        waitForReactUpdate(2000);
+
+        BoardSelectors.boardContainer().contains(cardName).should('be.visible');
+
+        // Open card and add content to the row document
+        BoardSelectors.boardContainer().contains(cardName).click({ force: true });
+        waitForReactUpdate(1500);
+
+        cy.get('[role="dialog"]', { timeout: 10000 }).should('be.visible');
+
+        // Type content in the row document area (below properties)
+        cy.get('[role="dialog"]').find('[data-block-type]').first().click({ force: true });
+        waitForReactUpdate(500);
+        cy.focused().type(documentContent, { force: true });
+        waitForReactUpdate(2000);
+
+        // Close modal
+        cy.get('body').type('{esc}', { force: true });
+        waitForReactUpdate(2000);
+
+        // Reopen the card multiple times and verify content persists
+        for (let i = 1; i <= reopenCount; i++) {
+          cy.task('log', `[REOPEN ${i}/${reopenCount}] Opening card`);
+
+          BoardSelectors.boardContainer().contains(cardName).click({ force: true });
+          waitForReactUpdate(1500);
+
+          cy.get('[role="dialog"]', { timeout: 10000 }).should('be.visible');
+
+          // Verify the document content is still there
+          cy.get('[role="dialog"]').contains(documentContent, { timeout: 10000 }).should('exist');
+
+          // Close modal
+          cy.get('body').type('{esc}', { force: true });
+          waitForReactUpdate(1500);
+        }
+
+        cy.task('log', '[TEST COMPLETE] Card reopen test passed');
+      });
+    });
   });
 
   describe('Card Persistence', () => {

src/application/services/js-services/cache/index.ts

@@ -1,3 +1,5 @@
+import * as Y from 'yjs';
+
 import { migrateDatabaseFieldTypes } from '@/application/database-yjs/migrations/rollup_fieldtype';
 import { getRowKey } from '@/application/database-yjs/row_meta';
 import { closeCollabDB, db, openCollabDB, openCollabDBWithProvider } from '@/application/db';
@@ -562,3 +564,141 @@ export function getCachedRowDoc(rowKey: string): YDoc | undefined {
 export function deleteRow(rowKey: string) {
   rowDocs.delete(rowKey);
 }
+
+// ============================================================================
+// Row Sub-Document Cache (for document content inside database rows)
+// ============================================================================
+
+type RowSubDocEntry = {
+  doc: YDoc;
+  whenSynced: Promise<void>;
+};
+
+const rowSubDocs = new Map<string, RowSubDocEntry>();
+
+/**
+ * Helper to get text content summary from a Y.Doc for debugging.
+ */
+function getDocTextSummary(doc: YDoc): { hasText: boolean; textCount: number; sampleText: string } {
+  try {
+    const sharedRoot = doc.getMap(YjsEditorKey.data_section);
+    const document = sharedRoot?.get(YjsEditorKey.document) as Y.Map<unknown> | undefined;
+    const meta = document?.get(YjsEditorKey.meta) as Y.Map<unknown> | undefined;
+    const textMap = meta?.get(YjsEditorKey.text_map) as Y.Map<Y.Text> | undefined;
+
+    if (!textMap) {
+      return { hasText: false, textCount: 0, sampleText: '' };
+    }
+
+    let textCount = 0;
+    let sampleText = '';
+
+    for (const text of textMap.values()) {
+      const str = text?.toString() || '';
+
+      if (str.length > 0) {
+        textCount++;
+        if (!sampleText) {
+          sampleText = str.slice(0, 50);
+        }
+      }
+    }
+
+    return { hasText: textCount > 0, textCount, sampleText };
+  } catch {
+    return { hasText: false, textCount: 0, sampleText: '' };
+  }
+}
+
+/**
+ * Get or create a cached row sub-document.
+ * This ensures the same Y.Doc instance is reused when reopening a card,
+ * preserving the sync state and preventing content loss.
+ */
+export async function getOrCreateRowSubDoc(documentId: string): Promise<YDoc> {
+  const existing = rowSubDocs.get(documentId);
+
+  if (existing) {
+    const textSummary = getDocTextSummary(existing.doc);
+
+    Log.debug('[RowSubDoc] returning cached doc', {
+      documentId,
+      hasDoc: Boolean(existing.doc),
+      ...textSummary,
+    });
+
+    await existing.whenSynced;
+    return existing.doc;
+  }
+
+  Log.debug('[RowSubDoc] creating new doc entry', { documentId });
+
+  const startedAt = Date.now();
+  const { doc, provider } = await openCollabDBWithProvider(documentId, { awaitSync: false });
+
+  // Check initial state
+  const sharedRoot = doc.getMap(YjsEditorKey.data_section);
+  const hasDocument = sharedRoot.has(YjsEditorKey.document);
+  const textBeforeSync = getDocTextSummary(doc);
+
+  Log.debug('[RowSubDoc] opened (before IndexedDB sync)', {
+    documentId,
+    openDurationMs: Date.now() - startedAt,
+    providerSynced: provider.synced,
+    hasDocumentBeforeSync: hasDocument,
+    ...textBeforeSync,
+  });
+
+  const whenSynced = provider.synced
+    ? Promise.resolve()
+    : new Promise<void>((resolve) => {
+        provider.on('synced', () => {
+          const syncedSharedRoot = doc.getMap(YjsEditorKey.data_section);
+          const hasDocAfterSync = syncedSharedRoot.has(YjsEditorKey.document);
+          const textAfterSync = getDocTextSummary(doc);
+
+          Log.debug('[RowSubDoc] IndexedDB synced', {
+            documentId,
+            durationMs: Date.now() - startedAt,
+            hasDocumentAfterSync: hasDocAfterSync,
+            hadDocumentBeforeSync: hasDocument,
+            textBefore: textBeforeSync,
+            textAfter: textAfterSync,
+          });
+
+          resolve();
+        });
+      });
+
+  const entry = { doc, whenSynced };
+
+  rowSubDocs.set(documentId, entry);
+
+  await whenSynced;
+
+  // Log final state after sync
+  const finalTextSummary = getDocTextSummary(doc);
+
+  Log.debug('[RowSubDoc] ready', {
+    documentId,
+    totalDurationMs: Date.now() - startedAt,
+    ...finalTextSummary,
+  });
+
+  return doc;
+}
+
+/**
+ * Get a cached row sub-document if it exists, without creating a new one.
+ */
+export function getCachedRowSubDoc(documentId: string): YDoc | undefined {
+  return rowSubDocs.get(documentId)?.doc;
+}
+
+/**
+ * Remove a row sub-document from the cache.
+ * Call this when the document is no longer needed (e.g., row deleted).
+ */
+export function deleteRowSubDoc(documentId: string) {
+  rowSubDocs.delete(documentId);
+}

src/application/slate-yjs/utils/yjs.ts

@@ -24,8 +24,9 @@ import {
 } from '@/application/types';
 import { Log } from '@/utils/log';
 
-// UUID namespace OID (same as Rust's uuid::NAMESPACE_OID)
-const UUID_NAMESPACE_OID = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+// UUID namespace OID (same as Rust's Uuid::NAMESPACE_OID)
+// Note: 6ba7b812 (not 6ba7b810 which is NAMESPACE_DNS)
+const UUID_NAMESPACE_OID = '6ba7b812-9dad-11d1-80b4-00c04fd430c8';
 
 /**
  * Generate a deterministic page_id from document_id.
@@ -49,7 +50,16 @@ export function pageIdFromDocumentId(documentId: string): string {
     : uuidv5(documentId, UUID_NAMESPACE_OID);
 
   // Generate page_id as UUID v5 with document_id as namespace and "page" as name
-  return uuidv5('page', docUuid);
+  const pageId = uuidv5('page', docUuid);
+
+  Log.debug('[pageIdFromDocumentId]', {
+    documentId,
+    isValidUuid: uuidValidate(documentId),
+    docUuid,
+    pageId,
+  });
+
+  return pageId;
 }
 
 export function getTextMap(sharedRoot: YSharedRoot) {
@@ -300,6 +310,10 @@ export function initializeDocumentStructure(doc: YDoc, includeInitialParagraph =
 
   // Skip if already initialized
   if (sharedRoot.has(YjsEditorKey.document)) {
+    Log.debug('[initializeDocumentStructure] skipped - already initialized', {
+      docGuid: doc.guid,
+      documentId,
+    });
     return;
   }
 
@@ -308,6 +322,13 @@ export function initializeDocumentStructure(doc: YDoc, includeInitialParagraph =
   // Use deterministic page_id from documentId when provided, otherwise fallback to nanoid
   // The deterministic algorithm matches the server's default_document_data
   const pageId = documentId ? pageIdFromDocumentId(documentId) : nanoid(8);
+
+  Log.debug('[initializeDocumentStructure] creating new structure', {
+    docGuid: doc.guid,
+    documentId,
+    pageId,
+    includeInitialParagraph,
+  });
   const meta = new Y.Map();
   const childrenMap = new Y.Map() as YChildrenMap;
   const textMap = new Y.Map() as YTextMap;
@@ -357,6 +378,11 @@ export function initializeDocumentStructure(doc: YDoc, includeInitialParagraph =
   textMap.set(pageId, new Y.Text());
 
   sharedRoot.set(YjsEditorKey.document, document);
+
+  Log.debug('[initializeDocumentStructure] completed', {
+    docGuid: doc.guid,
+    pageId,
+  });
 }
 
 export function createEmptyDocument() {

src/application/view-loader/index.ts

@@ -11,7 +11,7 @@
  */
 
 import { openCollabDB } from '@/application/db';
-import { hasCollabCache } from '@/application/services/js-services/cache';
+import { getOrCreateRowSubDoc, hasCollabCache } from '@/application/services/js-services/cache';
 import { fetchPageCollab } from '@/application/services/js-services/fetch';
 import { Types, ViewLayout, YDoc, YjsDatabaseKey, YjsEditorKey, YSharedRoot } from '@/application/types';
 import { applyYDoc } from '@/application/ydoc/apply';
@@ -197,3 +197,53 @@ export function getDatabaseIdFromDoc(doc: YDoc): string | null {
     return null;
   }
 }
+
+// ============================================================================
+// Row Sub-Document (cached)
+// ============================================================================
+
+/**
+ * Open a row sub-document (the document content inside a database row).
+ *
+ * This uses a cache to ensure the same Y.Doc instance is reused when
+ * reopening the same card. This is critical for:
+ * 1. Preserving sync state between opens
+ * 2. Preventing content loss when server updates are applied
+ * 3. Following the same pattern as the desktop application
+ *
+ * @param workspaceId - The workspace ID
+ * @param documentId - The row sub-document ID
+ */
+export async function openRowSubDocument(
+  workspaceId: string,
+  documentId: string
+): Promise<ViewLoaderResult> {
+  const startedAt = Date.now();
+
+  Log.debug('[ViewLoader] openRowSubDocument start', { workspaceId, documentId });
+
+  // Use cached doc to preserve sync state across reopens
+  const doc = await getOrCreateRowSubDoc(documentId);
+
+  // Check cache
+  const fromCache = hasCollabCache(doc);
+
+  Log.debug('[ViewLoader] rowSubDoc cache check', {
+    documentId,
+    fromCache,
+    durationMs: Date.now() - startedAt,
+  });
+
+  // Fetch from server if not cached
+  if (!fromCache) {
+    await fetchAndApply(workspaceId, documentId, doc);
+  }
+
+  Log.debug('[ViewLoader] openRowSubDocument complete', {
+    documentId,
+    fromCache,
+    totalDurationMs: Date.now() - startedAt,
+  });
+
+  return { doc, fromCache, collabType: Types.Document };
+}