Fix: Async resolving the shared instances (avoiding duplicates) (3/3)

CHANGELOG.md

@@ -18,6 +18,7 @@ __Sections__
 - Support for multiple arguments. Code clean up.
 - Using parameter packs for multiple arguments
 - Tests are converted to the new Swift Testing framework
+- Fix of async resolve of shared dependencies
 
 ## [1.0.4]
 

Derived/InfoPlists/DependencyInjection-Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>NSHumanReadableCopyright</key>
+	<string>Copyright ©. All rights reserved.</string>
+</dict>
+</plist>

Sources/Container/Async/AsyncContainer.swift

@@ -14,6 +14,7 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
 
     private var registrations = [RegistrationIdentifier: AsyncRegistration]()
     private var sharedInstances = [RegistrationIdentifier: any Sendable]()
+    private var sharedTasks = [RegistrationIdentifier: Task<any Sendable, Error>]()
 
     /// Create new instance of ``AsyncContainer``
     public init() {}
@@ -28,6 +29,7 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
     /// Remove already instantiated shared instances from the container
     public func releaseSharedInstances() {
         sharedInstances.removeAll()
+        sharedTasks.removeAll()
     }
 
     // MARK: Register dependency
@@ -50,6 +52,7 @@ public actor AsyncContainer: AsyncDependencyResolving, AsyncDependencyRegisterin
         // With a new registration we should clean all shared instances
         // because the new registered factory most likely returns different objects and we have no way to tell
         sharedInstances[registration.identifier] = nil
+        sharedTasks[registration.identifier] = nil
     }
 
     // MARK: Register dependency with arguments
@@ -132,28 +135,54 @@ private extension AsyncContainer {
         )
     }
 
-    func getDependency<Dependency: Sendable>(from registration: AsyncRegistration, with argument: (any Sendable)? = nil) async throws -> Dependency {
+    func getDependency<Dependency: Sendable>(from registration: AsyncRegistration, with argument: (any Sendable)? = ()) async throws -> Dependency {
         switch registration.scope {
         case .shared:
             if let dependency = sharedInstances[registration.identifier] as? Dependency {
                 return dependency
             }
+
+            if let task = sharedTasks[registration.identifier] {
+                do {
+                    return try await task.value as! Dependency
+                } catch {
+                    sharedTasks[registration.identifier] = nil
+                    throw error
+                }
+            }
         case .new:
             break
         }
 
         // We use force cast here because we are sure that the type-casting always succeed
         // The reason why the `factory` closure returns ``Any`` is that we have to erase the generic type in order to store the registration
         // When the registration is created it can be initialized just with a `factory` that returns the matching type
-        let dependency = try await registration.asyncRegistrationFactory(self, argument) as! Dependency
+        let task = Task<any Sendable, Error> {
+            try await registration.asyncRegistrationFactory(self, argument)
+        }
 
-        switch registration.scope {
-        case .shared:
-            sharedInstances[registration.identifier] = dependency
-        case .new:
-            break
+        if case .shared = registration.scope {
+            sharedTasks[registration.identifier] = task
+        }
+
+        do {
+            let dependency = try await task.value as! Dependency
+
+            switch registration.scope {
+            case .shared:
+                sharedInstances[registration.identifier] = dependency
+                sharedTasks[registration.identifier] = nil
+            case .new:
+                break
+            }
+
+            return dependency
+        } catch {
+            if case .shared = registration.scope {
+                sharedTasks[registration.identifier] = nil
+            }
+            throw error
         }
 
-        return dependency
     }
 }

Sources/Container/Sync/Container.swift

@@ -128,7 +128,7 @@ private extension Container {
         )
     }
 
