Performance: Optimize property retrieval and authorization checks in collection views (closes #21367)

src/Umbraco.Core/Models/Entities/TreeEntityPath.cs

@@ -14,4 +14,9 @@ public class TreeEntityPath
     ///     Gets or sets the path of the entity.
     /// </summary>
     public string Path { get; set; } = null!;
+
+    /// <summary>
+    ///     Gets or sets the unique key of the entity.
+    /// </summary>
+    public Guid Key { get; set; }
 }

src/Umbraco.Core/Persistence/Repositories/IContentRepository.cs

@@ -73,6 +73,7 @@
     ///     Gets paged content items.
     /// </summary>
     /// <remarks>Here, <paramref name="filter" /> can be null but <paramref name="ordering" /> cannot.</remarks>
+    [Obsolete("Please use the method overload with all parameters. Scheduled for removal in Umbraco 19.")]
     IEnumerable<TEntity> GetPage(
         IQuery<TEntity>? query,
         long pageIndex,
@@ -81,5 +82,32 @@
         IQuery<TEntity>? filter,
         Ordering? ordering);
 
+    /// <summary>
+    ///     Gets paged content items.
+    /// </summary>
+    /// <param name="query">The base query for content items.</param>
+    /// <param name="pageIndex">The page index (zero-based).</param>
+    /// <param name="pageSize">The number of items per page.</param>
+    /// <param name="totalRecords">Output parameter with total record count.</param>
+    /// <param name="propertyAliases">
+    ///     Optional array of property aliases to load. If null, all properties are loaded.
+    ///     If empty array, no custom properties are loaded (only system properties).
+    /// </param>
+    /// <param name="filter">Optional filter query.</param>
+    /// <param name="ordering">The ordering specification.</param>
+    /// <returns>A collection of content items for the specified page.</returns>
+    /// <remarks>Here, <paramref name="filter" /> can be null but <paramref name="ordering" /> cannot.</remarks>
+#pragma warning disable CS0618 // Type or member is obsolete
+    IEnumerable<TEntity> GetPage(
+        IQuery<TEntity>? query,
+        long pageIndex,
+        int pageSize,
+        out long totalRecords,
+        string[]? propertyAliases,
+        IQuery<TEntity>? filter,
+        Ordering? ordering)
+        => GetPage(query, pageIndex, pageSize, out totalRecords, filter, ordering);
+#pragma warning restore CS0618 // Type or member is obsolete
+
     ContentDataIntegrityReport CheckDataIntegrity(ContentDataIntegrityReportOptions options);
 }

src/Umbraco.Core/Persistence/Repositories/IDocumentRepository.cs

@@ -1,11 +1,43 @@
 using System.Collections.Immutable;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Membership;
+using Umbraco.Cms.Core.Persistence.Querying;
+using Umbraco.Cms.Core.Services;
 
 namespace Umbraco.Cms.Core.Persistence.Repositories;
 
 public interface IDocumentRepository : IContentRepository<int, IContent>, IReadRepository<Guid, IContent>
 {
+    /// <summary>
+    ///     Gets paged documents.
+    /// </summary>
+    /// <param name="query">The base query for documents.</param>
+    /// <param name="pageIndex">The page index (zero-based).</param>
+    /// <param name="pageSize">The number of items per page.</param>
+    /// <param name="totalRecords">Output parameter with total record count.</param>
+    /// <param name="propertyAliases">
+    ///     Optional array of property aliases to load. If null, all properties are loaded.
+    ///     If empty array, no custom properties are loaded (only system properties).
+    /// </param>
+    /// <param name="filter">Optional filter query.</param>
+    /// <param name="ordering">The ordering specification.</param>
+    /// <param name="loadTemplates">
+    ///     Whether to load templates. Set to false for performance optimization when templates are not needed
+    ///     (e.g., collection views). Default is true.
+    /// </param>
+    /// <returns>A collection of documents for the specified page.</returns>
+    /// <remarks>Here, <paramref name="filter" /> can be null but <paramref name="ordering" /> cannot.</remarks>
+    IEnumerable<IContent> GetPage(
+        IQuery<IContent>? query,
+        long pageIndex,
+        int pageSize,
+        out long totalRecords,
+        string[]? propertyAliases,
+        IQuery<IContent>? filter,
+        Ordering? ordering,
+        bool loadTemplates)
+        => GetPage(query, pageIndex, pageSize, out totalRecords, propertyAliases, filter, ordering);
+
     /// <summary>
     ///     Gets publish/unpublish schedule for a content node.
     /// </summary>

src/Umbraco.Core/Security/Authorization/ContentPermissionAuthorizer.cs

@@ -73,4 +73,11 @@ public async Task<bool> IsDeniedForCultures(IUser currentUser, ISet<string> cult
         // If we can't find the content item(s) then we can't determine whether you are denied access.
         return result is not (ContentAuthorizationStatus.Success or ContentAuthorizationStatus.NotFound);
     }
+
+    /// <inheritdoc/>
+    public async Task<ISet<Guid>> FilterAuthorizedAsync(
+        IUser currentUser,
+        IEnumerable<Guid> contentKeys,
+        ISet<string> permissionsToCheck) =>
+        await _contentPermissionService.FilterAuthorizedAccessAsync(currentUser, contentKeys, permissionsToCheck);
 }

