Introduce INavigationService for in-memory navigation data

src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs

@@ -39,6 +39,7 @@
 using Umbraco.Cms.Core.Security.Authorization;
 using Umbraco.Cms.Core.Services.FileSystem;
 using Umbraco.Cms.Core.Services.ImportExport;
+using Umbraco.Cms.Core.Services.Navigation;
 using Umbraco.Cms.Core.Services.Querying.RecycleBin;
 using Umbraco.Cms.Core.Sync;
 using Umbraco.Cms.Core.Telemetry;
@@ -338,20 +339,25 @@
                 factory.GetRequiredService<ICoreScopeProvider>(),
                 factory.GetRequiredService<ILoggerFactory>(),
                 factory.GetRequiredService<IEventMessagesFactory>(),
-                factory.GetRequiredService<IExternalLoginWithKeyRepository>()
-            ));
+                factory.GetRequiredService<IExternalLoginWithKeyRepository>()));
             Services.AddUnique<ILogViewerService, LogViewerService>();
             Services.AddUnique<IExternalLoginWithKeyService>(factory => factory.GetRequiredService<ExternalLoginService>());
             Services.AddUnique<ILocalizedTextService>(factory => new LocalizedTextService(
                 factory.GetRequiredService<Lazy<LocalizedTextServiceFileSources>>(),
                 factory.GetRequiredService<ILogger<LocalizedTextService>>()));
 
             Services.AddUnique<IEntityXmlSerializer, EntityXmlSerializer>();
 
             Services.AddSingleton<ConflictingPackageData>();
             Services.AddSingleton<CompiledPackageXmlParser>();
             Services.AddUnique<IPreviewTokenGenerator, NoopPreviewTokenGenerator>();
             Services.AddUnique<IPreviewService, PreviewService>();
+            Services.AddUnique<DocumentNavigationService, DocumentNavigationService>();
+            Services.AddUnique<IDocumentNavigationQueryService>(x => x.GetRequiredService<DocumentNavigationService>());
+            Services.AddUnique<IDocumentNavigationManagementService>(x => x.GetRequiredService<DocumentNavigationService>());
+            Services.AddUnique<MediaNavigationService, MediaNavigationService>();
+            Services.AddUnique<IMediaNavigationQueryService>(x => x.GetRequiredService<MediaNavigationService>());
+            Services.AddUnique<IMediaNavigationManagementService>(x => x.GetRequiredService<MediaNavigationService>());
 
             // Register a noop IHtmlSanitizer & IMarkdownSanitizer to be replaced
             Services.AddUnique<IHtmlSanitizer, NoopHtmlSanitizer>();

src/Umbraco.Core/Models/Navigation/NavigationNode.cs

@@ -0,0 +1,30 @@
+namespace Umbraco.Cms.Core.Models.Navigation;
+
+public sealed class NavigationNode
+{
+    private List<NavigationNode> _children;
+
+    public Guid Key { get; private set; }
+
+    public NavigationNode? Parent { get; private set; }
+
+    public IEnumerable<NavigationNode> Children => _children.AsEnumerable();
+
+    public NavigationNode(Guid key)
+    {
+        Key = key;
+        _children = new List<NavigationNode>();
+    }
+
+    public void AddChild(NavigationNode child)
+    {
+        child.Parent = this;
+        _children.Add(child);
+    }
+
+    public void RemoveChild(NavigationNode child)
+    {
+        _children.Remove(child);
+        child.Parent = null;
+    }
+}

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

@@ -0,0 +1,21 @@
+using System.Collections.Concurrent;
+using Umbraco.Cms.Core.Models.Navigation;
+
+namespace Umbraco.Cms.Core.Persistence.Repositories;
+
+public interface INavigationRepository
+{
+    /// <summary>
+    ///     Retrieves a dictionary of content nodes based on the object type key.
+    /// </summary>
+    /// <param name="objectTypeKey">The unique identifier for the object type.</param>
+    /// <returns>A dictionary of navigation nodes where the key is the unique identifier of the node.</returns>
+    public ConcurrentDictionary<Guid, NavigationNode> GetContentNodesByObjectType(Guid objectTypeKey);
+
+    /// <summary>
+    ///     Retrieves a dictionary of trashed content nodes based on the object type key.
+    /// </summary>
+    /// <param name="objectTypeKey">The unique identifier for the object type.</param>
+    /// <returns>A dictionary of navigation nodes where the key is the unique identifier of the node.</returns>
+    public ConcurrentDictionary<Guid, NavigationNode> GetTrashedContentNodesByObjectType(Guid objectTypeKey);
+}

