function EntryPoint::index

Controller to list all the resources.

Return value

\Drupal\jsonapi\ResourceResponse The response object.

File

core/modules/jsonapi/src/Controller/EntryPoint.php, line 74

Class

EntryPoint

Controller for the API entry point.

Namespace

Code

public function index() {
    $cacheability = (new CacheableMetadata())->addCacheContexts([
        'user.roles:authenticated',
    ])
        ->addCacheTags([
        'jsonapi_resource_types',
    ]);
    // Only build URLs for exposed resources.
    $resources = array_filter($this->resourceTypeRepository
        ->all(), function ($resource) {
        return !$resource->isInternal();
    });
    $self_link = new Link(new CacheableMetadata(), Url::fromRoute('jsonapi.resource_list'), 'self');
    $urls = array_reduce($resources, function (LinkCollection $carry, ResourceType $resource_type) {
        if ($resource_type->isLocatable() || $resource_type->isMutable()) {
            $route_suffix = $resource_type->isLocatable() ? 'collection' : 'collection.post';
            $url = Url::fromRoute(sprintf('jsonapi.%s.%s', $resource_type->getTypeName(), $route_suffix))
                ->setAbsolute();
            // Using a resource type name in place of a link relation type is not
            // technically valid. However, since it matches the link key, it will
            // not actually be serialized since the rel is omitted if it matches the
            // link key; because of that no client can rely on it. Once an extension
            // relation type is implemented for links to a collection, that should
            // be used instead. Unfortunately, the `collection` link relation type
            // would not be semantically correct since it would imply that the
            // entrypoint is a *member* of the link target.
            // @todo Implement an extension relation type to signal that this is a primary collection resource.
            $link_relation_type = $resource_type->getTypeName();
            return $carry->withLink($resource_type->getTypeName(), new Link(new CacheableMetadata(), $url, $link_relation_type));
        }
        return $carry;
    }, new LinkCollection([
        'self' => $self_link,
    ]));
    $meta = [];
    if ($this->user
        ->isAuthenticated()) {
        $current_user_uuid = $this->entityTypeManager()
            ->getStorage('user')
            ->load($this->user
            ->id())
            ->uuid();
        $meta['links']['me'] = [
            'meta' => [
                'id' => $current_user_uuid,
            ],
        ];
        $cacheability->addCacheContexts([
            'user',
        ]);
        try {
            $me_url = Url::fromRoute('jsonapi.user--user.individual', [
                'entity' => $current_user_uuid,
            ])->setAbsolute()
                ->toString(TRUE);
            $meta['links']['me']['href'] = $me_url->getGeneratedUrl();
            // The cacheability of the `me` URL is the cacheability of that URL
            // itself and the currently authenticated user.
            $cacheability = $cacheability->merge($me_url);
        } catch (RouteNotFoundException) {
            // Do not add the link if the route is disabled or marked as internal.
        }
    }
    $response = new CacheableResourceResponse(new JsonApiDocumentTopLevel(new ResourceObjectData([]), new NullIncludedData(), $urls, $meta));
    return $response->addCacheableDependency($cacheability);
}