Wrapping @Shared and ignoring updates, or ensuring atomic updates?

[jshier]

I'm writing a wrapper for @Shared to replace an old singleton as well as a newer swift-dependencies-style wrapper. Currently they each do their own caching and operate in separate parts of the app, so unifying them will help keep things in sync.

However, while I've gotten the property wrapper to work, I'm having trouble optimizing it. Namely, I track the Tasks which encapsulate the network calls used to update the underlying state. However, this means that the shared state is updated, which triggers the observation and publisher machinery. I'd like to avoid that but there doesn't seem to be any way for @Shared to ignore updates to particular properties, nor does @PerceptionIgnored work.

Alternatively I could break those Tasks out into their own @Shared value, but then I run into issues properly keeping updates atomic. Since every instance of the wrapper is separate, internal locks won't help. Moving everything to use the async withLock (which seems misnamed since it doesn't lock and has to be used async) causes issues, as it means I can no longer atomically update the state in a way that prevents duplicate work, as the suspension provides an opportunity for other instances to start their own version of the work.

Is there any general guidance here, for either of these problems?

Current wrapper code

@propertyWrapper
struct Features: Equatable {
    struct GroupKey: Hashable {
        let group: FeatureResponse.Group
        let userID: String

        init?(group: FeatureResponse.Group) {
            @Dependency(\.user) var user

            guard let userID = user()?.userId else { return nil }

            self.userID = userID
            self.group = group
        }
    }

    @Shared(.inMemory("SharedFeatureAssessments")) private var features = SharedFeatures()

    var projectedValue: Self { self }

    var wrappedValue: SharedFeatures {
        get { self.features }
        nonmutating set { features = newValue }
    }

    /// Underlying shared publisher.
    ///
    /// - Note: This publisher emits when any of the `isLoading`, `response`, or `task` values are updated, despite the
    ///         task values not being visible externally.
    ///
    var publisher: AnyPublisher<SharedFeatureAssessments, Never> {
        self.$assessments.publisher
    }

    func refresh(group: FeatureResponse.Group) {
        Task { await self.refresh(group: group) }
    }

    func refresh(group: FeatureResponse.Group) async {
        guard let key = Features.GroupKey(group: group) else { return }

        @Dependency(\.featuresClient) var featuresClient

        self.features.isLoading[key] = true

        var isNewTask = false
        let task: Task<FeatureResponse?, Never>
        if let existingTask = features.refreshTasks[key] {
            task = existingTask
        } else {
            let newTask = Task { await features.fetchAvailability(group) }
            self.features.refreshTasks[key] = newTask
            isNewTask = true
            task = newTask
        }

        let response = await task.value

        if isNewTask {
            // Mutate atomically.
            self.mutate {
                $0.refreshTasks[key] = nil
                $0.responses[key] = response
                $0.isLoading[key] = false
            }
        }
    }

    func refreshAll() {
        self.makeRefreshTasks()
    }

    func refreshAll() async {
        for task in self.makeRefreshTasks() {
            await task.value
        }
    }

    private func mutate(_ mutation: (inout SharedFeatures) -> Void) {
        mutation(&self.features)
    }

    @discardableResult
    private func makeRefreshTasks() -> [Task<Void, Never>] {
        self.features.responses.keys.map(\.group).uniqued().map { group in
            // Start refreshes in parallel.
            Task { await self.refresh(group: group) }
        }
    }
}

struct SharedFeatures: Equatable {
    subscript(response group: FeatureResponse.FeatureGroup) -> FeatureResponse? {
        get { Features.GroupKey(group: group).flatMap { self.responses[$0] } }
        set {
            guard let key = Features.GroupKey(group: group) else { return }

            self.responses[key] = newValue
        }
    }

    subscript(isLoading group: FeatureResponse.Group) -> Bool {
        get { Features.GroupKey(group: group).flatMap { self.isLoading[$0] } ?? false }
        set {
            guard let key = Features.GroupKey(group: group) else { return }

            self.isLoading[key] = newValue
        }
    }

    fileprivate var responses: [Features.GroupKey: FeatureResponse] = [:]
    fileprivate var isLoading: [Features.GroupKey: Bool] = [:]

    fileprivate var refreshTasks: [Features.GroupKey: Task<FeatureResponse?, Never>] = [:]
}