Core Data: report autosave resolution on every exit path

The completion dispatch sat on the success path only, so an early return
(unknown author, post type without autosave support) or a rejected request
skipped it. hasFetchedAutosaves then stayed false and
isEditedPostAutosaveable never enabled autosaving for the session.

This was a regression against the delegation it replaced: that completed
getAutosaves resolution unconditionally, and hasFinishedResolution treats an
errored resolution as complete, so even a failed fetch counted as fetched.

Move the dispatch into a finally, and correct the docblock, which claimed
getAutosaves was unaffected. Reporting against its key also suppresses that
resolver via hasStartedResolution, so a later direct call returns the stored
single-author array rather than refetching.

Two existing tests asserted the dispatch was NOT made on the early-return
paths, encoding the bug as intended behavior. They now assert the opposite,
and cover the failed-request path.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: whyisjake

packages/core-data/src/resolvers.js

@@ -628,11 +628,23 @@ export const getAutosaves =
  * long-lived post with many editors, the difference is the entire collection
  * versus one row.
  *
- * `getAutosaves` is intentionally left alone rather than being narrowed, so
- * calling it directly still returns the full collection. Its resolution is
- * marked finished here because `hasFetchedAutosaves` reports on it, and
- * `isEditedPostAutosaveable` in @wordpress/editor treats an unfinished
- * resolution as "not yet known" — without this, autosaving would never enable.
+ * The `getAutosaves` resolver itself is left unchanged. This one reports
+ * completion against the `getAutosaves` resolution key because that is what
+ * `hasFetchedAutosaves` reads, and the editor package's
+ * `isEditedPostAutosaveable` treats an unfinished resolution as "not yet
+ * known" — without it, autosaving would never enable.
+ *
+ * That report happens in a `finally` so it covers every exit path. The previous
+ * delegation to `getAutosaves` completed its resolution unconditionally, and a
+ * failed request still counted as finished (`hasFinishedResolution` treats
+ * `error` as complete). Reporting only on the success path would leave
+ * autosaving disabled for the rest of the session after a single early return
+ * or network failure.
+ *
+ * Note that reporting against `getAutosaves` also suppresses that resolver for
+ * the post: `hasStartedResolution` becomes true, so a later direct call to the
+ * `getAutosaves` selector returns whatever this resolver stored rather than
+ * refetching the full collection.
  *
  * @param {string} postType The type of the parent post.
  * @param {number} postId   The id of the parent post.
@@ -641,36 +653,38 @@ export const getAutosaves =
 export const getAutosave =
 	( postType, postId, authorId ) =>
 	async ( { dispatch, resolveSelect } ) => {
-		if ( authorId === undefined ) {
-			return;
-		}
+		try {
+			if ( authorId === undefined ) {
+				return;
+			}
 
-		const {
-			rest_base: restBase,
-			rest_namespace: restNamespace = 'wp/v2',
-			supports,
-		} = await resolveSelect.getPostType( postType );
+			const {
+				rest_base: restBase,
+				rest_namespace: restNamespace = 'wp/v2',
+				supports,
+			} = await resolveSelect.getPostType( postType );
 
-		if ( ! supports?.autosave ) {
-			return;
-		}
+			if ( ! supports?.autosave ) {
+				return;
+			}
 
-		const autosaves = await apiFetch( {
-			path: addQueryArgs(
-				`/${ restNamespace }/${ restBase }/${ postId }/autosaves`,
-				{
-					context: 'edit',
-					per_page: 1,
-					author: authorId,
-				}
-			),
-		} );
+			const autosaves = await apiFetch( {
+				path: addQueryArgs(
+					`/${ restNamespace }/${ restBase }/${ postId }/autosaves`,
+					{
+						context: 'edit',
+						per_page: 1,
+						author: authorId,
+					}
+				),
+			} );
 
-		if ( autosaves && autosaves.length ) {
-			dispatch.receiveAutosaves( postId, autosaves );
+			if ( autosaves && autosaves.length ) {
+				dispatch.receiveAutosaves( postId, autosaves );
+			}
+		} finally {
+			dispatch.finishResolution( 'getAutosaves', [ postType, postId ] );
 		}
-
-		dispatch.finishResolution( 'getAutosaves', [ postType, postId ] );
 	};
 
 export const __experimentalGetCurrentGlobalStylesId =

packages/core-data/src/test/autosaves.js

@@ -124,6 +124,58 @@ describe( 'autosaves', () => {
 		} );
 	} );
 
