Corrects the mapping of types to features in ITypeFeatureProvider

src/OrchardCore.Modules/OrchardCore.Roles/Services/RoleUpdater.cs

@@ -54,7 +54,7 @@ private async Task UpdateRolesForInstalledFeatureAsync(IFeatureInfo feature)
             _installedFeatures.Add(feature.Id);
 
             var providers = _permissionProviders
-                .Where(provider => _typeFeatureProvider.GetFeatureForDependency(provider.GetType()).Id == feature.Id);
+                .Where(provider => _typeFeatureProvider.GetFeaturesForDependency(provider.GetType()).Any(p => p.Id == feature.Id));
 
             if (!providers.Any())
             {
@@ -98,7 +98,7 @@ private async Task UpdateRolesForEnabledFeatureAsync(IFeatureInfo feature)
             }
 
             var providers = _permissionProviders
-                .Where(provider => _typeFeatureProvider.GetFeatureForDependency(provider.GetType()).Id == feature.Id);
+                .Where(provider => _typeFeatureProvider.GetFeaturesForDependency(provider.GetType()).Any(p => p.Id == feature.Id));
 
             if (!providers.Any())
             {
@@ -144,8 +144,8 @@ private async Task UpdateRoleForInstalledFeaturesAsync(string roleName)
 
             // And defining at least one 'IPermissionProvider'.
             rolesDocument.MissingFeaturesByRole[roleName] = (await _extensionManager.LoadFeaturesAsync(missingFeatures))
-                .Where(entry => entry.ExportedTypes.Any(type => type.IsAssignableTo(typeof(IPermissionProvider))))
-                .Select(entry => entry.FeatureInfo.Id)
+                .Where(entry => _typeFeatureProvider.GetTypesForFeature(entry).Any(type => type.IsAssignableTo(typeof(IPermissionProvider))))
+                .Select(entry => entry.Id)
                 .ToList();
 
             await _documentManager.UpdateAsync(rolesDocument);

src/OrchardCore/OrchardCore.Abstractions/Extensions/Features/ITypeFeatureProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using OrchardCore.Environment.Extensions.Features;
 
 namespace OrchardCore.Environment.Extensions
@@ -9,7 +10,39 @@ namespace OrchardCore.Environment.Extensions
     /// </summary>
     public interface ITypeFeatureProvider
     {
+        /// <summary>
+        /// Gets the extension for the specified dependent type.
+        /// </summary>
+        /// <param name="dependency"></param>
+        /// <returns></returns>
+        IExtensionInfo GetExtensionForDependency(Type dependency);
+
+        /// <summary>
+        /// Gets the first feature for the specified dependent type.
+        /// </summary>
+        /// <param name="dependency"></param>
+        /// <returns></returns>
         IFeatureInfo GetFeatureForDependency(Type dependency);
+
+        /// <summary>
+        /// Gets all features for the specified dependent type.
+        /// </summary>
+        /// <param name="dependency"></param>
+        /// <returns></returns>
+        IEnumerable<IFeatureInfo> GetFeaturesForDependency(Type dependency);
+
+        /// <summary>
+        /// Gets all dependent types for the specified feature.
+        /// </summary>
+        /// <param name="feature"></param>
+        /// <returns></returns>
+        IEnumerable<Type> GetTypesForFeature(IFeatureInfo feature);
+
+        /// <summary>
+        /// Adds a type to the specified feature.
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="feature"></param>
         void TryAdd(Type type, IFeatureInfo feature);
     }
 }

src/OrchardCore/OrchardCore.Abstractions/Extensions/IExtensionManager.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using OrchardCore.Environment.Extensions.Features;
@@ -8,13 +9,14 @@ public interface IExtensionManager
     {
         IExtensionInfo GetExtension(string extensionId);
         IEnumerable<IExtensionInfo> GetExtensions();
+        IEnumerable<Type> GetExportedExtensionTypes(IExtensionInfo extensionInfo);
         Task<ExtensionEntry> LoadExtensionAsync(IExtensionInfo extensionInfo);
 
         IEnumerable<IFeatureInfo> GetFeatures();
         IEnumerable<IFeatureInfo> GetFeatures(string[] featureIdsToLoad);
         IEnumerable<IFeatureInfo> GetFeatureDependencies(string featureId);
         IEnumerable<IFeatureInfo> GetDependentFeatures(string featureId);
-        Task<IEnumerable<FeatureEntry>> LoadFeaturesAsync();
-        Task<IEnumerable<FeatureEntry>> LoadFeaturesAsync(string[] featureIdsToLoad);
+        Task<IEnumerable<IFeatureInfo>> LoadFeaturesAsync();
+        Task<IEnumerable<IFeatureInfo>> LoadFeaturesAsync(string[] featureIdsToLoad);
     }
 }