src/Umbraco.Core/Security/Authorization/IContentPermissionAuthorizer.cs

@@ -81,4 +81,30 @@ Task<bool> IsDeniedAtRecycleBinLevelAsync(IUser currentUser, string permissionTo
     Task<bool> IsDeniedAtRecycleBinLevelAsync(IUser currentUser, ISet<string> permissionsToCheck);
 
     Task<bool> IsDeniedForCultures(IUser currentUser, ISet<string> culturesToCheck);
+
+    /// <summary>
+    ///     Filters the specified content keys to only those the user has access to.
+    /// </summary>
+    /// <param name="currentUser">The current user.</param>
+    /// <param name="contentKeys">The keys of the content items to filter.</param>
+    /// <param name="permissionsToCheck">The collection of permissions to authorize.</param>
+    /// <returns>Returns the keys of content items the user has access to.</returns>
+    /// <remarks>
+    ///     The default implementation falls back to calling <see cref="IsDeniedAsync(IUser, IEnumerable{Guid}, ISet{string})"/>
+    ///     for each key individually. Override this method for better performance with batch authorization.
+    /// </remarks>
+    // TODO (V18): Remove default implementation.
+    async Task<ISet<Guid>> FilterAuthorizedAsync(IUser currentUser, IEnumerable<Guid> contentKeys, ISet<string> permissionsToCheck)
+    {
+        var authorizedKeys = new HashSet<Guid>();
+        foreach (Guid key in contentKeys)
+        {
+            if (await IsDeniedAsync(currentUser, [key], permissionsToCheck) == false)
+            {
+                authorizedKeys.Add(key);
+            }
+        }
+
+        return authorizedKeys;
+    }
 }

src/Umbraco.Core/Security/Authorization/IMediaPermissionAuthorizer.cs

@@ -38,4 +38,23 @@ Task<bool> IsDeniedAsync(IUser currentUser, Guid mediaKey)
     /// <param name="currentUser">The current user.</param>
     /// <returns>Returns <c>true</c> if authorization is successful, otherwise <c>false</c>.</returns>
     Task<bool> IsDeniedAtRecycleBinLevelAsync(IUser currentUser);
+
+    /// <summary>
+    ///     Filters the specified media keys to only those the user has access to.
+    /// </summary>
+    /// <param name="currentUser">The current user.</param>
+    /// <param name="mediaKeys">The keys of the media items to filter.</param>
+    /// <returns>Returns the keys of media items the user has access to.</returns>
+    /// <remarks>
+    ///     The default implementation falls back to calling <see cref="IsDeniedAsync(IUser, IEnumerable{Guid})"/>
+    ///     for each key individually. Override this method for better performance with batch authorization.
+    /// </remarks>
+    // TODO (V18): Remove default implementation and make this method required.
+    async Task<ISet<Guid>> FilterAuthorizedAsync(IUser currentUser, IEnumerable<Guid> mediaKeys)
+    {
+        var results = await Task.WhenAll(mediaKeys.Select(async key =>
+            (key, isAuthorized: await IsDeniedAsync(currentUser, [key]) == false)));
+
+        return results.Where(r => r.isAuthorized).Select(r => r.key).ToHashSet();
+    }
 }

src/Umbraco.Core/Security/Authorization/MediaPermissionAuthorizer.cs

@@ -44,4 +44,8 @@ public async Task<bool> IsDeniedAtRecycleBinLevelAsync(IUser currentUser)
         // If we can't find the media item(s) then we can't determine whether you are denied access.
         return result is not (MediaAuthorizationStatus.Success or MediaAuthorizationStatus.NotFound);
     }
+
+    /// <inheritdoc/>
+    public async Task<ISet<Guid>> FilterAuthorizedAsync(IUser currentUser, IEnumerable<Guid> mediaKeys) =>
+        await _mediaPermissionService.FilterAuthorizedAccessAsync(currentUser, mediaKeys);
 }

src/Umbraco.Core/Services/ContentEditingService.cs

