Support ResourceType which may have a null bundle defined.

Here is an example patch. The summary is to allow passing a ResourceType to the FieldResolver and then when determining include field info, loop through the FieldMap to find available bundles and field candidates.

1. +++ b/src/Context/FieldResolver.php
   @@ -102,8 +102,7 @@ class FieldResolver {
   -  public function resolveInternal($entity_type_id, $bundle, $external_field_name) {
   -    $resource_type = $this->resourceTypeRepository->get($entity_type_id, $bundle);
   +  public function resolveInternal(ResourceType $resource_type, $external_field_name) {
   
   +++ b/src/Normalizer/JsonApiDocumentTopLevelNormalizer.php
   @@ -256,8 +256,7 @@ class JsonApiDocumentTopLevelNormalizer extends NormalizerBase implements Denorm
   -        $resource_type->getEntityTypeId(),
   -        $resource_type->getBundle(),
   +        $resource_type,
   

   This is the biggest change. It adjusts the method to re-use the ResourceType gathered from the route.

2. +++ b/src/Context/FieldResolver.php
   @@ -196,10 +195,23 @@ class FieldResolver {
   -      $definitions = $this->fieldManager->getFieldDefinitions($entity_type, $bundle);
   -      if (isset($definitions[$field_name])) {
   -        $result[] = $definitions[$field_name]->getItemDefinition();
   ...
   +      if ($bundle !== NULL) {
   +        $definitions = $this->fieldManager->getFieldDefinitions($entity_type, $bundle);
   +        if (isset($definitions[$field_name])) {
   +          $result[] = $definitions[$field_name]->getItemDefinition();
   +        }
   +      }
   +      else {
   +        $definitions = $this->fieldManager->getFieldMap();
   +        if (isset($definitions[$entity_type]) && isset($definitions[$entity_type][$field_name])) {
   +          foreach ($definitions[$entity_type][$field_name]['bundles'] as $field_map_bundle) {
   +            $definitions = $this->fieldManager->getFieldDefinitions($entity_type, $field_map_bundle);
   +            $result[] = $definitions[$field_name]->getItemDefinition();
   +          }
   +        }
   ...
   +
   

   This allows a ResourceType to have a null bundle and discovered included fields!

+++ b/src/Context/FieldResolver.php
@@ -102,8 +102,7 @@ class FieldResolver {
+  public function resolveInternal(ResourceType $resource_type, $external_field_name) {

This breaks \Drupal\jsonapi\Normalizer\FilterNormalizer::expandItem.

EDIT: The $context would need to be updated to contain the ResourceType object.

@Wim, I will try! I did give it a quick look before and I thought I still saw some blockers. But I was busy hurrying up for Decoupled Days, Vacation, and then Drupal Europe. My schedule has simmered down, now. So I'll give it another take!

Holy cow! NULL BUNDLES ARE SUPPORT!

EDIT: This is only one order type with one order item type. It needs testing. But, before, it would not even return this much data. It always had errors.

There's a weird access quirk, but here is the controller: https://github.com/mglaman/commerce_cart_api/blob/jsonapi/src/Controller...

Here's the output for a cart with one item.

{
  "data": [
    {
      "type": "commerce_order--physical",
      "id": "89ca6fbb-1a22-4974-9e84-b8d134f5d86a",
      "attributes": {
        "drupal_internal__order_id": 1,
        "order_number": null,
        "total_price": {
          "number": "20.000000",
          "currency_code": "USD"
        }
      },
      "relationships": {
        "store_id": {
          "data": {
            "type": "commerce_store--online",
            "id": "1073edc9-9eb7-414a-9996-047e9dd3e223"
          },
          "links": {
            "self": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order\/physical\/89ca6fbb-1a22-4974-9e84-b8d134f5d86a\/relationships\/store_id"
            },
            "related": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order\/physical\/89ca6fbb-1a22-4974-9e84-b8d134f5d86a\/store_id"
            }
          }
        },
        "order_items": {
          "data": [
            {
              "type": "commerce_order_item--physical_product_variation",
              "id": "794cedd6-f345-4567-9286-9e1a07ea8a41"
            }
          ],
          "links": {
            "self": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order\/physical\/89ca6fbb-1a22-4974-9e84-b8d134f5d86a\/relationships\/order_items"
            },
            "related": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order\/physical\/89ca6fbb-1a22-4974-9e84-b8d134f5d86a\/order_items"
            }
          }
        }
      },
      "links": {
        "self": {
          "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order\/physical\/89ca6fbb-1a22-4974-9e84-b8d134f5d86a"
        }
      }
    }
  ],
  "jsonapi": {
    "version": "1.0",
    "meta": {
      "links": {
        "self": {
          "href": "http:\/\/jsonapi.org\/format\/1.0\/"
        }
      }
    }
  },
  "included": [
    {
      "type": "commerce_order_item--physical_product_variation",
      "id": "794cedd6-f345-4567-9286-9e1a07ea8a41",
      "attributes": {
        "drupal_internal__order_item_id": 1,
        "title": "The Adventure Begins Camping Mug",
        "quantity": "1.00",
        "unit_price": {
          "number": "20.000000",
          "currency_code": "USD"
        },
        "total_price": {
          "number": "20.000000",
          "currency_code": "USD"
        }
      },
      "relationships": {
        "purchased_entity": {
          "data": {
            "type": "commerce_product_variation--simple",
            "id": "8ccb12f6-5465-454c-8495-5346798f9b68"
          },
          "links": {
            "self": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order_item\/physical_product_variation\/794cedd6-f345-4567-9286-9e1a07ea8a41\/relationships\/purchased_entity"
            },
            "related": {
              "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order_item\/physical_product_variation\/794cedd6-f345-4567-9286-9e1a07ea8a41\/purchased_entity"
            }
          }
        }
      },
      "links": {
        "self": {
          "href": "http:\/\/commerce2x.ddev.local\/jsonapi\/commerce_order_item\/physical_product_variation\/794cedd6-f345-4567-9286-9e1a07ea8a41"
        }
      }
    }
  ]
}

In talking with @gabesullice, we came up with the following code for a custom controller to return mixed bundles of an entity type (without paging.)

The controller method looks like this:

  /**
   * Get a carts collection for the current user.
   *
   * @todo anonymous needs "view own commerce_order" permission.
   *
   * @param \Symfony\Component\HttpFoundation\Request $request
   *   The request.
   *
   * @return \Drupal\jsonapi\ResourceResponse
   *   The response.
   */
  public function getCarts(Request $request) {
    $this->fixInclude($request);
    $carts = $this->commerceCartCartProvider->getCarts();

    $entity_collection = new EntityCollection($carts);
    $grouped_by_resource_type = array_reduce($carts, function ($grouped, OrderInterface $cart) {
      $resource_type = $this->resourceTypeRepository->get($cart->getEntityTypeId(), $cart->bundle());
      $grouped[$resource_type->getTypeName()][] = $cart;
      return $grouped;
    }, []);

    $includes = array_reduce($grouped_by_resource_type, function ($includes, array $cart_subset) use ($request) {
      /** @var \Drupal\commerce_order\Entity\OrderInterface $first_cart */
      $first_cart = reset($cart_subset);
      $resource_type = $this->resourceTypeRepository->get($first_cart->getEntityTypeId(), $first_cart->bundle());
      $subset = $this->includeResolver->resolve($resource_type, new EntityCollection($cart_subset), $request->query->get('include'));
      return EntityCollection::merge($includes, $subset);
    }, new EntityCollection([]));

    $response = new ResourceResponse(new JsonApiDocumentTopLevel($entity_collection, $includes, [], []), 200, []);
    return $response;
  }

It dies at \Drupal\jsonapi\EventSubscriber\ResourceResponseSubscriber::generateContext, because there is no resource type on the request. Which we can't provide since the bundle needs to be null. But as previously shown, that works fine.

  protected static function generateContext(Request $request) {
    $resource_type = $request->get('resource_type');

I had latest HEAD on 2.x. See #3001564: Follow-up to #2997600: Clean up dead code paths :)

I really want to make sure that Commerce can do what it needs to do on top of JSON API, since we want to get JSON API into core. It'd be sad if you could benefit from JSON API's much better DX (compared to core REST's) for everything except the Commerce Cart.

I have other concerns, which I talked about in the jsonapi channel. I'll have to dig those up, and it's a different thread than this.

After the blocked issue from #12 I could remove that snippet: https://github.com/mglaman/commerce_cart_api/commit/b4a0a11d926ef803e162...

The response comes through fine!

Support ResourceType's having hardcoded `fields`

Yeah, this was me using bad terms. This proper way would be to use isInternal or checking admin permissions.

As far as I'm concerned, this issue is now fixed. I'm able to return a collection of entities with mixed bundles without JSON API crashing, via a custom endpoint.

Concerns around limitations and spec problems for the Commerce data model and a Cart API could be carried on in an issue in that project.

So the obvious next question then is: what does this mean for https://www.drupal.org/project/commerce_cart_api?

:) Today and the next few days I will work to open a "2.x" issue for that project, outlining its goals and improvements. I still find some problems around the implementations with JSON API (less on the Drupal implementation, more with the spec.) It will summarize some discussions I had with
gabesullice and my own thoughts.

This specific issue can be closed. 2.0 allowed me to build a collection with mixed bundles: https://github.com/mglaman/commerce_cart_api/blob/jsonapi/src/Controller...

Anything related to working with JSON API I can open in follow-up issues (#25 touches on other concerns)