-    func getDependency<Dependency>(from registration: Registration, with argument: Any? = nil) throws -> Dependency {
+    func getDependency<Dependency>(from registration: Registration, with argument: Any? = ()) throws -> Dependency {
         switch registration.scope {
         case .shared:
             if let dependency = sharedInstances[registration.identifier] as? Dependency {

Tests/Container/Async/AsyncBaseTests.swift

@@ -82,4 +82,109 @@ struct AsyncBaseTests {
             }
         }
     }
+
+    @Test("Concurrent resolve of shared dependency")
+    func concurrentResolveSharedDependency() async {
+        // Given
+        let subject = AsyncContainer()
+        await subject.register(in: .shared) { _ -> SimpleDependency in
+            SimpleDependency()
+        }
+
+        // When
+        let resolvedDependencies = await withTaskGroup(of: SimpleDependency.self) { group in
+            for _ in 0..<50 {
+                group.addTask {
+                    await subject.resolve()
+                }
+            }
+
+            var dependencies: [SimpleDependency] = []
+            for await dependency in group {
+                dependencies.append(dependency)
+            }
+
+            return dependencies
+        }
+
+        // Then
+        guard let firstDependency = resolvedDependencies.first else {
+            Issue.record("Expected to resolve at least one dependency")
+            return
+        }
+
+        #expect(resolvedDependencies.allSatisfy { $0 === firstDependency })
+    }
+
+    @Test("Concurrent register and resolve different types")
+    func concurrentRegisterAndResolveDifferentTypes() async {
+        // Given
+        let subject = AsyncContainer()
+
+        // When
+        let resolvedDependencies = await withTaskGroup(of: Any.self) { group in
+            group.addTask {
+                await subject.register(in: .shared) { _ -> SimpleDependency in
+                    SimpleDependency()
+                }
+
+                let dependency: SimpleDependency = await subject.resolve()
+                return dependency
+            }
+
+            group.addTask {
+                await subject.register { _, argument -> DependencyWithValueTypeParameter in
+                    DependencyWithValueTypeParameter(subDependency: argument)
+                }
+
+                let argument = StructureDependency(property1: "concurrent")
+                let dependency: DependencyWithValueTypeParameter = await subject.resolve(arguments: argument)
+                return dependency
+            }
+
+            group.addTask {
+                await subject.register { _, argument -> DependencyWithAsyncInitWithParameter in
+                    await DependencyWithAsyncInitWithParameter(subDependency: argument)
+                }
+
+                let argument = StructureDependency(property1: "async")
+                let dependency: DependencyWithAsyncInitWithParameter = await subject.resolve(arguments: argument)
+                return dependency
+            }
+
+            var dependencies: [Any] = []
+            for await dependency in group {
+                dependencies.append(dependency)
+            }
+
+            return dependencies
+        }
+
+        // Then
+        #expect(resolvedDependencies.count == 3)
+
+        let hasSimpleDependency = resolvedDependencies.contains { $0 is SimpleDependency }
+        #expect(hasSimpleDependency)
+
+        let hasValueTypeParameter = resolvedDependencies.contains { $0 is DependencyWithValueTypeParameter }
+        #expect(hasValueTypeParameter)
+
+        let hasAsyncInitParameter = resolvedDependencies.contains { $0 is DependencyWithAsyncInitWithParameter }
+        #expect(hasAsyncInitParameter)
+    }
+
+    @Test("Register explicit type with resolver-only factory")
+    func registerExplicitTypeWithResolverOnlyFactory() async throws {
+        // Given
+        let subject = AsyncContainer()
+        await subject.register(type: SimpleDependency.self) { _ in
+            SimpleDependency()
+        }
+
+        // When
+        let resolvedDependency = try await subject.tryResolve(type: SimpleDependency.self)
+
+        // Then
+        #expect(resolvedDependency is SimpleDependency)
+    }
 }

Tests/Container/Sync/BaseTests.swift

@@ -124,4 +124,19 @@ struct BaseTests {
             }
         }
     }
+
+    @Test("Register explicit type with resolver-only factory")
+    func registerExplicitTypeWithResolverOnlyFactory() throws {
+        // Given
+        let subject = Container()
+        subject.register(type: SimpleDependency.self) { _ in
+            SimpleDependency()
+        }
+
+        // When
+        let resolvedDependency: SimpleDependency = try subject.tryResolve(type: SimpleDependency.self)
+
+        // Then
+        #expect(resolvedDependency is SimpleDependency)
+    }
 }