refactor: implement new NSE mechanism and pull pending events - WPB-10219

WireAPI/Sources/WireAPI/Models/UpdateEvent/FeatureConfigEvent/FeatureConfigEvent.swift

@@ -20,7 +20,7 @@ import Foundation
 
 /// An event concerning feature configs.
 
-public enum FeatureConfigEvent: Equatable, Codable {
+public enum FeatureConfigEvent: Equatable, Codable, Sendable {
 
     /// A feature config was updated.
 

WireAPI/Sources/WireAPI/Models/UpdateEvent/FederationEvent/FederationEvent.swift

@@ -20,7 +20,7 @@ import Foundation
 
 /// An event concerning federation between domains.
 
-public enum FederationEvent: Equatable, Codable {
+public enum FederationEvent: Equatable, Codable, Sendable {
 
     /// Two or more other domains have stopped federating
     /// with each other.

WireAPI/Sources/WireAPI/Models/UpdateEvent/TeamEvent/TeamEvent.swift

@@ -20,7 +20,7 @@ import Foundation
 
 /// An event concerning teams.
 
-public enum TeamEvent: Equatable, Codable {
+public enum TeamEvent: Equatable, Codable, Sendable {
 
     /// The self team was deleted.
 

WireAPI/Sources/WireAPI/Models/UpdateEvent/UserEvent/UserEvent.swift

@@ -20,7 +20,7 @@ import Foundation
 
 /// An event concerning users.
 
-public enum UserEvent: Equatable, Codable {
+public enum UserEvent: Equatable, Codable, Sendable {
 
     /// The self user has added a new client.
 

WireDomain/Sources/WireDomain/Assembly.swift

@@ -0,0 +1,104 @@
+//
+// Wire
+// Copyright (C) 2025 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import WireAPI
+import WireDataModel
+import WireFoundation
+
+public final class Assembly {
+
+    private let userID: UUID
+    private let clientID: String
+    private let context: NSManagedObjectContext
+    private let sharedUserDefaults: UserDefaults
+    private let proteusService: any ProteusServiceInterface
+    private let apiService: any APIServiceProtocol
+    private let apiVersion: WireAPI.APIVersion
+    private let pushChannel: any PushChannelProtocol
+    private let backendEnvironmentProvider: BackendEnvironmentProvider
+
+    init(
+        userID: UUID,
+        clientID: String,
+        context: NSManagedObjectContext,
+        sharedUserDefaults: UserDefaults,
+        proteusService: any ProteusServiceInterface,
+        apiService: any APIServiceProtocol,
+        apiVersion: WireAPI.APIVersion,
+        pushChannel: any PushChannelProtocol,
+        backendEnvironmentProvider: BackendEnvironmentProvider
+    ) {
+        self.userID = userID
+        self.clientID = clientID
+        self.context = context
+        self.sharedUserDefaults = sharedUserDefaults
+        self.proteusService = proteusService
+        self.apiService = apiService
+        self.apiVersion = apiVersion
+        self.pushChannel = pushChannel
+        self.backendEnvironmentProvider = backendEnvironmentProvider
+
+        registerNotificationServiceDependencies()
+    }
+
+    // MARK: - API Init
+
+    private lazy var updateEventsAPI = UpdateEventsAPIBuilder(
+        apiService: apiService
+    ).makeAPI(for: apiVersion)
+
+    // MARK: - Repositories and local stores Init
+
+    private lazy var userLocalStore = UserLocalStore(context: context)
+
+    private lazy var updateEventsLocalStore = UpdateEventsLocalStore(
+        context: context,
+        userID: userID,
+        sharedUserDefaults: sharedUserDefaults
+    )
+
+}
+
+extension Assembly {
+
+    /// Register some domain dependencies to be resolved by the `NotificationService`.
+    /// Since `NotificationService` is not initializable, the injector provides a lightweight dependency injection
+    /// mechanism to retrieve some already initialized dependencies that the notification service requires.
+
+    private func registerNotificationServiceDependencies() {
+        Injector.register(UserLocalStoreProtocol.self) {
+            self.userLocalStore
+        }
+
+        Injector.register(UpdateEventsAPI.self) {
+            self.updateEventsAPI
+        }
+
+        Injector.register(PushChannelProtocol.self) {
+            self.pushChannel
+        }
+
+        Injector.register(BackendEnvironmentProvider.self) {
+            self.backendEnvironmentProvider
+        }
+
+        Injector.register(UpdateEventsLocalStoreProtocol.self) {
+            self.updateEventsLocalStore
+        }
+    }
+}

WireDomain/Sources/WireDomain/Dependency Injection/Injector.swift

@@ -0,0 +1,194 @@
+//
+// Wire
+// Copyright (C) 2025 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import Foundation
+
+protocol OptionalProtocol {
+    static var wrappedType: Any.Type { get }
+}
+
+extension Optional: OptionalProtocol {
+    public static var wrappedType: Any.Type {
+        Wrapped.self
+    }
+}
+
+enum Injector {
+    private nonisolated(unsafe) static var services: [ServiceKey: ServiceEntryProtocol] = [:]
+
+    // MARK: - Register
+
+    static func register<Service>(
+        _ serviceType: Service.Type,
+        factory: @escaping () -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1, Arg2>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1, Arg2) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1, Arg2, Arg3>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1, Arg2, Arg3) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1, Arg2, Arg3, Arg4>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1, Arg2, Arg3, Arg4) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1, Arg2, Arg3, Arg4, Arg5) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    static func register<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arg1, Arg2, Arg3, Arg4, Arg5, Arg6) -> Service
+    ) {
+        _register(serviceType, factory: factory)
+    }
+
+    private static func _register<Service, Arguments>(
+        _ serviceType: Service.Type,
+        factory: @escaping (Arguments) -> Any
+    ) {
+
+        let key = ServiceKey(serviceType: Service.self, argumentsType: Arguments.self)
+
+        let entry = ServiceEntry(
+            serviceType: serviceType,
+            argumentsType: Arguments.self,
+            factory: factory
+        )
+        services[key] = entry
+    }
+
+    // MARK: - Resolve
+
+    static func resolve<Service>() -> Service {
+        typealias FactoryType = (()) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory(())
+        }
+    }
+
+    static func resolve<Service, Arg1>(
+        argument: Arg1
+    ) -> Service {
+        typealias FactoryType = (Arg1) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory(argument)
+        }
+    }
+
+    static func resolve<Service, Arg1, Arg2>(
+        arguments arg1: Arg1, _ arg2: Arg2
+    ) -> Service {
+        typealias FactoryType = ((Arg1, Arg2)) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory((arg1, arg2))
+        }
+    }
+
+    static func resolve<Service, Arg1, Arg2, Arg3>(
+        arguments arg1: Arg1, _ arg2: Arg2, _ arg3: Arg3
+    ) -> Service {
+        typealias FactoryType = ((Arg1, Arg2, Arg3)) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory((arg1, arg2, arg3))
+        }
+    }
+
+    static func resolve<Service, Arg1, Arg2, Arg3, Arg4>(
+        arguments arg1: Arg1, _ arg2: Arg2, _ arg3: Arg3, _ arg4: Arg4
+    ) -> Service {
+        typealias FactoryType = ((Arg1, Arg2, Arg3, Arg4)) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory((arg1, arg2, arg3, arg4))
+        }
+    }
+
+    static func resolve<Service, Arg1, Arg2, Arg3, Arg4, Arg5>(
+        arguments arg1: Arg1, _ arg2: Arg2, _ arg3: Arg3, _ arg4: Arg4, _ arg5: Arg5
+    ) -> Service {
+        typealias FactoryType = ((Arg1, Arg2, Arg3, Arg4, Arg5)) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory((arg1, arg2, arg3, arg4, arg5))
+        }
+    }
+
+    static func resolve<Service, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(
+        arguments arg1: Arg1, _ arg2: Arg2, _ arg3: Arg3, _ arg4: Arg4, _ arg5: Arg5, _ arg6: Arg6
+    ) -> Service {
+        typealias FactoryType = ((Arg1, Arg2, Arg3, Arg4, Arg5, Arg6)) -> Any
+        return _genericResolve(serviceType: Service.self) { (factory: FactoryType) in
+            factory((arg1, arg2, arg3, arg4, arg5, arg6))
+        }
+    }
+
+    static func _genericResolve<Service, Arguments>(
+        serviceType: Service.Type,
+        invoker: @escaping ((Arguments) -> Any) -> Any
+    ) -> Service {
+        var resolvedInstance: Service?
+        let type: Any.Type = if let optionalType = Service.self as? OptionalProtocol.Type {
+            optionalType.wrappedType
+        } else {
+            Service.self
+        }
+
+        let key = ServiceKey(serviceType: type, argumentsType: Arguments.self)
+
+        if let entry = services[key] {
+            resolvedInstance = resolve(entry: entry, invoker: invoker)
+        }
+
+        if let resolvedInstance {
+            return resolvedInstance
+        } else {
+            fatalError("You need to register concrete type for \(Service.self)")
+        }
+    }
+
+    private static func resolve<Service, Factory>(
+        entry: ServiceEntryProtocol,
+        invoker: (Factory) -> Any
+    ) -> Service? {
+        let resolvedInstance = invoker(entry.factory as! Factory)
+        return resolvedInstance as? Service
+    }
+}

WireDomain/Sources/WireDomain/Dependency Injection/ServiceEntry.swift

@@ -0,0 +1,43 @@
+//
+// Wire
+// Copyright (C) 2025 Wire Swiss GmbH
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see http://www.gnu.org/licenses/.
+//
+
+import Foundation
+
+typealias FunctionType = Any
+
+protocol ServiceEntryProtocol: AnyObject {
+    var factory: FunctionType { get }
+    var serviceType: Any.Type { get }
+}
+
+final class ServiceEntry<Service>: ServiceEntryProtocol {
+
+    // MARK: - Properties
+
+    let serviceType: Any.Type
+    let argumentsType: Any.Type
+    let factory: FunctionType
+
+    // MARK: - Object lifecycle
+
+    init(serviceType: Service.Type, argumentsType: Any.Type, factory: FunctionType) {
+        self.serviceType = serviceType
+        self.argumentsType = argumentsType
+        self.factory = factory
+    }
+}