+	it( 'reports hasFetchedAutosaves after a failed request', async () => {
+		const registry = createTestRegistry();
+		triggerFetch.mockImplementation( ( { path, parse } ) => {
+			if ( path.startsWith( '/wp/v2/types' ) ) {
+				const postType = {
+					slug: 'post',
+					rest_base: 'posts',
+					rest_namespace: 'wp/v2',
+					supports: { autosave: true },
+				};
+
+				if ( parse === false ) {
+					return {
+						json: async () => postType,
+						headers: { get: () => '' },
+					};
+				}
+
+				return postType;
+			}
+
+			throw new Error( 'Network error' );
+		} );
+
+		await registry
+			.resolveSelect( coreDataStore )
+			.getAutosave( 'post', POST_ID, AUTHOR_ID )
+			.catch( () => {} );
+
+		// Autosaving must not stay disabled for the session after one failure.
+		expect(
+			registry
+				.select( coreDataStore )
+				.hasFetchedAutosaves( 'post', POST_ID )
+		).toBe( true );
+	} );
+
+	it( 'reports hasFetchedAutosaves when the author is not yet known', async () => {
+		const registry = createTestRegistry();
+		mockFetch( [ AUTOSAVE ] );
+
+		await registry
+			.resolveSelect( coreDataStore )
+			.getAutosave( 'post', POST_ID, undefined );
+
+		expect(
+			registry
+				.select( coreDataStore )
+				.hasFetchedAutosaves( 'post', POST_ID )
+		).toBe( true );
+	} );
+
 	it( 'does not return another author’s autosave', async () => {
 		const registry = createTestRegistry();
 		mockFetch( [ { id: 100, author: 999, parent: POST_ID } ] );

packages/core-data/src/test/resolvers.js

@@ -958,7 +958,7 @@ describe( 'getAutosave', () => {
 		);
 	} );
 
-	it( 'does not fetch when the author is unknown', async () => {
+	it( 'does not fetch when the author is unknown, but still finishes resolution', async () => {
 		const { dispatch, resolveSelect } = setUp( SUCCESSFUL_RESPONSE );
 
 		await getAutosave(
@@ -968,10 +968,15 @@ describe( 'getAutosave', () => {
 		)( { dispatch, resolveSelect } );
 
 		expect( triggerFetch ).not.toHaveBeenCalled();
-		expect( dispatch.finishResolution ).not.toHaveBeenCalled();
+		// Bailing without reporting would leave autosaving disabled for the
+		// session if the current user id never arrives.
+		expect( dispatch.finishResolution ).toHaveBeenCalledWith(
+			'getAutosaves',
+			[ postType, postId ]
+		);
 	} );
 
-	it( 'does not fetch when the post type does not support autosaves', async () => {
+	it( 'does not fetch when the post type does not support autosaves, but still finishes resolution', async () => {
 		const { dispatch } = setUp( SUCCESSFUL_RESPONSE );
 		const resolveSelect = Object.assign( jest.fn(), {
 			getPostType: jest.fn( () => ( {
@@ -987,7 +992,33 @@ describe( 'getAutosave', () => {
 		)( { dispatch, resolveSelect } );
 
 		expect( triggerFetch ).not.toHaveBeenCalled();
-		expect( dispatch.finishResolution ).not.toHaveBeenCalled();
+		expect( dispatch.finishResolution ).toHaveBeenCalledWith(
+			'getAutosaves',
+			[ postType, postId ]
+		);
+	} );
+
+	it( 'finishes resolution even when the request fails', async () => {
+		const { dispatch, resolveSelect } = setUp( SUCCESSFUL_RESPONSE );
+		triggerFetch.mockImplementation( () => {
+			throw new Error( 'Network error' );
+		} );
+
+		await expect(
+			getAutosave(
+				postType,
+				postId,
+				AUTHOR_ID
+			)( { dispatch, resolveSelect } )
+		).rejects.toThrow( 'Network error' );
+
+		expect( dispatch.receiveAutosaves ).not.toHaveBeenCalled();
+		// A failed fetch previously still counted as fetched, because
+		// hasFinishedResolution treats an errored resolution as complete.
+		expect( dispatch.finishResolution ).toHaveBeenCalledWith(
+			'getAutosaves',
+			[ postType, postId ]
+		);
 	} );
 
 	it( 'leaves the getAutosaves resolver behavior unchanged', async () => {