fix: send row document source when creating row pages (#418)

* fix: send row document source when creating row pages

* Fix favorite view sync

* feat(sync): send before/after Yjs state vectors on collab updates

Attach before_state_vector/after_state_vector (lib0 v1) to outbound collab
Update messages so the server can detect missing updates. Adds proto
fields 5/6 to Update (regenerated messages.js/.d.ts), captures the vectors
from the Yjs transaction in sync-protocol onUpdate, and threads them
through the persistent sync outbox (a merged drain spans the first
record's before-vector to the last record's after-vector). Covered by new
outbox tests. Backward compatible: empty vectors are treated as absent by
the server, so this is inert when the server feature is off.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lmq1LHFqqDTchv9K2bGEKR

* perf(sync): drop after_state_vector from web collab updates

The server never trusts a client-provided after vector (it derives the
post-update state from the update bytes itself), so sending it was wasted
work. Compute and send only before_state_vector: one Y.encodeStateVector
call per update instead of two, and fewer bytes on the wire. Removes the
field from the outbox record and all build sites (immediate/broadcast,
IDB-fallback, merge-drain) and from handleSyncRequest. The Update proto
still declares field 6 to stay aligned with the server wire contract; it
is simply left unset (serializes as absent -> None on the server).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Lmq1LHFqqDTchv9K2bGEKR

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: appflowy

src/application/database-yjs/context.ts

@@ -16,6 +16,7 @@ import {
   LoadView,
   LoadViewMeta,
   RowId,
+  RowDocumentSourcePayload,
   Subscription,
   TestDatabasePromptConfig,
   TimeFormat,
@@ -84,7 +85,7 @@ export interface DatabaseContextState {
    * Only available in app mode - not provided in publish mode.
    * Returns the doc_state (Y.js update) to initialize the local document.
    */
-  createRowDocument?: (documentId: string) => Promise<Uint8Array | null>;
+  createRowDocument?: (documentId: string, source?: RowDocumentSourcePayload) => Promise<Uint8Array | null>;
   /** Fire-and-forget: ask the server to duplicate the row document with inline DB deep copy. */
   duplicateRowDocument?: (databaseId: string, sourceRowId: string, newRowId: string, clientDocStateB64?: string) => Promise<void>;
   navigateToView?: (viewId: string, blockId?: string) => Promise<void>;

src/application/db/tables/sync_outbox.ts

@@ -9,6 +9,12 @@ export interface SyncOutboxRecord {
   version?: string | null;
   payload: Uint8Array;
   createdAt: number;
+  // Yjs state vector (lib0 v1) of the doc state before this local edit, so the
+  // server can detect missing updates. Optional: older rows written before this
+  // field existed drain without it (legacy server path). Not indexed, so no
+  // schema version bump is needed. We intentionally don't store an after vector —
+  // the server derives the post-update state itself and never trusts a client one.
+  beforeStateVector?: Uint8Array;
 }
 
 export type SyncOutboxTable = {

src/application/services/js-services/http/page-api.ts

@@ -48,7 +48,7 @@ export async function favoritePageView(
   workspaceId: string,
   viewId: string,
   isFavorite: boolean,
-  isPinned: boolean = false
+  isPinned: boolean = true
 ): Promise<void> {
   const url = `/api/workspace/${workspaceId}/page-view/${viewId}/favorite`;
 

src/application/services/js-services/http/view-api.ts

@@ -1,5 +1,5 @@
 import { AppOutlineResponse } from '@/application/services/services.type';
-import { View } from '@/application/types';
+import { CreateOrphanedViewPayload, View } from '@/application/types';
 
 import { APIResponse, executeAPIRequest, getAxios } from './core';
 
@@ -149,7 +149,7 @@ export async function getAppTrash(workspaceId: string) {
   );
 }
 
-export async function createOrphanedView(workspaceId: string, payload: { document_id: string }): Promise<Uint8Array> {
+export async function createOrphanedView(workspaceId: string, payload: CreateOrphanedViewPayload): Promise<Uint8Array> {
   const url = `/api/workspace/${workspaceId}/orphaned-view`;
 
   // Server returns doc_state as Vec<u8> which is JSON encoded as number[]

src/application/services/js-services/sync-protocol.ts

@@ -84,15 +84,19 @@ const handleSyncRequest = (ctx: SyncContext, message: collab.ISyncRequest): void
     version: doc.version,
     bytes: update.byteLength,
   });
-  // send the update containing new data back to the server
+  // send the update containing new data back to the server. This is a
+  // manifest-style diff, so the causal `before` vector is the server's own
+  // advertised state (what it told us it has). No after vector — the server
+  // derives its own post-update state and never trusts a client-provided one.
   emit({
     collabMessage: {
       objectId: doc.guid,
       collabType: ctx.collabType,
       update: {
         flags: UpdateFlags.Lib0v1,
         payload: update,
-        version: doc.version
+        version: doc.version,
+        beforeStateVector: stateVector,
       },
     },
   });
@@ -193,16 +197,24 @@ export const initSync = (ctx: SyncContext) => {
 
   ctx.discardPendingUpdates = () => deleteOutboxByObjectId(doc.guid);
 
-  const onUpdate = (update: Uint8Array, origin: string) => {
+  const onUpdate = (update: Uint8Array, origin: string, _doc: Y.Doc, transaction: Y.Transaction) => {
     if (origin === 'remote') {
       return; // Ignore remote updates
     }
 
+    // Causal metadata for server-side missing-update detection: the state vector
+    // before this edit. Yjs already computed `transaction.beforeState`, so we just
+    // encode it (lib0 v1, to match the server). We deliberately do NOT send an
+    // after vector — the server never trusts a client-provided one (it derives the
+    // post-update state from the update bytes itself), so it would be wasted work.
+    const beforeStateVector = Y.encodeStateVector(transaction.beforeState);
+
     enqueueOutboxUpdate({
       objectId: doc.guid,
       collabType,
       version: doc.version ?? null,
       payload: update,
+      beforeStateVector,
     });
     ctx.onLocalUpdate?.(doc.guid);
   };

src/application/sync-outbox/__tests__/sync-outbox.test.ts

@@ -11,6 +11,7 @@ interface MockSyncOutboxRecord {
   version?: string | null;
   payload: Uint8Array;
   createdAt: number;
+  beforeStateVector?: Uint8Array;
 }
 
 let mockRecords: MockSyncOutboxRecord[] = [];
@@ -199,6 +200,79 @@ describe('sync outbox live send', () => {
     expect(mockRecords).toHaveLength(0);
   });
 
+  it('attaches the before state vector to an immediately sent update (and no after)', async () => {
+    const send = jest.fn();
+
+    configureDrain({
+      userId,
+      workspaceId,
+      send,
+      isReady: () => true,
+    });
+
+    const beforeStateVector = new Uint8Array([1, 2, 3]);
+
+    enqueueOutboxUpdate({
+      objectId,
+      collabType: Types.Document,
+      version: null,
+      payload: makeUpdate('draft'),
+      beforeStateVector,
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    const update = send.mock.calls[0][0].collabMessage.update;
+
+    expect(update.beforeStateVector).toBe(beforeStateVector);
+    expect(update.afterStateVector).toBeUndefined();
+  });
+
+  it('takes the merged drain before vector from the first record (and sends no after)', async () => {
+    let ready = false;
+    const send = jest.fn();
+
+    configureDrain({
+      userId,
+      workspaceId,
+      send,
+      isReady: () => ready,
+    });
+
+    const firstBefore = new Uint8Array([10]);
+    const lastBefore = new Uint8Array([20]);
+
+    enqueueOutboxUpdate({
+      objectId,
+      collabType: Types.Document,
+      version: null,
+      payload: makeUpdate('old'),
+      beforeStateVector: firstBefore,
+    });
+    enqueueOutboxUpdate({
+      objectId,
+      collabType: Types.Document,
+      version: null,
+      payload: makeUpdate('new'),
+      beforeStateVector: lastBefore,
+    });
+    await flushPromises();
+
+    expect(send).not.toHaveBeenCalled();
+    expect(mockRecords).toHaveLength(2);
+
+    ready = true;
+    startDrainAll();
+    await flushPromises();
+
+    expect(send).toHaveBeenCalledTimes(1);
+    const update = send.mock.calls[0][0].collabMessage.update;
+
+    // Merged payload covers first->last, so before = the first record's before.
+    expect(update.beforeStateVector).toBe(firstBefore);
+    expect(update.afterStateVector).toBeUndefined();
+    expect(mockRecords).toHaveLength(0);
+  });
+
   it('live sends the current update and drains older queued records', async () => {
     let ready = false;
     const send = jest.fn();

src/application/sync-outbox/index.ts

@@ -225,6 +225,7 @@ export function enqueueOutboxUpdate(record: Omit<SyncOutboxRecord, 'id' | 'creat
             flags: FLAGS_LIB0V1,
             payload: record.payload,
             version: record.version ?? undefined,
+            beforeStateVector: record.beforeStateVector,
           } as collab.IUpdate,
         },
       };
@@ -490,7 +491,9 @@ async function distinctObjectIdsForSession(userId: string, workspaceId: string):
   return Array.from(ids);
 }
 
-function buildUpdateMessage(record: Pick<SyncOutboxRecord, 'objectId' | 'collabType' | 'payload' | 'version'>): messages.IMessage {
+function buildUpdateMessage(
+  record: Pick<SyncOutboxRecord, 'objectId' | 'collabType' | 'payload' | 'version' | 'beforeStateVector'>,
+): messages.IMessage {
   return {
     collabMessage: {
       objectId: record.objectId,
@@ -499,6 +502,7 @@ function buildUpdateMessage(record: Pick<SyncOutboxRecord, 'objectId' | 'collabT
         flags: FLAGS_LIB0V1,
         payload: record.payload,
         version: record.version ?? undefined,
+        beforeStateVector: record.beforeStateVector,
       } as collab.IUpdate,
     },
   };
@@ -580,11 +584,18 @@ async function drainObjectWhileReady(objectId: string): Promise<void> {
 
     if (records.length === 0) return;
 
+    // Records are sorted by id (insertion order), so first/last bound the batch.
+    const firstRecord = records[0];
+    const lastRecord = records[records.length - 1];
+
     const merged = records.length === 1
-      ? records[0].payload
+      ? firstRecord.payload
       : Y.mergeUpdates(records.map((r) => r.payload));
-    const collabType = records[records.length - 1].collabType as Types;
-    const version = records[records.length - 1].version;
+    const collabType = lastRecord.collabType as Types;
+    const version = lastRecord.version;
+    // The merged payload spans from the first queued edit to the last, so its
+    // causal `before` is the first record's before-vector.
+    const beforeStateVector = firstRecord.beforeStateVector;
 
     const message: messages.IMessage = {
       collabMessage: {
@@ -594,6 +605,7 @@ async function drainObjectWhileReady(objectId: string): Promise<void> {
           flags: FLAGS_LIB0V1,
           payload: merged,
           version: version ?? undefined,
+          beforeStateVector,
         } as collab.IUpdate,
       },
     };

src/application/types.ts

@@ -1203,6 +1203,10 @@ export interface View {
   has_children?: boolean;
   is_published: boolean;
   is_private: boolean;
+  /** Whether this view is currently in the user's favorites. Synced via the folder. */
+  is_favorite?: boolean;
+  /** Favorite-section pin state returned by the favorites endpoint. */
+  is_pinned?: boolean;
   /** Whether the page is locked (read-only) for everyone until unlocked. Synced via the folder. */
   is_locked?: boolean;
   last_edited_time?: string;
@@ -1348,6 +1352,17 @@ export interface UpdatePagePayload {
   is_locked?: boolean;
 }
 
+export interface RowDocumentSourcePayload {
+  database_id: string;
+  database_view_id: string;
+  row_id: string;
+}
+
+export interface CreateOrphanedViewPayload {
+  document_id: string;
+  row_document_source?: RowDocumentSourcePayload;
+}
+
 export type ViewMetaCover = ViewCover;
 
 export interface ViewMetaProps {
@@ -1396,7 +1411,7 @@ export interface ViewComponentProps {
    * Create a row document on the server (orphaned view).
    * Only available in app mode - not provided in publish mode.
    */
-  createRowDocument?: (documentId: string) => Promise<Uint8Array | null>;
+  createRowDocument?: (documentId: string, source?: RowDocumentSourcePayload) => Promise<Uint8Array | null>;
   duplicateRowDocument?: (
     databaseId: string,
     sourceRowId: string,

src/components/app/contexts/AppOperationsContext.ts

@@ -5,6 +5,7 @@ import { SyncContext } from '@/application/services/js-services/sync-protocol';
 import {
   CreateDatabaseViewPayload,
   CreateDatabaseViewResponse,
+  CreateOrphanedViewPayload,
   DuplicatePageOperationOptions,
   CreatePagePayload,
   CreatePageResponse,
@@ -15,6 +16,7 @@ import {
   LoadDatabasePrompts,
   LoadView,
   LoadViewMeta,
+  RowDocumentSourcePayload,
   Subscription,
   TestDatabasePromptConfig,
   TextCount,
@@ -113,7 +115,7 @@ export interface AppOperationsContextType {
 
   // ── Database operations ────────────────────────────────────────────
   /** Create an orphaned view (e.g. for inline database within a document). */
-  createOrphanedView?: (payload: { document_id: string }) => Promise<Uint8Array>;
+  createOrphanedView?: (payload: CreateOrphanedViewPayload) => Promise<Uint8Array>;
   /** Load AI prompt templates for a database. */
   loadDatabasePrompts?: LoadDatabasePrompts;
   /** Test an AI prompt config against a database. */
@@ -123,7 +125,7 @@ export interface AppOperationsContextType {
   /** Load an existing row document. */
   loadRowDocument?: (documentId: string) => Promise<YDoc | null>;
   /** Create a new row document (returns encoded initial state). */
-  createRowDocument?: (documentId: string) => Promise<Uint8Array | null>;
+  createRowDocument?: (documentId: string, source?: RowDocumentSourcePayload) => Promise<Uint8Array | null>;
   /** Fire-and-forget: ask the server to duplicate the row document with inline DB deep copy. */
   duplicateRowDocument?: (databaseId: string, sourceRowId: string, newRowId: string, clientDocStateB64?: string) => Promise<void>;
   /** Resolve a database ID to its primary view ID. */