Issue #3037039 by gabesullice, rajanvalecha12, e0ipso, Wim Leers,...

Issue #3037039 by gabesullice, rajanvalecha12, e0ipso, Wim Leers, effulgentsia, xjm, jibran, larowlan, dww, alexpott, amateescu, webchick: Create a public API for indicating resource types should not be exposed

core/modules/jsonapi/jsonapi.services.yml

@@ -82,7 +82,7 @@ services:
       - { name: jsonapi_encoder, format: 'api_json' }
   jsonapi.resource_type.repository:
     class: Drupal\jsonapi\ResourceType\ResourceTypeRepository
-    arguments: ['@entity_type.manager', '@entity_type.bundle.info', '@entity_field.manager', '@cache.jsonapi_resource_types']
+    arguments: ['@entity_type.manager', '@entity_type.bundle.info', '@entity_field.manager', '@cache.jsonapi_resource_types', '@event_dispatcher']
   jsonapi.route_enhancer:
     class: Drupal\jsonapi\Routing\RouteEnhancer
     tags:

core/modules/jsonapi/src/ResourceType/ResourceTypeBuildEvent.php

+<?php
+
+namespace Drupal\jsonapi\ResourceType;
+
+use Drupal\Core\Entity\EntityTypeInterface;
+use Symfony\Component\EventDispatcher\Event;
+
+/**
+ * An event used to configure the construction of a JSON:API resource type.
+ *
+ * @see \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvents
+ * @see \Drupal\jsonapi\ResourceType\ResourceTypeRepository
+ */
+class ResourceTypeBuildEvent extends Event {
+
+  /**
+   * The JSON:API resource type name of the instance to be built.
+   *
+   * @var string
+   */
+  protected $resourceTypeName;
+
+  /**
+   * Whether the JSON:API resource type to be built should be disabled.
+   *
+   * @var bool
+   */
+  protected $disabled = FALSE;
+
+  /**
+   * ResourceTypeBuildEvent constructor.
+   *
+   * This constructor is protected by design. Use
+   * static::createFromEntityTypeAndBundle() instead.
+   *
+   * @param string $resource_type_name
+   *   A JSON:API resource type name.
+   */
+  protected function __construct($resource_type_name) {
+    $this->resourceTypeName = $resource_type_name;
+  }
+
+  /**
+   * Creates a new ResourceTypeBuildEvent.
+   *
+   * @param \Drupal\Core\Entity\EntityTypeInterface $entity_type
+   *   An entity type for the resource type to be built.
+   * @param string $bundle
+   *   A bundle name for the resource type to be built. If the entity type does
+   *   not have bundles, the entity type ID.
+   *
+   * @return \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent
+   *   A new event.
+   */
+  public static function createFromEntityTypeAndBundle(EntityTypeInterface $entity_type, $bundle) {
+    return new static(sprintf('%s--%s', $entity_type->id(), $bundle));
+  }
+
+  /**
+   * Gets current resource type name of the resource type to be built.
+   *
+   * @return string
+   *   The resource type name.
+   */
+  public function getResourceTypeName() {
+    return $this->resourceTypeName;
+  }
+
+  /**
+   * Disables the resource type to be built.
+   */
+  public function disableResourceType() {
+    $this->disabled = TRUE;
+  }
+
+  /**
+   * Whether the resource type to be built should be disabled.
+   *
+   * @return bool
+   *   TRUE if the resource type should be disabled, FALSE otherwise.
+   */
+  public function resourceTypeShouldBeDisabled() {
+    return $this->disabled;
+  }
+
+}

core/modules/jsonapi/src/ResourceType/ResourceTypeBuildEvents.php

+<?php
+
+namespace Drupal\jsonapi\ResourceType;
+
+/**
+ * Contains all events emitted during the resource type build process.
+ *
+ * @see \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent
+ * @see \Drupal\jsonapi\ResourceType\ResourceTypeRepository
+ */
+final class ResourceTypeBuildEvents {
+
+  /**
+   * Emitted during the resource type build process.
+   */
+  const BUILD = 'jsonapi.resource_type.build';
+
+}

core/modules/jsonapi/src/ResourceType/ResourceTypeRepository.php

@@ -15,6 +15,7 @@
 use Drupal\Core\Entity\FieldableEntityInterface;
 use Drupal\Core\Field\FieldDefinitionInterface;
 use Drupal\Core\TypedData\DataReferenceTargetDefinition;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
 use Symfony\Component\HttpKernel\Exception\PreconditionFailedHttpException;
 
 /**
@@ -67,6 +68,13 @@ class ResourceTypeRepository implements ResourceTypeRepositoryInterface {
    */
   protected $cache;
 
+  /**
+   * The event dispatcher.
+   *
+   * @var \Symfony\Component\EventDispatcher\EventDispatcherInterface
+   */
+  protected $eventDispatcher;
+
   /**
    * Cache tags used for caching the repository.
    *
@@ -93,12 +101,15 @@ class ResourceTypeRepository implements ResourceTypeRepositoryInterface {
    *   The entity field manager.
    * @param \Drupal\Core\Cache\CacheBackendInterface $cache
    *   The cache backend.
+   * @param \Symfony\Component\EventDispatcher\EventDispatcherInterface $dispatcher
+   *   The event dispatcher.
    */
