Missing descendants query and filtering in v10 — migration blocker from v4

[tsotnebukiya]

Question

We're migrating from UHeadless v4 to v10 (Umbraco 17) and hit a blocker.

Our frontend heavily relies on contentDescendantsByAbsoluteRoute with where clause filtering (contentType, level, IDs,
parent). This query doesn't exist in v10, and HotChocolate.Data filtering was removed in v5.

The 6 available queries in v10 don't cover our use case — we need to fetch descendants under a specific route, filtered
by content type.

Is there any plan to bring back a descendants query or re-introduce filtering?

[nikcio]

Hi @tsotnebukiya,

It wouldn't be a problem to reintroduce the contentDescendantsByAbsoluteRoute query to the package again. It was removed in an effort to simplify the package to make maintenance easier. It's the same reason the HotChocolate.Data package was removed.

If we simply want the query back in its original shape it would look something like this. But I think we might want to consider if we can load the descendant data in a better way so we don't load content that isn't used.

And also what filters are needed in your application? I think instead of reintroducing HotChocolate.Data it would be better from a package standpoint to expose specific filters that are commonly used and then you as a consumer of the package can install HotChocolate.Data if you'd like the full filtering it brings by extending the built-in queries.

using HotChocolate.Authorization;
using HotChocolate.Resolvers;
using HotChocolate.Data;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Nikcio.UHeadless.ContentItems;
using Nikcio.UHeadless.Defaults.Authorization;
using Umbraco.Cms.Core.Models.PublishedContent;
using Umbraco.Cms.Core.PublishedCache;
using Umbraco.Cms.Core.Routing;
using Umbraco.Cms.Core.Services;

namespace Nikcio.UHeadless.Defaults.ContentItems;