src/OrchardCore/OrchardCore.Abstractions/Shell/Builders/Models/ShellBlueprint.cs

@@ -15,6 +15,6 @@ public class ShellBlueprint
         public ShellSettings Settings { get; set; }
         public ShellDescriptor Descriptor { get; set; }
 
-        public IDictionary<Type, FeatureEntry> Dependencies { get; set; }
+        public IDictionary<Type, IEnumerable<IFeatureInfo>> Dependencies { get; set; }
     }
 }

src/OrchardCore/OrchardCore.Data.YesSql/Migration/DataMigrationManager.cs

@@ -276,7 +276,7 @@ private static async Task<int> InvokeMethodAsync(MethodInfo method, IDataMigrati
         private IDataMigration[] GetDataMigrations(string featureId)
         {
             var migrations = _dataMigrations
-                    .Where(dm => _typeFeatureProvider.GetFeatureForDependency(dm.GetType()).Id == featureId)
+                    .Where(dm => _typeFeatureProvider.GetFeaturesForDependency(dm.GetType()).Any(feature => feature.Id == featureId))
                     .ToArray();
 
             return migrations;

src/OrchardCore/OrchardCore.Infrastructure/Shell/ShellDescriptorManager.cs

@@ -83,7 +83,7 @@ public async Task<ShellDescriptor> GetShellDescriptorAsync()
             var featureIds = features.Select(sf => sf.Id).ToArray();
 
             var missingDependencies = (await _extensionManager.LoadFeaturesAsync(featureIds))
-                .Select(entry => entry.FeatureInfo.Id)
+                .Select(entry => entry.Id)
                 .Except(featureIds)
                 .Select(id => new ShellFeature(id));
 

src/OrchardCore/OrchardCore.Mvc.Core/ModularApplicationModelProvider.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using Microsoft.AspNetCore.Mvc.ApplicationModels;
 using Microsoft.Extensions.Hosting;
 using OrchardCore.Environment.Extensions;
@@ -42,25 +43,23 @@ public void OnProvidersExecuted(ApplicationModelProviderContext context)
             foreach (var controller in context.Result.Controllers)
             {
                 var controllerType = controller.ControllerType.AsType();
-                var blueprint = _typeFeatureProvider.GetFeatureForDependency(controllerType);
 
-                if (blueprint != null)
-                {
-                    if (blueprint.Extension.Id == _hostingEnvironment.ApplicationName && !_shellSettings.IsRunning())
-                    {
-                        // Don't serve any action of the application'module which is enabled during a setup.
-                        foreach (var action in controller.Actions)
-                        {
-                            action.Selectors.Clear();
-                        }
+                var blueprint = _typeFeatureProvider.GetExtensionForDependency(controllerType);
 
-                        controller.Selectors.Clear();
-                    }
-                    else
+                if (blueprint.Id == _hostingEnvironment.ApplicationName && !_shellSettings.IsRunning())
+                {
+                    // Don't serve any action of the application'module which is enabled during a setup.
+                    foreach (var action in controller.Actions)
                     {
-                        // Add an "area" route value equal to the module id.
-                        controller.RouteValues.Add("area", blueprint.Extension.Id);
+                        action.Selectors.Clear();
                     }
+
+                    controller.Selectors.Clear();
+                }
+                else
+                {
+                    // Add an "area" route value equal to the module id.
+                    controller.RouteValues.Add("area", blueprint.Id);
                 }
             }
         }

src/OrchardCore/OrchardCore.Recipes.Core/Services/RecipeMigrator.cs

@@ -39,9 +39,9 @@ public RecipeMigrator(
 
         public async Task<string> ExecuteAsync(string recipeFileName, IDataMigration migration)
         {
-            var featureInfo = _typeFeatureProvider.GetFeatureForDependency(migration.GetType());
+            var extensionInfo = _typeFeatureProvider.GetExtensionForDependency(migration.GetType());
 
-            var recipeBasePath = Path.Combine(featureInfo.Extension.SubPath, "Migrations").Replace('\\', '/');
+            var recipeBasePath = Path.Combine(extensionInfo.SubPath, "Migrations").Replace('\\', '/');
             var recipeFilePath = Path.Combine(recipeBasePath, recipeFileName).Replace('\\', '/');
             var recipeFileInfo = _hostingEnvironment.ContentRootFileProvider.GetFileInfo(recipeFilePath);
             var recipeDescriptor = await _recipeReader.GetRecipeDescriptorAsync(recipeBasePath, recipeFileInfo, _hostingEnvironment.ContentRootFileProvider);

src/OrchardCore/OrchardCore/Extensions/ExtensionManager.cs

@@ -3,7 +3,7 @@
 using System.Collections.Frozen;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using OrchardCore.Environment.Extensions.Features;
@@ -24,12 +24,11 @@ public class ExtensionManager : IExtensionManager
 
         private readonly IExtensionDependencyStrategy[] _extensionDependencyStrategies;
         private readonly IExtensionPriorityStrategy[] _extensionPriorityStrategies;
-        private readonly ITypeFeatureProvider _typeFeatureProvider;
         private readonly IFeaturesProvider _featuresProvider;
 
         private FrozenDictionary<string, ExtensionEntry> _extensions;
         private List<IExtensionInfo> _extensionsInfos;
-        private Dictionary<string, FeatureEntry> _features;
+        private Dictionary<string, IFeatureInfo> _features;
         private IFeatureInfo[] _featureInfos;
 
         private readonly ConcurrentDictionary<string, Lazy<IEnumerable<IFeatureInfo>>> _featureDependencies = new();
@@ -42,14 +41,12 @@ public ExtensionManager(
             IApplicationContext applicationContext,
             IEnumerable<IExtensionDependencyStrategy> extensionDependencyStrategies,
             IEnumerable<IExtensionPriorityStrategy> extensionPriorityStrategies,
-            ITypeFeatureProvider typeFeatureProvider,
             IFeaturesProvider featuresProvider,
             ILogger<ExtensionManager> logger)
         {
             _applicationContext = applicationContext;
             _extensionDependencyStrategies = extensionDependencyStrategies as IExtensionDependencyStrategy[] ?? extensionDependencyStrategies.ToArray();
             _extensionPriorityStrategies = extensionPriorityStrategies as IExtensionPriorityStrategy[] ?? extensionPriorityStrategies.ToArray();
-            _typeFeatureProvider = typeFeatureProvider;
             _featuresProvider = featuresProvider;
             L = logger;
         }
@@ -92,6 +89,18 @@ public IEnumerable<IFeatureInfo> GetFeatures(string[] featureIdsToLoad)
             }
         }
 
+        public IEnumerable<Type> GetExportedExtensionTypes(IExtensionInfo extensionInfo)
+        {
+            EnsureInitialized();
+
+            if (_extensions.TryGetValue(extensionInfo.Id, out var extension))
+            {
+                return extension.ExportedTypes;
+            }
+
+            return [];
+        }
+
         public Task<ExtensionEntry> LoadExtensionAsync(IExtensionInfo extensionInfo)
         {
             EnsureInitialized();
@@ -101,22 +110,22 @@ public Task<ExtensionEntry> LoadExtensionAsync(IExtensionInfo extensionInfo)
             return Task.FromResult(extension);
         }
 
-        public Task<IEnumerable<FeatureEntry>> LoadFeaturesAsync()
+        public Task<IEnumerable<IFeatureInfo>> LoadFeaturesAsync()
         {
             EnsureInitialized();
-            return Task.FromResult<IEnumerable<FeatureEntry>>(_features.Values);
+            return Task.FromResult<IEnumerable<IFeatureInfo>>(_features.Values);
         }
 
-        public Task<IEnumerable<FeatureEntry>> LoadFeaturesAsync(string[] featureIdsToLoad)
+        public Task<IEnumerable<IFeatureInfo>> LoadFeaturesAsync(string[] featureIdsToLoad)
         {
             EnsureInitialized();
 
             var features = new HashSet<string>(GetFeatures(featureIdsToLoad).Select(f => f.Id));
 
             var loadedFeatures = _features.Values
-                .Where(f => features.Contains(f.FeatureInfo.Id));
+                .Where(f => features.Contains(f.Id));
 
-            return Task.FromResult<IEnumerable<FeatureEntry>>(loadedFeatures);
+            return Task.FromResult<IEnumerable<IFeatureInfo>>(loadedFeatures);
         }
 
         public IEnumerable<IFeatureInfo> GetFeatureDependencies(string featureId)
@@ -130,9 +139,7 @@ public IEnumerable<IFeatureInfo> GetFeatureDependencies(string featureId)
                     return [];
                 }
 
-                var feature = entry.FeatureInfo;
-
-                return GetFeatureDependencies(feature, _featureInfos);
+                return GetFeatureDependencies(entry, _featureInfos);
             })).Value;
         }
 
