Collaboration: Add collaboration_storage filter for pluggable storage backends

Allow hosts and plugins to replace the default database-backed storage
with a custom WP_Collaboration_Storage implementation via mu-plugin.
Combined with the existing sync.providers JS filter, hosts can now
provide WebSocket-based collaboration without patching core.

Includes an in-memory storage implementation and integration test
verifying the filter correctly replaces the backend.

Author: josephfusco

src/wp-includes/rest-api.php

@@ -431,7 +431,18 @@ function create_initial_rest_routes() {
 
 	// Collaboration.
 	if ( wp_is_collaboration_enabled() ) {
-		$collaboration_storage = new WP_Collaboration_Table_Storage();
+		/**
+		 * Filters the storage backend used for collaborative editing.
+		 *
+		 * Allows hosts and plugins to replace the default database-backed
+		 * storage with a custom implementation (e.g. Redis, Memcached).
+		 * The returned object must implement WP_Collaboration_Storage.
+		 *
+		 * @since 7.0.0
+		 *
+		 * @param WP_Collaboration_Storage $storage Storage backend instance.
+		 */
+		$collaboration_storage = apply_filters( 'collaboration_storage', new WP_Collaboration_Table_Storage() );
 		$collaboration_server  = new WP_HTTP_Polling_Collaboration_Server( $collaboration_storage );
 		$collaboration_server->register_routes();
 	}

tests/phpunit/tests/rest-api/rest-collaboration-server.php

@@ -1779,4 +1779,166 @@ public function test_collaboration_idle_poll_query_count(): void {
 			sprintf( 'Idle poll should use at most 3 queries per room, used %d.', $query_count )
 		);
 	}
+
+	/**
+	 * Verifies that the collaboration_storage filter allows replacing the
+	 * default storage backend with a custom implementation.
+	 *
+	 * @ticket 64696
+	 */
+	public function test_collaboration_storage_filter_replaces_backend() {
+		wp_set_current_user( self::$editor_id );
+
+		$custom_storage = new WP_Test_In_Memory_Collaboration_Storage();
+
+		add_filter(
+			'collaboration_storage',
+			static function () use ( $custom_storage ) {
+				return $custom_storage;
+			}
+		);
+
+		// Reset the REST server so routes are re-registered with the filtered storage.
+		global $wp_rest_server;
+		$wp_rest_server = null;
+		rest_get_server();
+
+		$room   = $this->get_post_room();
+		$update = array(
+			'type' => 'update',
+			'data' => base64_encode( 'custom-storage-test' ),
+		);
+
+		// Client 1 sends an update.
+		$response = $this->dispatch_collaboration(
+			array(
+				$this->build_room( $room, 1, 0, array( 'user' => 'c1' ), array( $update ) ),
+			)
+		);
+
+		$this->assertSame( 200, $response->get_status(), 'Custom storage should handle updates.' );
+
+		// Client 2 polls and should receive client 1's update.
+		$response = $this->dispatch_collaboration(
+			array(
+				$this->build_room( $room, 2, 0, array( 'user' => 'c2' ) ),
+			)
+		);
+
+		$data        = $response->get_data();
+		$update_data = wp_list_pluck( $data['rooms'][0]['updates'], 'data' );
+
+		$this->assertContains(
+			base64_encode( 'custom-storage-test' ),
+			$update_data,
+			'Client 2 should receive the update stored by the custom backend.'
+		);
+
+		$this->assertTrue( $custom_storage->was_used, 'The custom storage backend should have been called.' );
+
+		remove_all_filters( 'collaboration_storage' );
+	}
+}
+
+/**
+ * In-memory collaboration storage for testing the collaboration_storage filter.
+ *
+ * Stores all data in arrays with no database interaction.
+ */
+class WP_Test_In_Memory_Collaboration_Storage implements WP_Collaboration_Storage {
+	public $was_used = false;
+
+	private $updates   = array();
+	private $awareness = array();
+	private $next_id   = 1;
+	private $cursors   = array();
+	private $counts    = array();
+
+	public function add_update( string $room, $update ): bool {
+		$this->was_used = true;
+		$this->updates[ $room ][] = array(
+			'id'     => $this->next_id++,
+			'update' => $update,
+		);
+		return true;
+	}
+
+	public function get_awareness_state( string $room, int $timeout = 30 ): array {
+		$this->was_used = true;
+		$cutoff = time() - $timeout;
+		$entries = array();
+		foreach ( $this->awareness[ $room ] ?? array() as $entry ) {
+			if ( $entry['time'] >= $cutoff ) {
+				$entries[] = array(
+					'client_id'  => $entry['client_id'],
+					'state'      => $entry['state'],
+					'wp_user_id' => $entry['wp_user_id'],
+				);
+			}
+		}
+		return $entries;
+	}
+
+	public function get_cursor( string $room ): int {
+		return $this->cursors[ $room ] ?? 0;
+	}
+
+	public function get_update_count( string $room ): int {
+		return $this->counts[ $room ] ?? 0;
+	}
+
+	public function get_updates_after_cursor( string $room, int $cursor ): array {
+		$this->was_used = true;
+		$updates = array();
+		$max_id  = 0;
+		$total   = count( $this->updates[ $room ] ?? array() );
+
+		foreach ( $this->updates[ $room ] ?? array() as $entry ) {
+			if ( $entry['id'] > $max_id ) {
+				$max_id = $entry['id'];
+			}
+			if ( $entry['id'] > $cursor ) {
+				$updates[] = $entry['update'];
+			}
+		}
+
+		$this->cursors[ $room ] = $max_id;
+		$this->counts[ $room ]  = $total;
+		return $updates;
+	}
+
+	public function remove_updates_before_cursor( string $room, int $cursor ): bool {
+		if ( ! isset( $this->updates[ $room ] ) ) {
+			return true;
+		}
+		$this->updates[ $room ] = array_values(
+			array_filter(
+				$this->updates[ $room ],
+				static function ( $entry ) use ( $cursor ) {
+					return $entry['id'] > $cursor;
+				}
+			)
+		);
+		return true;
+	}
+
+	public function set_awareness_state( string $room, int $client_id, array $state, int $wp_user_id ): bool {
+		$this->was_used = true;
+		// Remove existing entry for this client.
+		$this->awareness[ $room ] = array_values(
+			array_filter(
+				$this->awareness[ $room ] ?? array(),
+				static function ( $entry ) use ( $client_id ) {
+					return $entry['client_id'] !== $client_id;
+				}
+			)
+		);
+		$this->awareness[ $room ][] = array(
+			'client_id'  => $client_id,
+			'state'      => $state,
+			'wp_user_id' => $wp_user_id,
+			'time'       => time(),
+		);
+		return true;
+	}
 }