fix: register correctly composed providers and export values

Author: francescovallone

packages/serinus/CHANGELOG.md

@@ -1,9 +1,24 @@
 # Changelog
 
+## 2.1.9
+
+**Released on:** 04-05-2026
+
+### Fixes
+
+- Fix a bug that caused the composed providers to not be correctly registered and finalized.
+
 ## 2.1.8
 
+**Released on:** 07-04-2026
+
+### Fixes
+
 - Re-add logs for Composed Modules that were falsely logged as internal modules in the previous release. This fix ensures that composed modules are correctly identified and logged as composed modules, providing better visibility and debugging capabilities for developers working with composed modules in Serinus applications. 
 - Prevent empty modules to be registered.
+
+### Features
+
 - Add `useService` and `canUseService` methods to the Application class to allow for service retrival in the main function. This allows for better integration with the Serinus CLI and other tools that may need to access services from the application context.
 
 ## 2.1.7

packages/serinus/lib/src/containers/modules/provider_registry.dart

@@ -267,23 +267,25 @@ class ProviderRegistry {
     Type dependency,
     ScopeManager scopeManager,
   ) {
+    final providerDependency = _providerDependencyType(dependency);
+    final valueDependencyToken = _valueDependencyToken(dependency);
     final localProviders = getProvidersForScope(scope);
     final localValues = getValuesForScope(scope);
 
-    if (localProviders.containsKey(dependency)) {
+    if (providerDependency != null &&
+        localProviders.containsKey(providerDependency)) {
       return (
-        provider: localProviders[dependency],
+        provider: localProviders[providerDependency],
         valueToken: null,
         value: null,
       );
     }
 
-    final localValueToken = ValueToken(dependency, null);
-    if (localValues.containsKey(localValueToken)) {
+    if (localValues.containsKey(valueDependencyToken)) {
       return (
         provider: null,
-        valueToken: localValueToken,
-        value: localValues[localValueToken],
+        valueToken: valueDependencyToken,
+        value: localValues[valueDependencyToken],
       );
     }
 
@@ -300,27 +302,21 @@ class ProviderRegistry {
       final importedProviders = getProvidersForScope(importedScope);
       final importedValues = getValuesForScope(importedScope);
 
-      if (importedScope.exports.contains(dependency) &&
-          importedProviders.containsKey(dependency)) {
+      if (providerDependency != null &&
+          _exportsDependency(importedScope.exports, dependency) &&
+          importedProviders.containsKey(providerDependency)) {
         importProviderMatches.add((
           scope: importedScope,
-          provider: importedProviders[dependency]!,
+          provider: importedProviders[providerDependency]!,
         ));
       }
 
-      final valueToken = ValueToken(dependency, null);
-      final exportsValue = importedScope.exports.any((exportType) {
-        if (exportType is Export) {
-          return exportType.toValueToken() == valueToken;
-        }
-        return exportType == dependency;
-      });
-
-      if (exportsValue && importedValues.containsKey(valueToken)) {
+      if (_exportsValue(importedScope.exports, valueDependencyToken) &&
+          importedValues.containsKey(valueDependencyToken)) {
         importValueMatches.add((
           scope: importedScope,
-          token: valueToken,
-          value: importedValues[valueToken],
+          token: valueDependencyToken,
+          value: importedValues[valueDependencyToken],
         ));
       }
     }
@@ -356,34 +352,75 @@ class ProviderRegistry {
       );
     }
 
-    final globalProviderMatches = _globalProviders
-        .where((provider) => provider.runtimeType == dependency)
-        .toList();
-    if (globalProviderMatches.length > 1) {
-      throw InitializationError(
-        'Ambiguous global dependency resolution for $dependency.',
-      );
-    }
-    if (globalProviderMatches.isNotEmpty) {
-      return (
-        provider: globalProviderMatches.first,
-        valueToken: null,
-        value: null,
-      );
+    if (providerDependency != null) {
+      final globalProviderMatches = _globalProviders
+          .where((provider) => provider.runtimeType == providerDependency)
+          .toList();
+      if (globalProviderMatches.length > 1) {
+        throw InitializationError(
+          'Ambiguous global dependency resolution for $dependency.',
+        );
+      }
+      if (globalProviderMatches.isNotEmpty) {
+        return (
+          provider: globalProviderMatches.first,
+          valueToken: null,
+          value: null,
+        );
+      }
     }
 
-    final globalValueToken = ValueToken(dependency, null);
-    if (_globalValueProviders.containsKey(globalValueToken)) {
+    if (_globalValueProviders.containsKey(valueDependencyToken)) {
       return (
         provider: null,
-        valueToken: globalValueToken,
-        value: _globalValueProviders[globalValueToken],
+        valueToken: valueDependencyToken,
+        value: _globalValueProviders[valueDependencyToken],
       );
     }
 
     return null;
   }
 
+  Type? _providerDependencyType(Type dependency) {
+    if (dependency case Export(:final exportedType, :final name)) {
+      if (name != null) {
+        return null;
+      }
+      return exportedType;
+    }
+    return dependency;
+  }
+
+  ValueToken _valueDependencyToken(Type dependency) {
+    if (dependency case Export()) {
+      return dependency.toValueToken();
+    }
+    return ValueToken(dependency, null);
+  }
+
+  bool _exportsDependency(Set<Type> exports, Type dependency) {
+    final providerDependency = _providerDependencyType(dependency);
+    if (providerDependency == null) {
+      return false;
+    }
+    return exports.any((exportType) {
+      if (exportType is Export) {
+        return exportType.name == null &&
+            exportType.exportedType == providerDependency;
+      }
+      return exportType == providerDependency;
+    });
+  }
+
+  bool _exportsValue(Set<Type> exports, ValueToken valueToken) {
+    return exports.any((exportType) {
+      if (exportType is Export) {
+        return exportType.toValueToken() == valueToken;
+      }
+      return exportType == valueToken.type && valueToken.name == null;
+    });
+  }
+
   /// Returns dependency types that cannot be resolved for a scope.
   List<Type> getMissingDependenciesForScope(
     ModuleScope scope,

packages/serinus/pubspec.yaml

@@ -4,7 +4,7 @@ description: Serinus is a framework written in Dart
 documentation: https://serinus.app
 homepage: https://serinus.app
 repository: https://github.com/francescovallone/serinus
-version: 2.1.8
+version: 2.1.9
 funding:
   - https://github.com/sponsors/francescovallone
 topics:

packages/serinus/test/containers/value_provider_test.dart

@@ -38,6 +38,18 @@ class TestProviderWithValue extends Provider {
   String getValue() => value;
 }
 
+class ImportedRepository {
+  final String source;
+
+  ImportedRepository(this.source);
+}
+
+class TestProviderWithImportedRepository extends Provider {
+  final ImportedRepository repository;
+
+  TestProviderWithImportedRepository(this.repository);
+}
+
 class SimpleModuleWithValueProvider extends Module {
   SimpleModuleWithValueProvider()
     : super(
@@ -104,6 +116,102 @@ class ModuleWithComposedProviderUsingValue extends Module {
       );
 }
 
+class ModuleWithExportedRepositoryValue extends Module {
+  ModuleWithExportedRepositoryValue()
+    : super(
+        controllers: [],
+        providers: [
+          Provider.forValue(
+            ImportedRepository('imported'),
+            asType: ImportedRepository,
+          ),
+        ],
+        exports: [ImportedRepository],
+      );
+}
+
+class ModuleWithImportedRepositoryDependency extends Module {
+  ModuleWithImportedRepositoryDependency()
+    : super(
+        imports: [ModuleWithExportedRepositoryValue()],
+        controllers: [],
+        providers: [
+          Provider.composed<TestProviderWithImportedRepository>((
+            CompositionContext ctx,
+          ) async {
+            return TestProviderWithImportedRepository(
+              ctx.use<ImportedRepository>(),
+            );
+          }, inject: [ImportedRepository]),
+        ],
+        exports: [],
+      );
+}
+
+class ModuleWithImportedExportDependency extends Module {
+  ModuleWithImportedExportDependency()
+    : super(
+        imports: [ModuleWithExportedRepositoryValue()],
+        controllers: [],
+        providers: [
+          Provider.composed<TestProviderWithImportedRepository>((
+            CompositionContext ctx,
+          ) async {
+            return TestProviderWithImportedRepository(
+              ctx.use<ImportedRepository>(),
+            );
+          }, inject: [const Export(ImportedRepository)]),
+        ],
+        exports: [],
+      );
+}
+
+class ModuleWithNamedRepositoryValue extends Module {
+  ModuleWithNamedRepositoryValue()
+    : super(
+        controllers: [],
+        providers: [
+          Provider.forValue(
+            ImportedRepository('secondary'),
+            asType: ImportedRepository,
+            name: 'secondary',
+          ),
+        ],
+        exports: [const Export(ImportedRepository, name: 'secondary')],
+      );
+}
+
+class SecondaryRepositoryBranch extends Module {
+  SecondaryRepositoryBranch()
+    : super(
+        imports: [ModuleWithNamedRepositoryValue()],
+        controllers: [],
+        providers: [],
+        exports: [],
+      );
+}
+
+class ModuleWithDefaultAndSecondaryRepositoryImports extends Module {
+  ModuleWithDefaultAndSecondaryRepositoryImports()
+    : super(
+        imports: [
+          ModuleWithExportedRepositoryValue(),
+          SecondaryRepositoryBranch(),
+        ],
+        controllers: [],
+        providers: [
+          Provider.composed<TestProviderWithImportedRepository>((
+            CompositionContext ctx,
+          ) async {
+            return TestProviderWithImportedRepository(
+              ctx.use<ImportedRepository>(),
+            );
+          }, inject: [ImportedRepository]),
+        ],
+        exports: [],
+      );
+}
+
 void main() {
   group('ValueProvider', () {
     late ApplicationConfig config;
@@ -216,6 +324,63 @@ void main() {
       expect(provider.getValue(), 'Base Value');
     });
 
+    test(
+      'ComposedProvider can use imported exported ValueProvider by raw type',
+      () async {
+        final container = ModulesContainer(config);
+        final module = ModuleWithImportedRepositoryDependency();
+        await container.registerModules(module);
+        await container.finalize(module);
+
+        final scope = container.getScope(InjectionToken.fromModule(module));
+        final provider =
+            scope.unifiedProviders.firstWhere(
+                  (p) => p is TestProviderWithImportedRepository,
+                )
+                as TestProviderWithImportedRepository;
+
+        expect(provider.repository.source, 'imported');
+      },
+    );
+
+    test(
+      'ComposedProvider can use imported exported ValueProvider by Export token',
+      () async {
+        final container = ModulesContainer(config);
+        final module = ModuleWithImportedExportDependency();
+        await container.registerModules(module);
+        await container.finalize(module);
+
+        final scope = container.getScope(InjectionToken.fromModule(module));
+        final provider =
+            scope.unifiedProviders.firstWhere(
+                  (p) => p is TestProviderWithImportedRepository,
+                )
+                as TestProviderWithImportedRepository;
+
+        expect(provider.repository.source, 'imported');
+      },
+    );
+
+    test(
+      'ComposedProvider uses the default exported value when a named sibling exists',
+      () async {
+        final container = ModulesContainer(config);
+        final module = ModuleWithDefaultAndSecondaryRepositoryImports();
+        await container.registerModules(module);
+        await container.finalize(module);
+
+        final scope = container.getScope(InjectionToken.fromModule(module));
+        final provider =
+            scope.unifiedProviders.firstWhere(
+                  (p) => p is TestProviderWithImportedRepository,
+                )
+                as TestProviderWithImportedRepository;
+
+        expect(provider.repository.source, 'imported');
+      },
+    );
+
     test('context.canUse<T>() returns true for ValueProvider types', () async {
       final container = ModulesContainer(config);
       final module = SimpleModuleWithValueProvider();