Backport pull request #17881 from jellyfin/release-12.z

Fix /UserViews exhausting memory and reporting random child counts

Original-merge: a838a06aa51eac388a76e9e6421f1a80873c417b

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Cody Robibero <cody@robibe.ro>

2 files changed, 100 insertions, 16 deletions

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 59e75691dc..e539508644 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using Jellyfin.Data;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Entities;
 using Jellyfin.Extensions;
@@ -192,15 +193,11 @@ namespace Emby.Server.Implementations.Dto
                 itemCountsBatch = GetItemCountsBatch(accessibleItems, user);
             }
 
-            // Batch-fetch child counts for all folders to avoid N+1 queries
+            // Batch-fetch child counts for all folders to avoid N+1 queries.
             Dictionary<Guid, int>? childCountBatch = null;
-            if (options.ContainsField(ItemFields.ChildCount))
+            if (user is not null && options.ContainsField(ItemFields.ChildCount))
             {
-                var folderIds = accessibleItems.OfType<Folder>().Select(f => f.Id).ToList();
-                if (folderIds.Count > 0)
-                {
-                    childCountBatch = _libraryManager.GetChildCountBatch(folderIds, user);
-                }
+                childCountBatch = GetChildCountBatch(accessibleItems, user);
             }
 
             // Batch-fetch played/total counts for all folders to avoid N+1 queries
@@ -714,24 +711,102 @@ namespace Emby.Server.Implementations.Dto
             };
         }
 
-        private static int GetChildCount(Folder folder, User user, Dictionary<Guid, int>? childCountBatch)
+        private Dictionary<Guid, int>? GetChildCountBatch(IReadOnlyList<BaseItem> items, User user)
         {
-            // Right now this is too slow to calculate for top level folders on a per-user basis
-            // Just return something so that apps that are expecting a value won't think the folders are empty
-            if (folder is ICollectionFolder || folder is UserView)
+            Dictionary<Guid, IReadOnlyList<Guid>>? sources = null;
+            foreach (var folder in items.OfType<Folder>())
+            {
+                var sourceIds = GetChildCountSourceIds(folder, user);
+                if (sourceIds.Count > 0)
+                {
+                    (sources ??= new Dictionary<Guid, IReadOnlyList<Guid>>())[folder.Id] = sourceIds;
+                }
+            }
+
+            if (sources is null)
+            {
+                return null;
+            }
+
+            var counts = _libraryManager.GetChildCountBatch(
+                sources.Values.SelectMany(ids => ids).Distinct().ToList(),
+                user);
+
+            var result = new Dictionary<Guid, int>(sources.Count);
+            foreach (var (folderId, sourceIds) in sources)
             {
-                return Random.Shared.Next(1, 10);
+                var total = 0;
+                foreach (var sourceId in sourceIds)
+                {
+                    total += counts.GetValueOrDefault(sourceId);
+                }
+
+                result[folderId] = total;
             }
 
+            return result;
+        }
+
+        private IReadOnlyList<Guid> GetChildCountSourceIds(Folder folder, User user)
+        {
+            if (folder is CollectionFolder collectionFolder)
+            {
+                return collectionFolder.PhysicalFolderIds;
+            }
+
+            if (folder is not UserView view)
+            {
+                return [folder.Id];
+            }
+
+            // Only a view that stands for a library proxies it. The sub-views a movie or show view
+            // is built from hang off the same library but hold a query, not the library's children.
+            if (!UserView.EnableOriginalFolder(view.ViewType)
+                && view.ViewType is not (CollectionType.movies or CollectionType.tvshows))
+            {
+                return [];
+            }
+
+            // A view over a single library proxies that library, whatever the view type.
+            var parentId = view.DisplayParentId.IsEmpty() ? view.ParentId : view.DisplayParentId;
+            if (!parentId.IsEmpty()
+                && !parentId.Equals(view.Id)
+                && _libraryManager.GetItemById(parentId) is Folder parent
+                && parent is not UserView)
+            {
+                return GetChildCountSourceIds(parent, user);
+            }
+
+            // A grouped view has no single parent: it stands for every library the user grouped
+            // into it, the same set UserViewManager builds the view from.
+            if (view.ViewType is CollectionType.movies or CollectionType.tvshows)
+            {
+                return _libraryManager.GetUserRootFolder()
+                    .GetChildren(user, true)
+                    .OfType<CollectionFolder>()
+                    .Where(f => user.IsFolderGrouped(f.Id)
+                        && (f.CollectionType == view.ViewType || f.CollectionType is null))
+                    .SelectMany(f => f.PhysicalFolderIds)
+                    .Distinct()
+                    .ToList();
+            }
+
+            return [];
+        }
+
+        private int GetChildCount(Folder folder, User user, Dictionary<Guid, int>? childCountBatch)
+        {
             // Use pre-fetched batch data if available
             if (childCountBatch is not null && childCountBatch.TryGetValue(folder.Id, out var count))
             {
                 return count;
             }
 
-            // Only reached when no batch was computed: the batch holds an entry for every folder it
-            // was asked about, zero included.
-            return folder.GetChildCount(user);
+            // No batch covered this folder.
+            var single = GetChildCountBatch([folder], user);
+            return single is not null && single.TryGetValue(folder.Id, out var singleCount)
+                ? singleCount
+                : folder.GetChildCount(user);
         }
 
         private static void SetBookProperties(BaseItemDto dto, Book item)
diff --git a/Emby.Server.Implementations/Library/UserViewManager.cs b/Emby.Server.Implementations/Library/UserViewManager.cs
index 47b3891901..231dbe6429 100644
--- a/Emby.Server.Implementations/Library/UserViewManager.cs
+++ b/Emby.Server.Implementations/Library/UserViewManager.cs
@@ -60,7 +60,16 @@ namespace Emby.Server.Implementations.Library
                 var folderViewType = collectionFolder?.CollectionType;
 
                 // Playlist and BoxSet libraries require special handling because the folder only references linked items
-                if (folderViewType == CollectionType.playlists || folderViewType == CollectionType.boxsets)
+                if (folderViewType == CollectionType.boxsets)
+                {
+                    // Only the existence of one visible box set matters here, so probe the children
+                    // lazily and stop at the first hit.
+                    if (!folder.Children.Any(item => item.IsVisible(user)))
+                    {
+                        continue;
+                    }
+                }
+                else if (folderViewType == CollectionType.playlists)
                 {
                     var items = folder.GetItemList(new InternalItemsQuery(user)
                     {