@wordpress/core-data 7.27.0 → 7.28.0

package/src/test/private-actions.js

@@ -0,0 +1,213 @@
+/**
+ * WordPress dependencies
+ */
+import apiFetch from '@wordpress/api-fetch';
+
+/**
+ * Internal dependencies
+ */
+import { editMediaEntity } from '../private-actions';
+
+jest.mock( '@wordpress/api-fetch' );
+
+describe( 'editMediaEntity', () => {
+	let dispatch;
+	let resolveSelect;
+
+	beforeEach( () => {
+		apiFetch.mockReset();
+		dispatch = Object.assign( jest.fn(), {
+			receiveEntityRecords: jest.fn(),
+			__unstableAcquireStoreLock: jest.fn( () => 'test-lock' ),
+			__unstableReleaseStoreLock: jest.fn(),
+		} );
+		resolveSelect = {
+			getEntitiesConfig: jest.fn( () => [
+				{
+					kind: 'postType',
+					name: 'attachment',
+					baseURL: '/wp/v2/media',
+				},
+			] ),
+		};
+	} );
+
+	it( 'should return early when recordId is not provided', async () => {
+		const result = await editMediaEntity( null )( {
+			dispatch,
+			resolveSelect,
+		} );
+
+		expect( result ).toBeUndefined();
+		expect( dispatch.__unstableAcquireStoreLock ).not.toHaveBeenCalled();
+		expect( apiFetch ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should return early when entity config is not found', async () => {
+		resolveSelect.getEntitiesConfig.mockReturnValue( [] );
+
+		const result = await editMediaEntity( 123 )( {
+			dispatch,
+			resolveSelect,
+		} );
+
+		expect( result ).toBeUndefined();
+		expect( dispatch.__unstableAcquireStoreLock ).not.toHaveBeenCalled();
+		expect( apiFetch ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should successfully edit a media entity', async () => {
+		const recordId = 123;
+		const edits = {
+			src: 'https://example.com/image.jpg',
+			modifiers: [
+				{ type: 'resize', args: { width: 300, height: 200 } },
+			],
+		};
+		const updatedRecord = {
+			id: recordId,
+			src: 'https://example.com/image.jpg',
+			modified: true,
+		};
+
+		apiFetch.mockResolvedValue( updatedRecord );
+
+		const result = await editMediaEntity(
+			recordId,
+			edits
+		)( {
+			dispatch,
+			resolveSelect,
+		} );
+
+		expect( dispatch.__unstableAcquireStoreLock ).toHaveBeenCalledWith(
+			'core',
+			[ 'entities', 'records', 'postType', 'attachment', recordId ],
+			{ exclusive: true }
+		);
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'SAVE_ENTITY_RECORD_START',
+			kind: 'postType',
+			name: 'attachment',
+			recordId,
+		} );
+
+		expect( apiFetch ).toHaveBeenCalledWith( {
+			path: '/wp/v2/media/123/edit',
+			method: 'POST',
+			data: edits,
+		} );
+
+		expect( dispatch.receiveEntityRecords ).toHaveBeenCalledWith(
+			'postType',
+			'attachment',
+			[ updatedRecord ],
+			undefined,
+			true,
+			undefined,
+			undefined
+		);
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'SAVE_ENTITY_RECORD_FINISH',
+			kind: 'postType',
+			name: 'attachment',
+			recordId,
+			error: undefined,
+		} );
+
+		expect( dispatch.__unstableReleaseStoreLock ).toHaveBeenCalledWith(
+			'test-lock'
+		);
+
+		expect( result ).toBe( updatedRecord );
+	} );
+
+	it( 'should handle API errors when throwOnError is false', async () => {
+		const recordId = 123;
+		const edits = { src: 'https://example.com/image.jpg' };
+		const apiError = new Error( 'API error' );
+
+		apiFetch.mockRejectedValue( apiError );
+
+		const result = await editMediaEntity( recordId, edits, {
+			throwOnError: false,
+		} )( { dispatch, resolveSelect } );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'SAVE_ENTITY_RECORD_START',
+			kind: 'postType',
+			name: 'attachment',
+			recordId,
+		} );
+
+		expect( dispatch ).toHaveBeenCalledWith( {
+			type: 'SAVE_ENTITY_RECORD_FINISH',
+			kind: 'postType',
+			name: 'attachment',
+			recordId,
+			error: apiError,
+		} );
+
+		expect( dispatch.__unstableReleaseStoreLock ).toHaveBeenCalledWith(
+			'test-lock'
+		);
+
+		expect( result ).toBeUndefined();
+	} );
+
+	it( 'should throw errors when throwOnError is true', async () => {
+		const recordId = 123;
+		const edits = { src: 'https://example.com/image.jpg' };
+		const apiError = new Error( 'API error' );
+
+		apiFetch.mockRejectedValue( apiError );
+
+		await expect(
+			editMediaEntity( recordId, edits, { throwOnError: true } )( {
+				dispatch,
+				resolveSelect,
+			} )
+		).rejects.toEqual( apiError );
+
+		expect( dispatch.__unstableReleaseStoreLock ).toHaveBeenCalledWith(
+			'test-lock'
+		);
+	} );
+
+	it( 'should use custom fetch function when provided', async () => {
+		const recordId = 123;
+		const edits = { src: 'https://example.com/image.jpg' };
+		const customFetch = jest.fn().mockResolvedValue( { id: recordId } );
+
+		await editMediaEntity( recordId, edits, {
+			__unstableFetch: customFetch,
+		} )( { dispatch, resolveSelect } );
+
+		expect( customFetch ).toHaveBeenCalledWith( {
+			path: '/wp/v2/media/123/edit',
+			method: 'POST',
+			data: edits,
+		} );
+		expect( apiFetch ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should handle null response from API', async () => {
+		const recordId = 123;
+		const edits = { src: 'https://example.com/image.jpg' };
+
+		apiFetch.mockResolvedValue( null );
+
+		const result = await editMediaEntity(
+			recordId,
+			edits
+		)( {
+			dispatch,
+			resolveSelect,
+		} );
+
+		expect( dispatch.receiveEntityRecords ).not.toHaveBeenCalled();
+		expect( result ).toBeUndefined();
+	} );
+} );