src/Umbraco.Core/Services/ContentService.cs

@@ -1,4 +1,4 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Events;
@@ -12,6 +12,7 @@
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.Scoping;
 using Umbraco.Cms.Core.Services.Changes;
+using Umbraco.Cms.Core.Services.Navigation;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Extensions;
 
@@ -33,39 +34,75 @@
     private readonly IShortStringHelper _shortStringHelper;
     private readonly ICultureImpactFactory _cultureImpactFactory;
     private readonly IUserIdKeyResolver _userIdKeyResolver;
+    private readonly IDocumentNavigationManagementService _documentNavigationManagementService;
     private IQuery<IContent>? _queryNotTrashed;
 
     #region Constructors
 
     public ContentService(
-    ICoreScopeProvider provider,
-    ILoggerFactory loggerFactory,
-    IEventMessagesFactory eventMessagesFactory,
-    IDocumentRepository documentRepository,
-    IEntityRepository entityRepository,
-    IAuditRepository auditRepository,
-    IContentTypeRepository contentTypeRepository,
-    IDocumentBlueprintRepository documentBlueprintRepository,
-    ILanguageRepository languageRepository,
-    Lazy<IPropertyValidationService> propertyValidationService,
-    IShortStringHelper shortStringHelper,
-    ICultureImpactFactory cultureImpactFactory,
-    IUserIdKeyResolver userIdKeyResolver)
-    : base(provider, loggerFactory, eventMessagesFactory)
+        ICoreScopeProvider provider,
+        ILoggerFactory loggerFactory,
+        IEventMessagesFactory eventMessagesFactory,
+        IDocumentRepository documentRepository,
+        IEntityRepository entityRepository,
+        IAuditRepository auditRepository,
+        IContentTypeRepository contentTypeRepository,
+        IDocumentBlueprintRepository documentBlueprintRepository,
+        ILanguageRepository languageRepository,
+        Lazy<IPropertyValidationService> propertyValidationService,
+        IShortStringHelper shortStringHelper,
+        ICultureImpactFactory cultureImpactFactory,
+        IUserIdKeyResolver userIdKeyResolver,
+        IDocumentNavigationManagementService documentNavigationManagementService)
+        : base(provider, loggerFactory, eventMessagesFactory)
     {
         _documentRepository = documentRepository;
         _entityRepository = entityRepository;
         _auditRepository = auditRepository;
         _contentTypeRepository = contentTypeRepository;
         _documentBlueprintRepository = documentBlueprintRepository;
         _languageRepository = languageRepository;
         _propertyValidationService = propertyValidationService;
         _shortStringHelper = shortStringHelper;
         _cultureImpactFactory = cultureImpactFactory;
         _userIdKeyResolver = userIdKeyResolver;
+        _documentNavigationManagementService = documentNavigationManagementService;
         _logger = loggerFactory.CreateLogger<ContentService>();
     }
 