@@ -345,7 +345,7 @@ protected override IContent New(string? name, int parentId, IContentType content
     protected override OperationResult? Delete(IContent content, int userId) => ContentService.Delete(content, userId);
 
     protected override IEnumerable<IContent> GetPagedChildren(int parentId, int pageIndex, int pageSize, out long total)
-        => ContentService.GetPagedChildren(parentId, pageIndex, pageSize, out total);
+        => ContentService.GetPagedChildren(parentId, pageIndex, pageSize, out total, propertyAliases: null, filter: null, ordering: null);
 
     protected override ContentEditingOperationStatus Sort(IEnumerable<IContent> items, int userId)
     {

src/Umbraco.Core/Services/ContentPermissionService.cs

@@ -1,8 +1,8 @@
-using System.Globalization;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
 using Umbraco.Cms.Core.Models.Membership;
+using Umbraco.Cms.Core.Security;
 using Umbraco.Cms.Core.Services.AuthorizationStatus;
 using Umbraco.Extensions;
 
@@ -37,19 +37,32 @@
         IEnumerable<Guid> contentKeys,
         ISet<string> permissionsToCheck)
     {
-        var contentItems = _contentService.GetByIds(contentKeys).ToArray();
+        Guid[] keysArray = contentKeys.ToArray();
 
-        if (contentItems.Length == 0)
+        if (keysArray.Length == 0)
+        {
+            return Task.FromResult(ContentAuthorizationStatus.Success);
+        }
+
+        // Use GetAllPaths instead of loading full content items - we only need paths for authorization
+        TreeEntityPath[] entityPaths = _entityService.GetAllPaths(UmbracoObjectTypes.Document, keysArray).ToArray();
+
+        if (entityPaths.Length == 0)
         {
             return Task.FromResult(ContentAuthorizationStatus.NotFound);
         }
 
-        if (contentItems.Any(contentItem => user.HasPathAccess(contentItem, _entityService, _appCaches) == false))
+        // Check path access using the paths directly
+        int[]? startNodeIds = user.CalculateContentStartNodeIds(_entityService, _appCaches);
+        foreach (TreeEntityPath entityPath in entityPaths)
         {
-            return Task.FromResult(ContentAuthorizationStatus.UnauthorizedMissingPathAccess);
+            if (ContentPermissions.HasPathAccess(entityPath.Path, startNodeIds, Constants.System.RecycleBinContent) == false)
+            {
+                return Task.FromResult(ContentAuthorizationStatus.UnauthorizedMissingPathAccess);
+            }
         }
 
-        return Task.FromResult(HasPermissionAccess(user, contentItems.Select(c => c.Path), permissionsToCheck)
+        return Task.FromResult(HasPermissionAccess(user, entityPaths.Select(p => p.Path), permissionsToCheck)
             ? ContentAuthorizationStatus.Success
             : ContentAuthorizationStatus.UnauthorizedMissingPermissionAccess);
     }
@@ -150,6 +163,50 @@
             : ContentAuthorizationStatus.UnauthorizedMissingCulture;
     }
 
+    /// <inheritdoc/>
+    public Task<ISet<Guid>> FilterAuthorizedAccessAsync(
+        IUser user,
+        IEnumerable<Guid> contentKeys,
+        ISet<string> permissionsToCheck)
+    {
+        Guid[] keysArray = [.. contentKeys];
+
+        if (keysArray.Length == 0)
+        {
+            return Task.FromResult<ISet<Guid>>(new HashSet<Guid>());
+        }
+
+        // Retrieve paths in a single database query for all keys.
+        TreeEntityPath[] entityPaths = [.. _entityService.GetAllPaths(UmbracoObjectTypes.Document, keysArray)];
+
+        if (entityPaths.Length == 0)
+        {
+            return Task.FromResult<ISet<Guid>>(new HashSet<Guid>());
+        }
+
+        var authorizedKeys = new HashSet<Guid>();
+        int[]? startNodeIds = user.CalculateContentStartNodeIds(_entityService, _appCaches);
+
+        foreach (TreeEntityPath entityPath in entityPaths)
+        {
+            // Check path access
+            if (ContentPermissions.HasPathAccess(entityPath.Path, startNodeIds, Constants.System.RecycleBinContent) == false)
+            {
+                continue;
+            }
+
+            // Check permission access
+            EntityPermissionSet permissionSet = _userService.GetPermissionsForPath(user, entityPath.Path);
+            ISet<string> permissionSetPermissions = permissionSet.GetAllPermissions();
+            if (permissionsToCheck.All(p => permissionSetPermissions.Contains(p)))
+            {
+                authorizedKeys.Add(entityPath.Key);
+            }
+        }
+
+        return Task.FromResult<ISet<Guid>>(authorizedKeys);
+    }
+
     /// <summary>
     ///     Check the implicit/inherited permissions of a user for given content items.
     /// </summary>

src/Umbraco.Core/Services/ContentService.cs

@@ -1,4 +1,4 @@
 using System.Collections.Immutable;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using Microsoft.Extensions.DependencyInjection;
@@ -673,6 +673,7 @@
                 pageIndex,
                 pageSize,
                 out totalRecords,
+                null,
                 filter,
                 ordering);
         }