-  public function __construct(EntityTypeManagerInterface $entity_type_manager, EntityTypeBundleInfoInterface $entity_bundle_info, EntityFieldManagerInterface $entity_field_manager, CacheBackendInterface $cache) {
+  public function __construct(EntityTypeManagerInterface $entity_type_manager, EntityTypeBundleInfoInterface $entity_bundle_info, EntityFieldManagerInterface $entity_field_manager, CacheBackendInterface $cache, EventDispatcherInterface $dispatcher) {
     $this->entityTypeManager = $entity_type_manager;
     $this->entityTypeBundleInfo = $entity_bundle_info;
     $this->entityFieldManager = $entity_field_manager;
     $this->cache = $cache;
+    $this->eventDispatcher = $dispatcher;
   }
 
   /**
@@ -139,11 +150,17 @@ public function all() {
    */
   protected function createResourceType(EntityTypeInterface $entity_type, $bundle) {
     $raw_fields = $this->getAllFieldNames($entity_type, $bundle);
+    $internalize_resource_type = $entity_type->isInternal();
+    if (!$internalize_resource_type) {
+      $event = ResourceTypeBuildEvent::createFromEntityTypeAndBundle($entity_type, $bundle);
+      $this->eventDispatcher->dispatch(ResourceTypeBuildEvents::BUILD, $event);
+      $internalize_resource_type = $event->resourceTypeShouldBeDisabled();
+    }
     return new ResourceType(
       $entity_type->id(),
       $bundle,
       $entity_type->getClass(),
-      $entity_type->isInternal(),
+      $internalize_resource_type,
       static::isLocatableResourceType($entity_type, $bundle),
       static::isMutableResourceType($entity_type, $bundle),
       static::isVersionableResourceType($entity_type),

core/modules/jsonapi/tests/modules/jsonapi_test_resource_type_building/jsonapi_test_resource_type_building.info.yml

+name: 'JSON:API test resource type building API'
+type: module
+package: Testing
+core: 8.x

core/modules/jsonapi/tests/modules/jsonapi_test_resource_type_building/jsonapi_test_resource_type_building.services.yml

+services:
+  jsonapi_test_resource_type_building.build_subscriber:
+    class: Drupal\jsonapi_test_resource_type_building\EventSubscriber\ResourceTypeBuildEventSubscriber
+    tags:
+      - { name: event_subscriber }

core/modules/jsonapi/tests/modules/jsonapi_test_resource_type_building/src/EventSubscriber/ResourceTypeBuildEventSubscriber.php

+<?php
+
+namespace Drupal\jsonapi_test_resource_type_building\EventSubscriber;
+
+use Drupal\jsonapi\ResourceType\ResourceTypeBuildEvents;
+use Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+
+/**
+ * Event subscriber which tests disabling resource types.
+ *
+ * @internal
+ */
+class ResourceTypeBuildEventSubscriber implements EventSubscriberInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function getSubscribedEvents() {
+    return [ResourceTypeBuildEvents::BUILD => 'disableResourceType'];
+  }
+
+  /**
+   * Disables any resource types that have been disabled by a test.
+   *
+   * @param \Drupal\jsonapi\ResourceType\ResourceTypeBuildEvent $event
+   *   The build event.
+   */
+  public function disableResourceType(ResourceTypeBuildEvent $event) {
+    $disabled_resource_types = \Drupal::state()->get('jsonapi_test_resource_type_builder.disabled_resource_types', []);
+    if (in_array($event->getResourceTypeName(), $disabled_resource_types, TRUE)) {
+      $event->disableResourceType();
+    }
+  }
+
+}

core/modules/jsonapi/tests/src/Kernel/ResourceType/ResourceTypeRepositoryTest.php

@@ -2,6 +2,7 @@
 
 namespace Drupal\Tests\jsonapi\Kernel\ResourceType;
 
+use Drupal\Core\Cache\Cache;
 use Drupal\jsonapi\ResourceType\ResourceType;
 use Drupal\node\Entity\NodeType;
 use Drupal\Tests\jsonapi\Kernel\JsonapiKernelTestBase;
@@ -23,6 +24,7 @@ class ResourceTypeRepositoryTest extends JsonapiKernelTestBase {
     'serialization',
     'system',
     'user',
+    'jsonapi_test_resource_type_building',
   ];
 
   /**
@@ -147,4 +149,22 @@ public function getFieldMappingProvider() {
     ];
   }
 
+  /**
+   * Tests that resource types can be disabled by a build subscriber.
+   */
+  public function testResourceTypeDisabling() {
+    $this->assertFalse($this->resourceTypeRepository->getByTypeName('node--article')->isInternal());
+    $this->assertFalse($this->resourceTypeRepository->getByTypeName('node--page')->isInternal());
+    $this->assertFalse($this->resourceTypeRepository->getByTypeName('user--user')->isInternal());
+    $disabled_resource_types = [
+      'node--page',
+      'user--user',
+    ];
+    \Drupal::state()->set('jsonapi_test_resource_type_builder.disabled_resource_types', $disabled_resource_types);
+    Cache::invalidateTags(['jsonapi_resource_types']);
+    $this->assertFalse($this->resourceTypeRepository->getByTypeName('node--article')->isInternal());
+    $this->assertTrue($this->resourceTypeRepository->getByTypeName('node--page')->isInternal());
+    $this->assertTrue($this->resourceTypeRepository->getByTypeName('user--user')->isInternal());
+  }
+
 }