+    [Obsolete("Use non-obsolete constructor. Scheduled for removal in V16.")]
+    public ContentService(
+        ICoreScopeProvider provider,
+        ILoggerFactory loggerFactory,
+        IEventMessagesFactory eventMessagesFactory,
+        IDocumentRepository documentRepository,
+        IEntityRepository entityRepository,
+        IAuditRepository auditRepository,
+        IContentTypeRepository contentTypeRepository,
+        IDocumentBlueprintRepository documentBlueprintRepository,
+        ILanguageRepository languageRepository,
+        Lazy<IPropertyValidationService> propertyValidationService,
+        IShortStringHelper shortStringHelper,
+        ICultureImpactFactory cultureImpactFactory,
+        IUserIdKeyResolver userIdKeyResolver)
+        : this(
+            provider,
+            loggerFactory,
+            eventMessagesFactory,
+            documentRepository,
+            entityRepository,
+            auditRepository,
+            contentTypeRepository,
+            documentBlueprintRepository,
+            languageRepository,
+            propertyValidationService,
+            shortStringHelper,
+            cultureImpactFactory,
+            userIdKeyResolver,
+            StaticServiceProvider.Instance.GetRequiredService<IDocumentNavigationManagementService>())
+    {
+    }
+
     [Obsolete("Use constructor that takes IUserIdKeyResolver as a parameter, scheduled for removal in V15")]
     public ContentService(
         ICoreScopeProvider provider,
@@ -93,7 +130,8 @@
             propertyValidationService,
             shortStringHelper,
             cultureImpactFactory,
-            StaticServiceProvider.Instance.GetRequiredService<IUserIdKeyResolver>())
+            StaticServiceProvider.Instance.GetRequiredService<IUserIdKeyResolver>(),
+            StaticServiceProvider.Instance.GetRequiredService<IDocumentNavigationManagementService>())
     {
     }
 
@@ -1034,6 +1072,11 @@
             // have always changed if it's been saved in the back office but that's not really fail safe.
             _documentRepository.Save(content);
 
+            // Updates in-memory navigation structure - we only handle new items, other updates are not a concern
+            UpdateInMemoryNavigationStructure(
+                "Umbraco.Cms.Core.Services.ContentService.Save-with-contentSchedule",
+                () => _documentNavigationManagementService.Add(content.Key, GetParent(content)?.Key));
+
             if (contentSchedule != null)
             {
                 _documentRepository.PersistContentSchedule(content, contentSchedule);
@@ -1097,6 +1140,11 @@
                 content.WriterId = userId;
 
                 _documentRepository.Save(content);
+
+                // Updates in-memory navigation structure - we only handle new items, other updates are not a concern
+                UpdateInMemoryNavigationStructure(
+                    "Umbraco.Cms.Core.Services.ContentService.Save",
+                    () => _documentNavigationManagementService.Add(content.Key, GetParent(content)?.Key));
             }
 
             scope.Notifications.Publish(
@@ -2288,6 +2336,26 @@
         }
 
         DoDelete(content);
+
+        if (content.Trashed)
+        {
+            // Updates in-memory navigation structure for recycle bin items
+            UpdateInMemoryNavigationStructure(
+                "Umbraco.Cms.Core.Services.ContentService.DeleteLocked-trashed",
+                () => _documentNavigationManagementService.RemoveFromBin(content.Key));
+        }
+        else
+        {
+            // Updates in-memory navigation structure for both documents and recycle bin items
+            // as the item needs to be deleted whether it is in the recycle bin or not
+            UpdateInMemoryNavigationStructure(
+                "Umbraco.Cms.Core.Services.ContentService.DeleteLocked",
+                () =>
+                {
+                    _documentNavigationManagementService.MoveToBin(content.Key);
+                    _documentNavigationManagementService.RemoveFromBin(content.Key);
+                });
+        }
     }
 
     // TODO: both DeleteVersions methods below have an issue. Sort of. They do NOT take care of files the way
