RTC: fix interaction with autosave that can cause posts and revisions to get lost even when a single user is editing a post

backport-changelog/7.0/11691.md

@@ -0,0 +1,3 @@
+https://github.com/WordPress/wordpress-develop/pull/11691
+
+* https://github.com/WordPress/gutenberg/pull/77865

lib/compat/wordpress-7.0/class-gutenberg-rest-autosaves-controller.php

@@ -73,44 +73,35 @@ public function create_item( $request ) {
 			require_once ABSPATH . 'wp-admin/includes/post.php';
 		}
 
-		$post_lock = wp_check_post_lock( $post->ID );
-		$is_draft  = 'draft' === $post->post_status || 'auto-draft' === $post->post_status;
+		$post_lock_is_active      = wp_check_post_lock( $post->ID );
+		$is_auto_draft            = 'auto-draft' === $post->post_status;
+		$is_draft                 = 'draft' === $post->post_status || $is_auto_draft;
+		$is_collaboration_enabled = wp_is_collaboration_enabled();
 
-		/**
-		 * In the context of real-time collaboration, all peers are effectively
-		 * authors and we don't want to vary behavior based on whether they are the
-		 * original author. Always target an autosave revision.
-		 *
-		 * This avoids the following issue when real-time collaboration is enabled:
-		 *
-		 * - Autosaves from the original author (if they have the post lock) will
-		 *   target the saved post.
-		 *
-		 * - Autosaves from other users are applied to a post revision.
+		/*
+		 * When a post is still in draft form, updates from the author can directly update the post.
+		 * Other autosaves must be stored as per-user autosave revisions.
 		 *
-		 * - If any user reloads a post, they load changes from the author's autosave.
+		 * When RTC is active, however, regular draft autosaves must not update the parent post directly.
+		 * Since all peers are sharing a persisted editing state (a shared CRDT), it’s important that
+		 * they all store updates in a revision. If edits were applied to the post, then upon the next
+		 * editor reload, it would appear as though the post had been updated externally, and those same
+		 * changes would be re-applied to the CRDT, duplicating the edits.
 		 *
-		 * - The saved post has now diverged from the persisted CRDT document. The
-		 *   content (and/or title or excerpt) are now "ahead" of the persisted CRDT
-		 *   document.
-		 *
-		 * - When the persisted CRDT document is loaded, a diff is computed against
-		 *   the saved post. This diff is then applied to the in-memory CRDT
-		 *   document, which can lead to duplicate inserts or deletions.
-		 *
-		 * Load the real-time collaboration setting and, when enabled, ensure that an
-		 * an autosave revision is always targeted.
+		 * The one caveat for RTC is that the first peer to store an edit must promote an auto-draft
+		 * into a real draft post. If this doesn’t happen then the peers may continue to make edits
+		 * but the draft will be lost, as auto-drafts are not listed in post views.
 		 */
