Changeset 41657

Timestamp:

10/01/2017 01:06:43 PM (9 years ago)

Author:

adamsilverstein

Message:

REST API JavaScript Client: improve support for model deletion/trash.

Update the way and location the JavaScript client determines which models/endpoints require the force=true parameter when being deleted to avoid a rest_trash_not_supported error. Identify models with endpoints that support DELETE, excluding those that support the trash (posts and pages by default). Also, move the check into the default wp.api.WPApiBaseModel.initialize() function.

Props caercam, euthelup.
Fixes #40672.

Location:

trunk

Files:

• src/wp-includes/js/wp-api.js (modified) (3 diffs)
• tests/qunit/wp-includes/js/wp-api.js (modified) (1 diff)

trunk/src/wp-includes/js/wp-api.js

@@ -771 +771 @@
                 /** @lends WPApiBaseModel.prototype  */
                 {
+                        initialize: function( attributes, options ) {
+
+                                /**
+                                 * Determine if a model requires ?force=true to actually delete them.
+                                 */
+                                if (
+                                        ! _.isEmpty(
+                                                _.filter(
+                                                        this.endpoints,
+                                                        function( endpoint ) {
+                                                                return (
+
+                                                                        // Does the method support DELETE?
+                                                                        'DELETE' === endpoint.methods[0] &&
+
+                                                                        // Exclude models that support trash (Post, Page).
+                                                                        (
+                                                                                ! _.isUndefined( endpoint.args.force ) &&
+                                                                                ! _.isUndefined( endpoint.args.force.description ) &&
+                                                                                'Whether to bypass trash and force deletion.' !== endpoint.args.force.description
+                                                                        )
+                                                                );
+                                                        }
+                                                )
+                                        )
+                                ) {
+                                        this.requireForceForDelete = true;
+                                }
+                        },
+
                         /**
                          * Set nonce header before every Backbone sync.
@@ -1267 +1297 @@
                                                 methods: modelRoute.route.methods,
 
-                                                initialize: function( attributes, options ) {
-                                                        wp.api.WPApiBaseModel.prototype.initialize.call( this, attributes, options );
-
-                                                        /**
-                                                         * Posts and pages support trashing, other types don't support a trash
-                                                         * and require that you pass ?force=true to actually delete them.
-                                                         *
-                                                         * @todo we should be getting trashability from the Schema, not hard coding types here.
-                                                         */
-                                                        if (
-                                                                'Posts' !== this.name &&
-                                                                'Pages' !== this.name &&
-                                                                _.includes( this.methods, 'DELETE' )
-                                                        ) {
-                                                                this.requireForceForDelete = true;
-                                                        }
-                                                }
+                                                // Include the array of route endpoints for easy reference.
+                                                endpoints: modelRoute.route.endpoints
                                         } );
                                 } else {
@@ -1318 +1333 @@
 
                                                 // Include the array of route methods for easy reference.
-                                                methods: modelRoute.route.methods
+                                                methods: modelRoute.route.methods,
+
+                                                // Include the array of route endpoints for easy reference.
+                                                endpoints: modelRoute.route.endpoints
                                         } );
                                 }

trunk/tests/qunit/wp-includes/js/wp-api.js

@@ -344 +344 @@
         });
 
+        // Test that models have the correct requireForceForDelete setting.
+        var modelsThatNeedrequireForceForDelete = [
+                { name: 'Category', expect: true },
+                { name: 'Comment', expect: undefined },
+                { name: 'Media', expect: undefined },
+                { name: 'Page', expect: undefined },
+                { name: 'PageRevision', expect: true },
+                { name: 'Post', expect: undefined },
+                { name: 'PostRevision', expect: true },
+                { name: 'Status', expect: undefined },
+                { name: 'Tag', expect: true },
+                { name: 'Taxonomy', expect: undefined },
+                { name: 'Type', expect: undefined },
+                { name: 'User', expect: true }
+        ];
+
+        _.each( modelsThatNeedrequireForceForDelete, function( model ) {
+                QUnit.test( 'Test requireForceForDelete is correct for ' + model.name, function( assert ) {
+                        var done = assert.async();
+                        assert.expect( 1 );
+                        wp.api.loadPromise.done( function() {
+
+                                // Instantiate the model.
+                                var theModel = new wp.api.models[ model.name ]();
+
+                                // Verify the model's requireForceForDelete is set as expected.
+                                assert.equal(
+                                        theModel.requireForceForDelete,
+                                        model.expect,
+                                        'wp.api.models.' + model.name + '.requireForceForDelete should be ' + model.expect + '.'
+                                );
+
+                                // Trigger Qunit async completion.
+                                done();
+                        } );
+                } );
+        } );
+
 } )( window.QUnit );