@@ -2512,54 +2580,83 @@
     // trash indicates whether we are trashing, un-trashing, or not changing anything
     private void PerformMoveLocked(IContent content, int parentId, IContent? parent, int userId, ICollection<(IContent, string)> moves, bool? trash)
     {
+        // Needed to update the in-memory navigation structure
+        var cameFromRecycleBin = content.ParentId == Constants.System.RecycleBinContent;
         content.WriterId = userId;
         content.ParentId = parentId;
 
         // get the level delta (old pos to new pos)
         // note that recycle bin (id:-20) level is 0!
         var levelDelta = 1 - content.Level + (parent?.Level ?? 0);
 
         var paths = new Dictionary<int, string>();
 
         moves.Add((content, content.Path)); // capture original path
 
         // need to store the original path to lookup descendants based on it below
         var originalPath = content.Path;
 
         // these will be updated by the repo because we changed parentId
         // content.Path = (parent == null ? "-1" : parent.Path) + "," + content.Id;
         // content.SortOrder = ((ContentRepository) repository).NextChildSortOrder(parentId);
         // content.Level += levelDelta;
         PerformMoveContentLocked(content, userId, trash);
 
         // if uow is not immediate, content.Path will be updated only when the UOW commits,
         // and because we want it now, we have to calculate it by ourselves
         // paths[content.Id] = content.Path;
         paths[content.Id] =
             (parent == null
                 ? parentId == Constants.System.RecycleBinContent ? "-1,-20" : Constants.System.RootString
                 : parent.Path) + "," + content.Id;
 
         const int pageSize = 500;
         IQuery<IContent>? query = GetPagedDescendantQuery(originalPath);
         long total;
         do
         {
             // We always page a page 0 because for each page, we are moving the result so the resulting total will be reduced
             IEnumerable<IContent> descendants =
                 GetPagedLocked(query, 0, pageSize, out total, null, Ordering.By("Path"));
 
             foreach (IContent descendant in descendants)
             {
                 moves.Add((descendant, descendant.Path)); // capture original path
 
                 // update path and level since we do not update parentId
                 descendant.Path = paths[descendant.Id] = paths[descendant.ParentId] + "," + descendant.Id;
                 descendant.Level += levelDelta;
                 PerformMoveContentLocked(descendant, userId, trash);
             }
         }
         while (total > pageSize);
+
+        if (parentId == Constants.System.RecycleBinContent)
+        {
+            // Updates in-memory navigation structure for both document items and recycle bin items
+            // as we are moving to recycle bin
+            UpdateInMemoryNavigationStructure(
+                "Umbraco.Cms.Core.Services.ContentService.PerformMoveLocked-to-recycle-bin",
+                () => _documentNavigationManagementService.MoveToBin(content.Key));
+        }
+        else
+        {
+            if (cameFromRecycleBin)
+            {
+                // Updates in-memory navigation structure for both document items and recycle bin items
+                // as we are restoring from recycle bin
+                UpdateInMemoryNavigationStructure(
+                    "Umbraco.Cms.Core.Services.ContentService.PerformMoveLocked-restore",
+                    () => _documentNavigationManagementService.RestoreFromBin(content.Key, parent?.Key));
+            }
+            else
+            {
+                // Updates in-memory navigation structure
+                UpdateInMemoryNavigationStructure(
+                    "Umbraco.Cms.Core.Services.ContentService.PerformMoveLocked",
+                    () => _documentNavigationManagementService.Move(content.Key, parent?.Key));
+            }
+        }
     }
 
     private void PerformMoveContentLocked(IContent content, int userId, bool? trash)
@@ -2663,99 +2760,122 @@
     {
         EventMessages eventMessages = EventMessagesFactory.Get();
 
+        // keep track of updates (copied item key and parent key) for the in-memory navigation structure
+        var navigationUpdates = new List<Tuple<Guid, Guid?>>();
+
         IContent copy = content.DeepCloneWithResetIdentities();
         copy.ParentId = parentId;
 
         using (ICoreScope scope = ScopeProvider.CreateCoreScope())
         {
             // FIXME: Pass parent key in constructor too when proper Copy method is implemented
             if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(content, copy, parentId, eventMessages)))
             {
                 scope.Complete();
                 return null;
             }
 
             // note - relateToOriginal is not managed here,
             // it's just part of the Copied event args so the RelateOnCopyHandler knows what to do
             // meaning that the event has to trigger for every copied content including descendants
             var copies = new List<Tuple<IContent, IContent>>();
 
             scope.WriteLock(Constants.Locks.ContentTree);
 
             // a copy is not published (but not really unpublishing either)
             // update the create author and last edit author
             if (copy.Published)
             {
                 copy.Published = false;
             }
 
             copy.CreatorId = userId;
             copy.WriterId = userId;
 
             // get the current permissions, if there are any explicit ones they need to be copied
             EntityPermissionCollection currentPermissions = GetPermissions(content);
             currentPermissions.RemoveWhere(p => p.IsDefaultPermissions);
 
             // save and flush because we need the ID for the recursive Copying events
             _documentRepository.Save(copy);
 