-		$is_collaboration_enabled = wp_is_collaboration_enabled();
-
-		if ( $is_draft && (int) $post->post_author === $user_id && ! $post_lock && ! $is_collaboration_enabled ) {
-			/*
-			 * Draft posts for the same author: autosaving updates the post and does not create a revision.
-			 * Convert the post object to an array and add slashes, wp_update_post() expects escaped array.
-			 */
+		$should_update_parent_draft_post = (
+			$is_draft &&
+			(int) $post->post_author === $user_id &&
+			! $post_lock_is_active &&
+			( ! $is_collaboration_enabled || $is_auto_draft )
+		);
+
+		if ( $should_update_parent_draft_post ) {
 			$autosave_id = wp_update_post( wp_slash( (array) $prepared_post ), true );
 		} else {
-			// Non-draft posts: create or update the post autosave. Pass the meta data.
 			$autosave_id = $this->create_post_autosave( (array) $prepared_post, (array) $request->get_param( 'meta' ) );
 		}
 

phpunit/tests/collaboration/restAutosavesController.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * Tests for the collaboration autosaves REST controller override.
+ *
+ * @package gutenberg
+ * @subpackage Collaboration
+ *
+ * @group collaboration
+ * @group restapi
+ */
+class Tests_Collaboration_RestAutosavesController extends WP_UnitTestCase {
+
+	protected static int $author_id;
+
+	public static function wpSetUpBeforeClass( WP_UnitTest_Factory $factory ) {
+		self::$author_id = $factory->user->create( array( 'role' => 'author' ) );
+	}
+
+	public static function wpTearDownAfterClass() {
+		self::delete_user( self::$author_id );
+		delete_option( 'wp_collaboration_enabled' );
+	}
+
+	public function set_up() {
+		parent::set_up();
+		wp_set_current_user( self::$author_id );
+	}
+
+	/**
+	 * Creates an empty auto-draft post.
+	 *
+	 * @return int Post ID.
+	 */
+	private function create_auto_draft(): int {
+		return self::factory()->post->create(
+			array(
+				'post_author'  => self::$author_id,
+				'post_content' => '',
+				'post_status'  => 'auto-draft',
+				'post_title'   => 'Auto Draft',
+				'post_type'    => 'post',
+			)
+		);
+	}
+
+	/**
+	 * Dispatches an autosave request for a post.
+	 *
+	 * @param int    $post_id Post ID.
+	 * @param string $title   Autosaved post title.
+	 * @param string $content Autosaved post content.
+	 * @return WP_REST_Response Autosave response.
+	 */
+	private function dispatch_autosave( int $post_id, string $title, string $content ): WP_REST_Response {
+		$request = new WP_REST_Request( 'POST', "/wp/v2/posts/{$post_id}/autosaves" );
+		$request->set_param( 'title', $title );
+		$request->set_param( 'content', $content );
+		$request->set_param( 'status', 'draft' );
+
+		return rest_get_server()->dispatch( $request );
+	}
+
+	public function test_auto_draft_autosave_promotes_parent_post_when_collaboration_is_disabled() {
+		update_option( 'wp_collaboration_enabled', 0 );
+
+		$post_id = $this->create_auto_draft();
+		$title   = 'No RTC autosaved title';
+		$content = '<!-- wp:paragraph --><p>No RTC autosaved content</p><!-- /wp:paragraph -->';
+
+		$response = $this->dispatch_autosave( $post_id, $title, $content );
+
+		$this->assertSame( 200, $response->get_status() );
+		$post = get_post( $post_id );
+		$this->assertSame( 'draft', $post->post_status );
+		$this->assertSame( $title, $post->post_title );
+		$this->assertSame( $content, $post->post_content );
+	}
+
+	public function test_auto_draft_autosave_promotes_parent_post_when_collaboration_is_enabled() {
+		update_option( 'wp_collaboration_enabled', 1 );
+
+		$post_id = $this->create_auto_draft();
+		$title   = 'RTC autosaved title';
+		$content = '<!-- wp:paragraph --><p>RTC autosaved content</p><!-- /wp:paragraph -->';
+
+		$response = $this->dispatch_autosave( $post_id, $title, $content );
+
+		$this->assertSame( 200, $response->get_status() );
+		$post = get_post( $post_id );
+		$this->assertSame( 'draft', $post->post_status );
+		$this->assertSame( $title, $post->post_title );
+		$this->assertSame( $content, $post->post_content );
+	}
+}

test/e2e/specs/editor/collaboration/collaboration-autodraft-autosave-loss.spec.ts

@@ -0,0 +1,133 @@
+/**
+ * External dependencies
+ */
+import type { Page, Response } from '@playwright/test';
+
+/**
+ * Internal dependencies
+ */
+import { test, expect } from './fixtures';
+
+type RestPost = {
+	id: number;
+	status: string;
+	title?: { raw?: string; rendered?: string } | string;
+	content?: { raw?: string; rendered?: string } | string;
+};
+
+function rawField( field: RestPost[ 'title' ] ): string {
+	if ( ! field ) {
+		return '';
+	}
+
+	return typeof field === 'string'
+		? field
+		: field.raw ?? field.rendered ?? '';
+}
+
+async function getCurrentPostId( page: Page ): Promise< number > {
+	return page.evaluate( () =>
+		( window as any ).wp.data.select( 'core/editor' ).getCurrentPostId()
+	);
+}
+
+function isAutosaveResponse( response: Response, postId: number ): boolean {
+	if ( response.request().method() !== 'POST' ) {
+		return false;
+	}
+
+	const url = new URL( response.url() );
+	const route = `/wp/v2/posts/${ postId }/autosaves`;
+
+	return (
+		url.pathname.includes( `/wp-json${ route }` ) ||
+		url.searchParams.get( 'rest_route' ) === route
+	);
+}
+
+async function useFastAutosaveInterval( page: Page ): Promise< void > {
+	await page.evaluate( () => {
+		const editorStore = ( window as any ).wp.data.select( 'core/editor' );
+		const settings = editorStore.getEditorSettings();
+
+		( window as any ).wp.data
+			.dispatch( 'core/editor' )
+			.updateEditorSettings( {
+				...settings,
+				autosaveInterval: 1,
+			} );
+	} );
+}
+
+test.describe( 'Collaboration - auto-draft autosave retention', () => {
+	test( 'keeps a new post discoverable after the editor automatically autosaves it', async ( {
+		admin,
+		collaborationUtils,
+		editor,
+		page,
+		requestUtils,
+	} ) => {
+		test.setTimeout( 120_000 );
+
+		const title = 'RTC automatic auto-draft autosave title';
+		const marker = 'rtc-automatic-auto-draft-autosave-content';
+
+		await admin.visitAdminPage( 'post-new.php' );
+		await editor.setPreferences( 'core/edit-post', {
+			welcomeGuide: false,
+			fullscreenMode: false,
+		} );
+		await collaborationUtils.waitForEntityReady( page, {
+			requireCollaboration: false,
+			timeout: 30_000,
+		} );
+		await collaborationUtils.waitForCollaborationReady( page, {
+			timeout: 30_000,
+		} );
+
+		await editor.canvas
+			.getByRole( 'textbox', { name: 'Add title' } )
+			.fill( title );
+		await editor.canvas
+			.getByRole( 'button', { name: 'Add default block' } )
+			.click();
+		await page.keyboard.type( marker );
+
+		const postId = await getCurrentPostId( page );
+		const autosaveRequest = page.waitForResponse(
+			( response ) => isAutosaveResponse( response, postId ),
+			{ timeout: 30_000 }
+		);
+		await useFastAutosaveInterval( page );
+
+		await autosaveRequest;
+		await page.waitForFunction(
+			() =>
+				! ( window as any ).wp.data
+					.select( 'core/editor' )
+					.isAutosavingPost(),
+			undefined,
+			{ timeout: 30_000 }
+		);
+
+		const post = await requestUtils.rest< RestPost >( {
+			path: `/wp/v2/posts/${ postId }`,
+			params: {
+				context: 'edit',
+			},
+		} );
+		const drafts = await requestUtils.rest< RestPost[] >( {
+			path: '/wp/v2/posts',
+			params: {
+				context: 'edit',
+				status: 'draft',
+				search: title,
+			},
+		} );
+
+		expect( post.status ).toBe( 'draft' );
+		expect( rawField( post.title ) ).toContain( title );
+		expect( rawField( post.content ) ).toContain( marker );
+		expect( drafts.map( ( draft ) => draft.id ) ).toContain( postId );
+	} );
+} );

test/e2e/specs/editor/various/change-detection.spec.js

@@ -65,13 +65,9 @@ test.describe( 'Change detection', () => {
 			).toBeDisabled(),
 		] );
 