@@ -705,6 +706,7 @@
                 pageIndex,
                 pageSize,
                 out totalRecords,
+                null,
                 filter,
                 ordering);
         }
@@ -840,7 +842,12 @@
     }
 
     /// <inheritdoc />
+    [Obsolete("Please use the method overload with all parameters. Scheduled for removal in Umbraco 19.")]
     public IEnumerable<IContent> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren, IQuery<IContent>? filter = null, Ordering? ordering = null)
+        => GetPagedChildren(id, pageIndex, pageSize, out totalChildren, propertyAliases: null, filter: filter, ordering: ordering);
+
+    /// <inheritdoc />
+    public IEnumerable<IContent> GetPagedChildren(int id, long pageIndex, int pageSize, out long totalChildren, string[]? propertyAliases, IQuery<IContent>? filter, Ordering? ordering, bool loadTemplates = true)
     {
         if (pageIndex < 0)
         {
@@ -859,7 +866,7 @@
             scope.ReadLock(Constants.Locks.ContentTree);
 
             IQuery<IContent>? query = Query<IContent>()?.Where(x => x.ParentId == id);
-            return _documentRepository.GetPage(query, pageIndex, pageSize, out totalChildren, filter, ordering);
+            return _documentRepository.GetPage(query, pageIndex, pageSize, out totalChildren, propertyAliases, filter, ordering, loadTemplates);
         }
     }
 
@@ -918,7 +925,7 @@
             throw new ArgumentNullException(nameof(ordering));
         }
 
-        return _documentRepository.GetPage(query, pageIndex, pageSize, out totalChildren, filter, ordering);
+        return _documentRepository.GetPage(query, pageIndex, pageSize, out totalChildren, propertyAliases: null, filter, ordering);
     }
 
     /// <summary>
@@ -1009,7 +1016,7 @@
             scope.ReadLock(Constants.Locks.ContentTree);
             IQuery<IContent>? query = Query<IContent>()?
                 .Where(x => x.Path.StartsWith(Constants.System.RecycleBinContentPathPrefix));
-            return _documentRepository.GetPage(query, pageIndex, pageSize, out totalRecords, filter, ordering);
+            return _documentRepository.GetPage(query, pageIndex, pageSize, out totalRecords, propertyAliases: null, filter, ordering);
         }
     }
 

src/Umbraco.Core/Services/EntityXmlSerializer.cs

@@ -88,7 +88,7 @@ public XElement Serialize(
             while (page * pageSize < total)
             {
                 IEnumerable<IContent> children =
-                    _contentService.GetPagedChildren(content.Id, page++, pageSize, out total);
+                    _contentService.GetPagedChildren(content.Id, page++, pageSize, out total, propertyAliases: null, filter: null, ordering: null);
                 SerializeChildren(children, xml, published);
             }
         }
@@ -678,7 +678,7 @@ private void SerializeChildren(IEnumerable<IContent> children, XElement xml, boo
             while (page * pageSize < total)
             {
                 IEnumerable<IContent> grandChildren =
-                    _contentService.GetPagedChildren(child.Id, page++, pageSize, out total);
+                    _contentService.GetPagedChildren(child.Id, page++, pageSize, out total, propertyAliases: null, filter: null, ordering: null);
 
                 // recurse
                 SerializeChildren(grandChildren, childXml, published);

src/Umbraco.Core/Services/IContentPermissionService.cs

@@ -88,4 +88,15 @@ Task<ContentAuthorizationStatus> AuthorizeBinAccessAsync(IUser user, string perm
     /// <param name="culturesToCheck">The collection of cultures to authorize.</param>
     /// <returns>A task resolving into a <see cref="ContentAuthorizationStatus"/>.</returns>
     Task<ContentAuthorizationStatus> AuthorizeCultureAccessAsync(IUser user, ISet<string> culturesToCheck);
+
+    /// <summary>
+    ///     Filters content keys to only those the user has access to.
+    /// </summary>
+    /// <param name="user"><see cref="IUser" /> to authorize.</param>
+    /// <param name="contentKeys">The identifiers of the content items to filter.</param>
+    /// <param name="permissionsToCheck">The collection of permissions to authorize.</param>
+    /// <returns>A task resolving into the set of authorized content keys.</returns>
+    // TODO (V18): Remove default implementation.
+    Task<ISet<Guid>> FilterAuthorizedAccessAsync(IUser user, IEnumerable<Guid> contentKeys, ISet<string> permissionsToCheck)
+        => Task.FromResult<ISet<Guid>>(new HashSet<Guid>());
 }