+            // store navigation update information for copied item
+            navigationUpdates.Add(Tuple.Create(copy.Key, GetParent(copy)?.Key));
+
             // add permissions
             if (currentPermissions.Count > 0)
             {
                 var permissionSet = new ContentPermissionSet(copy, currentPermissions);
                 _documentRepository.AddOrUpdatePermissions(permissionSet);
             }
 
             // keep track of copies
             copies.Add(Tuple.Create(content, copy));
             var idmap = new Dictionary<int, int> { [content.Id] = copy.Id };
 
             // process descendants
             if (recursive)
             {
                 const int pageSize = 500;
                 var page = 0;
                 var total = long.MaxValue;
                 while (page * pageSize < total)
                 {
                     IEnumerable<IContent> descendants =
                         GetPagedDescendants(content.Id, page++, pageSize, out total);
                     foreach (IContent descendant in descendants)
                     {
                         // if parent has not been copied, skip, else gets its copy id
                         if (idmap.TryGetValue(descendant.ParentId, out parentId) == false)
                         {
                             continue;
                         }
 
                         IContent descendantCopy = descendant.DeepCloneWithResetIdentities();
                         descendantCopy.ParentId = parentId;
 
                         // FIXME: Pass parent key in constructor too when proper Copy method is implemented
                         if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(descendant, descendantCopy, parentId, eventMessages)))
                         {
                             continue;
                         }
 
                         // a copy is not published (but not really unpublishing either)
                         // update the create author and last edit author
                         if (descendantCopy.Published)
                         {
                             descendantCopy.Published = false;
                         }
 
                         descendantCopy.CreatorId = userId;
                         descendantCopy.WriterId = userId;
 
                         // save and flush (see above)
                         _documentRepository.Save(descendantCopy);
 
+                        // store navigation update information for descendants
+                        navigationUpdates.Add(Tuple.Create(descendantCopy.Key, GetParent(descendantCopy)?.Key));
+
                         copies.Add(Tuple.Create(descendant, descendantCopy));
                         idmap[descendant.Id] = descendantCopy.Id;
                     }
                 }
             }
 
+            if (navigationUpdates.Count > 0)
+            {
+                // Updates in-memory navigation structure
+                UpdateInMemoryNavigationStructure(
+                    "Umbraco.Cms.Core.Services.ContentService.Copy",
+                    () =>
+                    {
+                        foreach (Tuple<Guid, Guid?> update in navigationUpdates)
+                        {
+                            _documentNavigationManagementService.Add(update.Item1, update.Item2);
+                        }
+                    });
+            }
+
             // not handling tags here, because
             // - tags should be handled by the content repository
             // - a copy is unpublished and therefore has no impact on tags in DB
@@ -3697,4 +3817,29 @@
         DeleteBlueprintsOfTypes(new[] { contentTypeId }, userId);
 
     #endregion
+
+    /// <summary>
+    ///     Enlists an action in the current scope context to update the in-memory navigation structure
+    ///     when the scope completes successfully.
+    /// </summary>
+    /// <param name="enlistingActionKey">The unique key identifying the action to be enlisted.</param>
+    /// <param name="updateNavigation">The action to be performed for updating the in-memory navigation structure.</param>
+    /// <exception cref="NullReferenceException">Thrown when the scope context is null and therefore cannot be used.</exception>
+    private void UpdateInMemoryNavigationStructure(string enlistingActionKey, Action updateNavigation)
+    {
+        IScopeContext? scopeContext = ScopeProvider.Context;
+
+        if (scopeContext is null)
+        {
+            throw new NullReferenceException($"The {nameof(scopeContext)} is null and cannot be used.");
+        }
+
+        scopeContext.Enlist(enlistingActionKey, completed =>
+        {
+            if (completed)
+            {
+                updateNavigation();
+            }
+        });
+    }
 }