-		// With RTC enabled, all autosaves target an autosave revision. Vary our
-		// expectation accordingly.
-		const isRTCEnabled = Boolean(
-			await page.evaluate( () => window._wpCollaborationEnabled )
-		);
-
-		expect( await changeDetectionUtils.getIsDirty() ).toBe( isRTCEnabled );
+		// New auto-drafts are promoted to drafts on first autosave, including
+		// when RTC is enabled, so the editor should no longer be dirty.
+		expect( await changeDetectionUtils.getIsDirty() ).toBe( false );
 	} );
 
 	test( 'Should prompt to confirm unsaved changes for autosaved draft for non-content fields', async ( {
@@ -528,12 +524,9 @@ test.describe( 'Change detection', () => {
 			).toBeDisabled(),
 		] );
 
-		// With RTC enabled, all autosaves target an autosave revision. Vary our
-		// expectation accordingly.
-		const isRTCEnabled = Boolean(
-			await page.evaluate( () => window._wpCollaborationEnabled )
-		);
-		expect( await changeDetectionUtils.getIsDirty() ).toBe( isRTCEnabled );
+		// New auto-drafts are promoted to drafts on first autosave, including
+		// when RTC is enabled, so content edits should be clean afterward.
+		expect( await changeDetectionUtils.getIsDirty() ).toBe( false );
 	} );
 } );