package/src/test/resolvers.js

@@ -379,8 +379,8 @@ describe( 'getEmbedPreview', () => {
 describe( 'canUser', () => {
 	const ENTITIES = [
 		{
-			name: 'media',
-			kind: 'root',
+			name: 'attachment',
+			kind: 'postType',
 			baseURL: '/wp/v2/media',
 			baseURLParams: { context: 'edit' },
 		},
@@ -417,7 +417,7 @@ describe( 'canUser', () => {
 			'create',
 			'media'
 		)( { dispatch, registry, resolveSelect } );
-		await canUser( 'create', { kind: 'root', name: 'media' } )( {
+		await canUser( 'create', { kind: 'postType', name: 'attachment' } )( {
 			dispatch,
 			registry,
 			resolveSelect,
@@ -469,7 +469,7 @@ describe( 'canUser', () => {
 			headers: new Map( [ [ 'allow', 'GET' ] ] ),
 		} ) );
 
-		await canUser( 'create', { kind: 'root', name: 'media' } )( {
+		await canUser( 'create', { kind: 'postType', name: 'attachment' } )( {
 			dispatch,
 			registry,
 			resolveSelect,
@@ -482,7 +482,7 @@ describe( 'canUser', () => {
 		} );
 
 		expect( dispatch.receiveUserPermission ).toHaveBeenCalledWith(
-			'create/root/media',
+			'create/postType/attachment',
 			false
 		);
 	} );
@@ -514,7 +514,7 @@ describe( 'canUser', () => {
 			headers: new Map( [ [ 'allow', 'POST, GET, PUT, DELETE' ] ] ),
 		} ) );
 
-		await canUser( 'create', { kind: 'root', name: 'media' } )( {
+		await canUser( 'create', { kind: 'postType', name: 'attachment' } )( {
 			dispatch,
 			registry,
 			resolveSelect,
@@ -527,7 +527,7 @@ describe( 'canUser', () => {
 		} );
 
 		expect( dispatch.receiveUserPermission ).toHaveBeenCalledWith(
-			'create/root/media',
+			'create/postType/attachment',
 			true
 		);
 	} );

package/src/test/selectors.js

@@ -24,6 +24,7 @@ import {
 	getRevisions,
 	getRevision,
 } from '../selectors';
+
 // getEntityRecord and __experimentalGetEntityRecordNoResolver selectors share the same tests.
 describe.each( [
 	[ getEntityRecord ],
@@ -52,6 +53,7 @@ describe.each( [
 			] );
 		} );
 	} );
+
 	it( 'should return undefined for unknown entity kind, name', () => {
 		const state = deepFreeze( {
 			entities: {
@@ -290,6 +292,7 @@ describe( 'getRawEntityRecord', () => {
 			},
 		},
 	};
+
 	it( 'should preserve the structure of `raw` field by default', () => {
 		const state = deepFreeze( {
 			entities: {
@@ -732,7 +735,7 @@ describe( 'canUser', () => {
 		} );
 		expect( canUser( state, 'create', 'media' ) ).toBe( undefined );
 		expect(
-			canUser( state, 'create', { kind: 'root', name: 'media' } )
+			canUser( state, 'create', { kind: 'postType', name: 'attachment' } )
 		).toBe( undefined );
 	} );
 
@@ -740,20 +743,24 @@ describe( 'canUser', () => {
 		const state = deepFreeze( {
 			userPermissions: {},
 		} );
-		expect( canUser( state, 'create', { name: 'media' } ) ).toBe( false );
-		expect( canUser( state, 'create', { kind: 'root' } ) ).toBe( false );
+		expect( canUser( state, 'create', { name: 'attachment' } ) ).toBe(
+			false
+		);
+		expect( canUser( state, 'create', { kind: 'postType' } ) ).toBe(
+			false
+		);
 	} );
 
 	it( 'returns whether an action can be performed', () => {
 		const state = deepFreeze( {
 			userPermissions: {
 				'create/media': false,
-				'create/root/media': false,
+				'create/postType/attachment': false,
 			},
 		} );
 		expect( canUser( state, 'create', 'media' ) ).toBe( false );
 		expect(
-			canUser( state, 'create', { kind: 'root', name: 'media' } )
+			canUser( state, 'create', { kind: 'postType', name: 'attachment' } )
 		).toBe( false );
 	} );
 
@@ -761,12 +768,16 @@ describe( 'canUser', () => {
 		const state = deepFreeze( {
 			userPermissions: {
 				'create/media/123': false,
-				'create/root/media/123': false,
+				'create/postType/attachment/123': false,
 			},
 		} );
 		expect( canUser( state, 'create', 'media', 123 ) ).toBe( false );
 		expect(
-			canUser( state, 'create', { kind: 'root', name: 'media', id: 123 } )
+			canUser( state, 'create', {
+				kind: 'postType',
+				name: 'attachment',
+				id: 123,
+			} )
 		).toBe( false );
 	} );
 } );

package/src/utils/log-entity-deprecation.ts

@@ -0,0 +1,67 @@
+/**
+ * WordPress dependencies
+ */
+import deprecated from '@wordpress/deprecated';
+
+/**
+ * Internal dependencies
+ */
+import { deprecatedEntities } from '../entities';
+
+let loggedAlready = false;
+
+/**
+ * Logs a deprecation warning for an entity, if it's deprecated.
+ *
+ * @param kind                            The kind of the entity.
+ * @param name                            The name of the entity.
+ * @param functionName                    The name of the function that was called with a deprecated entity.
+ * @param options                         The options for the deprecation warning.
+ * @param options.alternativeFunctionName The name of the alternative function that should be used instead.
+ * @param options.isShorthandSelector     Whether the function is a shorthand selector.
+ */
+export default function logEntityDeprecation(
+	kind: string,
+	name: string,
+	functionName: string,
+	{
+		alternativeFunctionName,
+		isShorthandSelector = false,
+	}: {
+		alternativeFunctionName?: string;
+		isShorthandSelector?: boolean;
+	} = {}
+) {
+	const deprecation = deprecatedEntities[ kind ]?.[ name ];
+	if ( ! deprecation ) {
+		return;
+	}
+
+	if ( ! loggedAlready ) {
+		const { alternative } = deprecation;
+
+		const message = isShorthandSelector
+			? `'${ functionName }'`
+			: `The '${ kind }', '${ name }' entity (used via '${ functionName }')`;
+
+		let alternativeMessage = `the '${ alternative.kind }', '${ alternative.name }' entity`;
+		if ( alternativeFunctionName ) {
+			alternativeMessage += ` via the '${ alternativeFunctionName }' function`;
+		}
+
+		deprecated( message, {
+			...deprecation,
+			alternative: alternativeMessage,
+		} );
+	}
+
+	// Only log an entity deprecation once per call stack,
+	// else there's spurious logging when selections or actions call through to other selectors or actions.
+	// Note: this won't prevent the deprecation warning being logged if a selector or action makes an async call
+	// to another selector or action, but this is probably the best we can do.
+	loggedAlready = true;
+	// At the end of the call stack, reset the flag.
+	setTimeout( () => {
+		loggedAlready = false;
+	}, 0 );
+}

package/src/utils/test/log-entity-deprecation.js

@@ -0,0 +1,130 @@
+/**
+ * WordPress dependencies
+ */
+import deprecated from '@wordpress/deprecated';
+
+/**
+ * Internal dependencies
+ */
+import logEntityDeprecation from '../log-entity-deprecation';
+
+jest.useFakeTimers();
+
+// Mock the deprecatedEntities import
+jest.mock( '../../entities', () => ( {
+	deprecatedEntities: {
+		root: {
+			media: {
+				since: '6.9',
+				alternative: {
+					kind: 'postType',
+					name: 'attachment',
+				},
+			},
+		},
+	},
+} ) );
+
+// Mock the deprecated function
+jest.mock( '@wordpress/deprecated' );
+
+describe( 'logEntityDeprecation', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+
+		// Ensure the timeout that prevents spurious logging is cleared.
+		jest.runAllTimers();
+	} );
+
+	it( 'should call deprecated when entity is deprecated', () => {
+		logEntityDeprecation( 'root', 'media', 'getEntityRecord' );
+
+		expect( deprecated ).toHaveBeenCalledWith(
+			"The 'root', 'media' entity (used via 'getEntityRecord')",
+			{
+				since: '6.9',
+				alternative: "the 'postType', 'attachment' entity",
+			}
+		);
+	} );
+
+	it( 'should not call deprecated when entity is not deprecated', () => {
+		logEntityDeprecation( 'root', 'nonExistentEntity', 'getEntityRecord' );
+
+		expect( deprecated ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should not call deprecated when kind is not deprecated', () => {
+		logEntityDeprecation( 'nonExistentKind', 'media', 'getEntityRecord' );
+
+		expect( deprecated ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should handle different function names', () => {
+		logEntityDeprecation( 'root', 'media', 'saveEntityRecord' );
+
+		expect( deprecated ).toHaveBeenCalledWith(
+			"The 'root', 'media' entity (used via 'saveEntityRecord')",
+			{
+				since: '6.9',
+				alternative: "the 'postType', 'attachment' entity",
+			}
+		);
+	} );
+
+	it( 'should include alternative function name when provided', () => {
+		logEntityDeprecation( 'root', 'media', 'getEntityRecord', {
+			alternativeFunctionName: 'getPostTypeEntity',
+		} );
+
+		expect( deprecated ).toHaveBeenCalledWith(
+			"The 'root', 'media' entity (used via 'getEntityRecord')",
+			{
+				since: '6.9',
+				alternative:
+					"the 'postType', 'attachment' entity via the 'getPostTypeEntity' function",
+			}
+		);
+	} );
+
+	it( 'should handle isShorthandSelector', () => {
+		logEntityDeprecation( 'root', 'media', 'getMedia', {
+			isShorthandSelector: true,
+		} );
+
+		expect( deprecated ).toHaveBeenCalledWith( "'getMedia'", {
+			since: '6.9',
+			alternative: "the 'postType', 'attachment' entity",
+		} );
+	} );
+
+	it( 'should handle empty string parameters', () => {
+		logEntityDeprecation( '', '', '' );
+
+		expect( deprecated ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should handle null parameters', () => {
+		logEntityDeprecation( null, null, null );
+
+		expect( deprecated ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should handle undefined parameters', () => {
+		logEntityDeprecation( undefined, undefined, undefined );
+
+		expect( deprecated ).not.toHaveBeenCalled();
+	} );
+
+	it( 'should handle undefined options', () => {
+		logEntityDeprecation( 'root', 'media', 'getEntityRecord', undefined );
+
+		expect( deprecated ).toHaveBeenCalledWith(
+			"The 'root', 'media' entity (used via 'getEntityRecord')",
+			{
+				since: '6.9',
+				alternative: "the 'postType', 'attachment' entity",
+			}
+		);
+	} );
+} );