@wordpress/core-data 4.0.1-next.253d9b6e21.0 → 4.0.3

package/src/batch/test/default-processor.js

@@ -11,6 +11,18 @@ import defaultProcessor from '../default-processor';
 jest.mock( '@wordpress/api-fetch' );
 
 describe( 'defaultProcessor', () => {
+	const preflightResponse = {
+		endpoints: [
+			{
+				args: {
+					requests: {
+						maxItems: 25,
+					},
+				},
+			},
+		],
+	};
+
 	const requests = [
 		{
 			path: '/v1/cricketers',
@@ -26,7 +38,12 @@ describe( 'defaultProcessor', () => {
 		},
 	];
 
-	const expectedFetchOptions = {
+	const expectedPreflightOptions = {
+		path: '/batch/v1',
+		method: 'OPTIONS',
+	};
+
+	const expectedBatchOptions = {
 		path: '/batch/v1',
 		method: 'POST',
 		data: {
@@ -49,21 +66,26 @@ describe( 'defaultProcessor', () => {
 	};
 
 	it( 'handles a successful request', async () => {
-		apiFetch.mockImplementation( async () => ( {
-			failed: false,
-			responses: [
-				{
-					status: 200,
-					body: 'Lyon',
-				},
-				{
-					status: 400,
-					body: 'Error!',
-				},
-			],
-		} ) );
+		apiFetch.mockImplementation( async ( { method } ) =>
+			method === 'OPTIONS'
+				? preflightResponse
+				: {
+						failed: false,
+						responses: [
+							{
+								status: 200,
+								body: 'Lyon',
+							},
+							{
+								status: 400,
+								body: 'Error!',
+							},
+						],
+				  }
+		);
 		const results = await defaultProcessor( requests );
-		expect( apiFetch ).toHaveBeenCalledWith( expectedFetchOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedPreflightOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedBatchOptions );
 		expect( results ).toEqual( [
 			{ output: 'Lyon' },
 			{ error: 'Error!' },
@@ -71,18 +93,23 @@ describe( 'defaultProcessor', () => {
 	} );
 
 	it( 'handles a failed request', async () => {
-		apiFetch.mockImplementation( async () => ( {
-			failed: true,
-			responses: [
-				null,
-				{
-					status: 400,
-					body: 'Error!',
-				},
-			],
-		} ) );
+		apiFetch.mockImplementation( async ( { method } ) =>
+			method === 'OPTIONS'
+				? preflightResponse
+				: {
+						failed: true,
+						responses: [
+							null,
+							{
+								status: 400,
+								body: 'Error!',
+							},
+						],
+				  }
+		);
 		const results = await defaultProcessor( requests );
-		expect( apiFetch ).toHaveBeenCalledWith( expectedFetchOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedPreflightOptions );
+		expect( apiFetch ).toHaveBeenCalledWith( expectedBatchOptions );
 		expect( results ).toEqual( [
 			{ error: undefined },
 			{ error: 'Error!' },

package/src/entities.js

@@ -6,18 +6,18 @@ import { upperFirst, camelCase, map, find, get, startCase } from 'lodash';
 /**
  * WordPress dependencies
  */
-import { controls } from '@wordpress/data';
-import { apiFetch } from '@wordpress/data-controls';
+import apiFetch from '@wordpress/api-fetch';
 import { __ } from '@wordpress/i18n';
 
 /**
  * Internal dependencies
  */
 import { addEntities } from './actions';
-import { STORE_NAME } from './name';
 
 export const DEFAULT_ENTITY_KEY = 'id';
 
+const POST_RAW_ATTRIBUTES = [ 'title', 'excerpt', 'content' ];
+
 export const defaultEntities = [
 	{
 		label: __( 'Base' ),
@@ -41,6 +41,7 @@ export const defaultEntities = [
 		key: 'slug',
 		baseURL: '/wp/v2/types',
 		baseURLParams: { context: 'edit' },
+		rawAttributes: POST_RAW_ATTRIBUTES,
 	},
 	{
 		name: 'media',
@@ -115,6 +116,7 @@ export const defaultEntities = [
 		baseURLParams: { context: 'edit' },
 		plural: 'menuItems',
 		label: __( 'Menu Item' ),
+		rawAttributes: [ 'title', 'content' ],
 	},
 	{
 		name: 'menuLocation',
@@ -167,8 +169,8 @@ export const prePersistPostType = ( persistedRecord, edits ) => {
  *
  * @return {Promise} Entities promise
  */
-function* loadPostTypeEntities() {
-	const postTypes = yield apiFetch( { path: '/wp/v2/types?context=edit' } );
+async function loadPostTypeEntities() {
+	const postTypes = await apiFetch( { path: '/wp/v2/types?context=edit' } );
 	return map( postTypes, ( postType, name ) => {
 		const isTemplate = [ 'wp_template', 'wp_template_part' ].includes(
 			name
@@ -184,6 +186,7 @@ function* loadPostTypeEntities() {
 				selection: true,
 			},
 			mergedEdits: { meta: true },
+			rawAttributes: POST_RAW_ATTRIBUTES,
 			getTitle: ( record ) =>
 				record?.title?.rendered ||
 				record?.title ||
@@ -199,8 +202,8 @@ function* loadPostTypeEntities() {
  *
  * @return {Promise} Entities promise
  */
-function* loadTaxonomyEntities() {
-	const taxonomies = yield apiFetch( {
+async function loadTaxonomyEntities() {
+	const taxonomies = await apiFetch( {
 		path: '/wp/v2/taxonomies?context=edit',
 	} );
 	return map( taxonomies, ( taxonomy, name ) => {
@@ -248,12 +251,8 @@ export const getMethodName = (
  *
  * @return {Array} Entities
  */
-export function* getKindEntities( kind ) {
-	let entities = yield controls.select(
-		STORE_NAME,
-		'getEntitiesByKind',
-		kind
-	);
+export const getKindEntities = ( kind ) => async ( { select, dispatch } ) => {
+	let entities = select.getEntitiesByKind( kind );
 	if ( entities && entities.length !== 0 ) {
 		return entities;
 	}
@@ -263,8 +262,8 @@ export function* getKindEntities( kind ) {
 		return [];
 	}
 
-	entities = yield kindConfig.loadEntities();
-	yield addEntities( entities );
+	entities = await kindConfig.loadEntities();
+	dispatch( addEntities( entities ) );
 
 	return entities;
-}
+};

package/src/index.js

@@ -2,7 +2,6 @@
  * WordPress dependencies
  */
 import { createReduxStore, register } from '@wordpress/data';
-import { controls } from '@wordpress/data-controls';
 
 /**
  * Internal dependencies
@@ -11,9 +10,7 @@ import reducer from './reducer';
 import * as selectors from './selectors';
 import * as actions from './actions';
 import * as resolvers from './resolvers';
-import * as locksSelectors from './locks/selectors';
-import * as locksActions from './locks/actions';
-import customControls from './controls';
+import createLocksActions from './locks/actions';
 import { defaultEntities, getMethodName } from './entities';
 import { STORE_NAME } from './name';
 
@@ -57,13 +54,13 @@ const entityActions = defaultEntities.reduce( ( result, entity ) => {
 	return result;
 }, {} );
 
-const storeConfig = {
+const storeConfig = () => ( {
 	reducer,
-	controls: { ...customControls, ...controls },
-	actions: { ...actions, ...entityActions, ...locksActions },
-	selectors: { ...selectors, ...entitySelectors, ...locksSelectors },
+	actions: { ...actions, ...entityActions, ...createLocksActions() },
+	selectors: { ...selectors, ...entitySelectors },
 	resolvers: { ...resolvers, ...entityResolvers },
-};
+	__experimentalUseThunks: true,
+} );
 
 /**
  * Store definition for the code data namespace.
@@ -72,7 +69,7 @@ const storeConfig = {
  *
  * @type {Object}
  */
-export const store = createReduxStore( STORE_NAME, storeConfig );
+export const store = createReduxStore( STORE_NAME, storeConfig() );
 
 register( store );
 

package/src/locks/actions.js

@@ -1,69 +1,18 @@
-/**
- * WordPress dependencies
- */
-import { __unstableAwaitPromise } from '@wordpress/data-controls';
-import { controls } from '@wordpress/data';
-
 /**
  * Internal dependencies
  */
-import { STORE_NAME } from '../name';
+import createLocks from './engine';
 
-export function* __unstableAcquireStoreLock( store, path, { exclusive } ) {
-	const promise = yield* __unstableEnqueueLockRequest( store, path, {
-		exclusive,
-	} );
-	yield* __unstableProcessPendingLockRequests();
-	return yield __unstableAwaitPromise( promise );
-}
+export default function createLocksActions() {
+	const locks = createLocks();
 
-export function* __unstableEnqueueLockRequest( store, path, { exclusive } ) {
-	let notifyAcquired;
-	const promise = new Promise( ( resolve ) => {
-		notifyAcquired = resolve;
-	} );
-	yield {
-		type: 'ENQUEUE_LOCK_REQUEST',
-		request: { store, path, exclusive, notifyAcquired },
-	};
-	return promise;
-}
-
-export function* __unstableReleaseStoreLock( lock ) {
-	yield {
-		type: 'RELEASE_LOCK',
-		lock,
-	};
-	yield* __unstableProcessPendingLockRequests();
-}
+	function __unstableAcquireStoreLock( store, path, { exclusive } ) {
+		return () => locks.acquire( store, path, exclusive );
+	}
 
-export function* __unstableProcessPendingLockRequests() {
-	yield {
-		type: 'PROCESS_PENDING_LOCK_REQUESTS',
-	};
-	const lockRequests = yield controls.select(
-		STORE_NAME,
-		'__unstableGetPendingLockRequests'
-	);
-	for ( const request of lockRequests ) {
-		const { store, path, exclusive, notifyAcquired } = request;
-		const isAvailable = yield controls.select(
-			STORE_NAME,
-			'__unstableIsLockAvailable',
-			store,
-			path,
-			{
-				exclusive,
-			}
-		);
-		if ( isAvailable ) {
-			const lock = { store, path, exclusive };
-			yield {
-				type: 'GRANT_LOCK_REQUEST',
-				lock,
-				request,
-			};
-			notifyAcquired( lock );
-		}
+	function __unstableReleaseStoreLock( lock ) {
+		return () => locks.release( lock );
 	}
+
+	return { __unstableAcquireStoreLock, __unstableReleaseStoreLock };
 }

package/src/locks/engine.js

@@ -0,0 +1,43 @@
+/**
+ * Internal dependencies
+ */
+import reducer from './reducer';
+import { isLockAvailable, getPendingLockRequests } from './selectors';
+
+export default function createLocks() {
+	let state = reducer( undefined, { type: '@@INIT' } );
+
+	function processPendingLockRequests() {
+		for ( const request of getPendingLockRequests( state ) ) {
+			const { store, path, exclusive, notifyAcquired } = request;
+			if ( isLockAvailable( state, store, path, { exclusive } ) ) {
+				const lock = { store, path, exclusive };
+				state = reducer( state, {
+					type: 'GRANT_LOCK_REQUEST',
+					lock,
+					request,
+				} );
+				notifyAcquired( lock );
+			}
+		}
+	}
+
+	function acquire( store, path, exclusive ) {
+		return new Promise( ( resolve ) => {
+			state = reducer( state, {
+				type: 'ENQUEUE_LOCK_REQUEST',
+				request: { store, path, exclusive, notifyAcquired: resolve },
+			} );
+			processPendingLockRequests();
+		} );
+	}
+	function release( lock ) {
+		state = reducer( state, {
+			type: 'RELEASE_LOCK',
+			lock,
+		} );
+		processPendingLockRequests();
+	}
+
+	return { acquire, release };
+}

package/src/locks/reducer.js

@@ -19,7 +19,7 @@ const DEFAULT_STATE = {
  *
  * @return {Object} Updated state.
  */
-export function locks( state = DEFAULT_STATE, action ) {
+export default function locks( state = DEFAULT_STATE, action ) {
 	switch ( action.type ) {
 		case 'ENQUEUE_LOCK_REQUEST': {
 			const { request } = action;
@@ -60,5 +60,3 @@ export function locks( state = DEFAULT_STATE, action ) {
 
 	return state;
 }
-
-export default locks;

package/src/locks/selectors.js

@@ -8,13 +8,13 @@ import {
 	getNode,
 } from './utils';
 
-export function __unstableGetPendingLockRequests( state ) {
-	return state.locks.requests;
+export function getPendingLockRequests( state ) {
+	return state.requests;
 }
 
-export function __unstableIsLockAvailable( state, store, path, { exclusive } ) {
+export function isLockAvailable( state, store, path, { exclusive } ) {
 	const storePath = [ store, ...path ];
-	const locks = state.locks.tree;
+	const locks = state.tree;
 
 	// Validate all parents and the node itself
 	for ( const node of iteratePath( locks, storePath ) ) {

package/src/locks/test/engine.js

@@ -0,0 +1,135 @@
+/**
+ * Internal dependencies
+ */
+import createLocks from '../engine';
+
+jest.useRealTimers();
+
+// we correctly await all promises with expect calls, but the rule doesn't detect that
+/* eslint-disable jest/valid-expect-in-promise */
+
+describe( 'Locks engine', () => {
+	it( 'does not grant two exclusive locks at once', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], true );
+		const l2 = locks.acquire( 'store', [ 'root' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'does not grant an exclusive lock if a non-exclusive one already exists', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], false );
+		const l2 = locks.acquire( 'store', [ 'root' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'does not grant two exclusive locks to parent and child', async () => {
+		const locks = createLocks();
+
+		let l1Granted = false;
+		let l2Granted = false;
+
+		// request two locks
+		const l1 = locks.acquire( 'store', [ 'root' ], true );
+		const l2 = locks.acquire( 'store', [ 'root', 'child' ], true );
+
+		// on each grant, verify that the other lock is not granted at the same time
+		const check1 = l1.then( () => {
+			l1Granted = true;
+			expect( l2Granted ).toBe( false );
+		} );
+
+		const check2 = l2.then( () => {
+			l2Granted = true;
+			expect( l1Granted ).toBe( false );
+		} );
+
+		// unlock both
+		const lock1 = await l1;
+		locks.release( lock1 );
+		l1Granted = false;
+
+		const lock2 = await l2;
+		locks.release( lock2 );
+		l2Granted = false;
+
+		// ensure that both locks were granted and checked
+		return await Promise.all( [ check1, check2 ] );
+	} );
+
+	it( 'grants two non-exclusive locks at once', async () => {
+		const locks = createLocks();
+
+		const l1 = await locks.acquire( 'store', [ 'root' ], false );
+		const l2 = await locks.acquire( 'store', [ 'root' ], false );
+
+		expect( l1 ).not.toBeUndefined();
+		expect( l2 ).not.toBeUndefined();
+	} );
+
+	it( 'grants two exclusive locks to different branches', async () => {
+		const locks = createLocks();
+
+		const l1 = await locks.acquire( 'store', [ 'a' ], true );
+		const l2 = await locks.acquire( 'store', [ 'b' ], true );
+
+		expect( l1 ).not.toBeUndefined();
+		expect( l2 ).not.toBeUndefined();
+	} );
+} );
+
+/* eslint-enable jest/valid-expect-in-promise */

package/src/locks/test/reducer.js

@@ -6,7 +6,7 @@ import deepFreeze from 'deep-freeze';
 /**
  * Internal dependencies
  */
-import { locks } from '../reducer';
+import locks from '../reducer';
 
 const buildNode = ( children = {} ) => ( {
 	locks: [],