[ExtendObjectType(typeof(HotChocolateQueryObject))]
public class ContentDescendantsByRouteQuery : ContentDescendantsByRouteQuery<ContentItem>
{
    protected override async Task<IEnumerable<ContentItem?>> CreateContentItemDescendantsFromRouteAsync(IResolverContext resolverContext, string route, string baseUrl, string? culture)
    {
        IPublishedRequest contentRequest = await GetContentRequestAsync(resolverContext, route, baseUrl).ConfigureAwait(false);

        IContentItemRepository<ContentItem> contentItemRepository = resolverContext.Service<IContentItemRepository<ContentItem>>();

        IEnumerable<ContentItem?> contentItems;
        switch (contentRequest.GetRouteResult())
        {
            case UmbracoRouteResult.Success:
                if(contentRequest.PublishedContent == null) {
                    contentItems = [];
                    break;
                }
                contentItems = contentRequest.PublishedContent.Descendants(culture).Select(child => contentItemRepository.GetContentItem(new ContentItem.CreateCommand()
                {
                    PublishedContent = child,
                    ResolverContext = resolverContext,
                    Redirect = null,
                    StatusCode = StatusCodes.Status200OK,
                });
                break;

            case UmbracoRouteResult.Redirect:
                contentItems = [];
                break;

            case UmbracoRouteResult.NotFound:
                contentItems = [];
                break;

            default:
                throw new InvalidOperationException("The route result is not valid");
        }

        return contentItems;
    }

    protected override IEnumerable<ContentItem?> CreateContentItemDescendants(IPublishedContent? publishedContent, IContentItemRepository<ContentItem> contentItemRepository, IResolverContext resolverContext, string? culture)
    {
        ArgumentNullException.ThrowIfNull(contentItemRepository);

        return publishedContent.Descendants(culture).Select(child => contentItemRepository.GetContentItem(new ContentItem.CreateCommand()
        {
            PublishedContent = child,
            ResolverContext = resolverContext,
            Redirect = null,
            StatusCode = StatusCodes.Status200OK,
        }));
    }
}

/// <summary>
/// Implements the <see cref="ContentDescendantsByRouteAsync" /> query
/// </summary>
public abstract class ContentDescendantsByRouteQuery<TContentItem> : IGraphQLQuery
    where TContentItem : ContentItemBase
{
    public const string PolicyName = "ContentDescendantsByRouteQuery";

    public const string ClaimValue = "content.descendants.by.route.query";

    [GraphQLIgnore]
    public virtual void ApplyConfiguration(UHeadlessOptions options)
    {
        ArgumentNullException.ThrowIfNull(options);

        options.UmbracoBuilder.Services.AddAuthorizationBuilder().AddPolicy(PolicyName, policy =>
        {
            if (options.DisableAuthorization)
            {
                policy.AddRequirements(new AlwaysAllowAuthoriaztionRequirement());
                return;
            }

            policy.AddAuthenticationSchemes(DefaultAuthenticationSchemes.UHeadless);

            policy.RequireAuthenticatedUser();

            policy.RequireClaim(DefaultClaims.UHeadlessScope, ClaimValue, DefaultClaimValues.GlobalContentRead);
        });

        AvailableClaimValue availableClaimValue = new()
        {
            Name = DefaultClaims.UHeadlessScope,
            Values = [ClaimValue, DefaultClaimValues.GlobalContentRead]
        };
        AuthorizationTokenProvider.AddAvailableClaimValue(ClaimValueGroups.Content, availableClaimValue);
    }

    /// <summary>
    /// Gets content item descendants by an absolute route
    /// </summary>
    [Authorize(Policy = PolicyName)]
    [GraphQLName("contentDescendantsByRoute")]
    [GraphQLDescription("Gets content item descendants by a route.")]
    [UsePaging]
    [UseFiltering]
    [UseSorting]
    public virtual async Task<IEnumerable<TContentItem?>> ContentDescendantsByRouteAsync(
        IResolverContext resolverContext,
        [GraphQLDescription("The route to fetch. Example '/da/frontpage/'.")] string route,
        [GraphQLDescription("The context of the request.")] QueryContext? inContext = null)
    {
        ArgumentNullException.ThrowIfNull(resolverContext);
        ArgumentException.ThrowIfNullOrEmpty(route);

        inContext ??= new QueryContext();
        if (!inContext.Initialize(resolverContext))
        {
            throw new InvalidOperationException("The context could not be initialized");
        }

        if (inContext.IncludePreview != true)
        {
            IEnumerable<TContentItem?> contentItems = await CreateContentItemDescendantsFromRouteAsync(resolverContext, route, inContext.BaseUrl, inContext.Culture).ConfigureAwait(false);

             return contentItems;
        }

        IContentItemRepository<TContentItem> contentItemRepository = resolverContext.Service<IContentItemRepository<TContentItem>>();
        IDocumentUrlService documentUrlService = resolverContext.Service<IDocumentUrlService>();

        IPublishedContentCache? contentCache = contentItemRepository.GetCache();

        if (contentCache == null)
        {
            throw new InvalidOperationException("The content cache is not available");
        }

        Guid? contentKey = documentUrlService.GetDocumentKeyByRoute(route, inContext.Culture, null, inContext.IncludePreview.Value);

        if (contentKey == null)
        {
            return CreateContentItemDescendants(null, contentItemRepository, resolverContext, inContext.Culture);
        }

        IPublishedContent? publishedContent = contentCache.GetById(inContext.IncludePreview.Value, contentKey.Value);

        return CreateContentItemDescendants(publishedContent, contentItemRepository, resolverContext, inContext.Culture);
    }

    /// <summary>
    /// Creates the content item descendants from the published content.
    /// </summary>
    /// <remarks>
    /// This runs if the content item is not found from the route via the <see cref="CreateContentItemDescendantsFromRouteAsync(IResolverContext, string, string, string?)"/>.
    /// </remarks>
    protected abstract TContentItem? CreateContentItem(IPublishedContent? publishedContent, IContentItemRepository<TContentItem> contentItemRepository, IResolverContext resolverContext, string? culture);

    /// <summary>
    /// Resolves the content item descendants from the route.
    /// </summary>
    /// <remarks>
    /// This runs first and if the content item is not found, it will run the <see cref="CreateContentItemDescendants(IPublishedContent?, IContentItemRepository{TContentItem}, IResolverContext, string?)"/> to create the content item.
    /// </remarks>
    protected abstract Task<TContentItem?> CreateContentItemDescendantsFromRouteAsync(IResolverContext resolverContext, string route, string baseUrl, string? culture);

    /// <summary>
    /// Gets the <see cref="IPublishedRequest"/> from the <see cref="IPublishedRouter"/>.
    /// </summary>
    protected async Task<IPublishedRequest> GetContentRequestAsync(IResolverContext resolverContext, string route, string baseUrl)
    {
        ArgumentNullException.ThrowIfNull(resolverContext);

        IPublishedRouter publishedRouter = resolverContext.Service<IPublishedRouter>();
        IHttpContextAccessor? httpContextAccessor = resolverContext.Service<IHttpContextAccessor>();

        baseUrl = SetBaseUrl(httpContextAccessor, baseUrl);

        var uri = new Uri($"{baseUrl.TrimEnd('/')}{route}");

        IPublishedRequestBuilder builder = await publishedRouter.CreateRequestAsync(uri).ConfigureAwait(false);
        IPublishedRequest request = await publishedRouter.RouteRequestAsync(builder, new RouteRequestOptions(RouteDirection.Inbound)).ConfigureAwait(false);

        return request;
    }

    private static string SetBaseUrl(IHttpContextAccessor httpContextAccessor, string baseUrl)
    {
        if (string.IsNullOrWhiteSpace(baseUrl))
        {
            if (httpContextAccessor == null || httpContextAccessor.HttpContext == null)
            {
                throw new HttpRequestException("HttpContext could not be found");
            }

            baseUrl = $"{httpContextAccessor.HttpContext.Request.Scheme}://{httpContextAccessor.HttpContext.Request.Host.Host}";

            if (httpContextAccessor.HttpContext.Request.Host.Port is not 80 and not 443)
            {
                baseUrl += $":{httpContextAccessor.HttpContext.Request.Host.Port}";
            }
        }

        return baseUrl;
    }
}

Note the above example was modifed directly in markdown so might have compile errors

[nikcio]

@tsotnebukiya Would you be open to looking at making a PR with this addition with a more well defined API that matches the usecases you have seen?