@@ -147,9 +154,7 @@ public IEnumerable<IFeatureInfo> GetDependentFeatures(string featureId)
                     return [];
                 }
 
-                var feature = entry.FeatureInfo;
-
-                return GetDependentFeatures(feature, _featureInfos);
+                return GetDependentFeatures(entry, _featureInfos);
             })).Value;
         }
 
@@ -260,13 +265,6 @@ private static List<IFeatureInfo> GetFeatureDependenciesFunc(IFeatureInfo curren
             return list;
         }
 
-        private static string GetSourceFeatureNameForType(Type type, string extensionId)
-        {
-            var attribute = type.GetCustomAttributes<FeatureAttribute>(false).FirstOrDefault();
-
-            return attribute?.FeatureName ?? extensionId;
-        }
-
         private void EnsureInitialized()
         {
             if (_isInitialized)
@@ -308,50 +306,20 @@ private void EnsureInitialized()
                     loadedExtensions.TryAdd(module.Name, entry);
                 });
 
-                var loadedFeatures = new Dictionary<string, FeatureEntry>();
-
-                // Get all valid types from any extension
-                var allTypesByExtension = loadedExtensions.SelectMany(extension =>
-                    extension.Value.ExportedTypes.Where(IsComponentType)
-                    .Select(type => new
-                    {
-                        ExtensionEntry = extension.Value,
-                        Type = type
-                    })).ToArray();
-
-                var typesByFeature = allTypesByExtension
-                    .GroupBy(typeByExtension => GetSourceFeatureNameForType(
-                        typeByExtension.Type,
-                        typeByExtension.ExtensionEntry.ExtensionInfo.Id))
-                    .ToDictionary(
-                        group => group.Key,
-                        group => group.Select(typesByExtension => typesByExtension.Type).ToArray());
+                var loadedFeatures = new Dictionary<string, IFeatureInfo>();
 
                 foreach (var loadedExtension in loadedExtensions)
                 {
                     var extension = loadedExtension.Value;
 
                     foreach (var feature in extension.ExtensionInfo.Features)
                     {
-                        // Features can have no types
-                        if (typesByFeature.TryGetValue(feature.Id, out var featureTypes))
-                        {
-                            foreach (var type in featureTypes)
-                            {
-                                _typeFeatureProvider.TryAdd(type, feature);
-                            }
-                        }
-                        else
-                        {
-                            featureTypes = [];
-                        }
-
-                        loadedFeatures.Add(feature.Id, new FeatureEntry(feature, featureTypes));
+                        loadedFeatures.Add(feature.Id, feature);
                     }
                 }
 
                 // Feature infos and entries are ordered by priority and dependencies.
-                _featureInfos = Order(loadedFeatures.Values.Select(f => f.FeatureInfo));
+                _featureInfos = Order(loadedFeatures.Values);
                 _features = _featureInfos.ToDictionary(f => f.Id, f => loadedFeatures[f.Id]);
 
                 // Extensions are also ordered according to the weight of their first features.
@@ -366,11 +334,6 @@ private void EnsureInitialized()
             }
         }
 
-        private static bool IsComponentType(Type type)
-        {
-            return type.IsClass && !type.IsAbstract && type.IsPublic;
-        }
-
         private IFeatureInfo[] Order(IEnumerable<IFeatureInfo> featuresToOrder)
         {
             return featuresToOrder