Deriving a non-optional SharedReaderKey from a SharedKey

[mAu888]

Let me first give a little bit of context of what we are trying to achieve. We have an application where a user can authenticate themselves. Once authenticated, the user is shared across the App using a FileStorageKey. The type is Optional<User>, where nil represents the unauthenticated state.

All features in the app except for the login screen require a user to be present. One solution leveraging existing tools from swift-sharing is to use the Shared(_:) initialiser that unwraps an optional shareable and pass the unwrapped Shared to the child features requiring a user.
This means though, that we need to inject the user from the top-most view down to each feature.

Ultimatively, what we'd like to have is a SharedReaderKey<User> that allows a child feature at any level to read the current user.

struct AppFeature {
  @Shared(\.currentUser) var user: User?

  func onLogin(_ user: User) {
    $user.withLock { $0 = user }
  }

  func onLogout() {
    $user.withLock { $0 = nil }
  }
}

// The child feature will only be shown when `.currentUser` is present.
struct DeeplyNestedChildFeature {
  @Shared(\.user) var user: User
}

Our first approach was to write a new shared key that reads from the same underlying storage. In general, this works fine until the user logs out. I assume that before our root view removes the child features from the view hierarchy, the child features @Shared(.user) is notified of the underlying persistence layer change and tries to decode the now nil value.
As expected, it raises a .valueNotFound error.

FileStorageKey.Default

public extension SharedReaderKey where Self == FileStorageKey<User>.Default {
    static var user: Self {
        let decoder = JSONDecoder()
        return Self[
            .fileStorage(
                .documentsDirectory.appending(component: "currentUser.json")
            ),
            default: {
                @Shared(.currentUser) var currentUser
                if let currentUser {
                    return currentUser
                } else {
                    reportIssue("`@Shared(.user)` should only be used in a context where it's existence is guranteed.")
                    return .init()
                }
            }()
        ]
    }
}

Then, we tried to create a custom persistence key.

UnwrappedSharingKey

public struct UnwrappedSharingKey<Entity: Sendable, UnderlyingKey: SharedReaderKey<Entity?>>: SharedReaderKey {
    private var underlyingKey: UnderlyingKey

    public typealias ID = UnderlyingKey.ID

    public init(underlying underlyingKey: UnderlyingKey) {
        self.underlyingKey = underlyingKey
    }

    public func load(
        context: LoadContext<Entity>,
        continuation: LoadContinuation<Entity>
    ) {
        @SharedReader(underlyingKey) var underlying
        if let underlying {
            continuation.resume(returning: underlying)
        } else {
            reportIssue("`UnwrappedSharingKey` should only be used in a context where its base values existence is guranteed at initialisation.")
            continuation.resumeReturningInitialValue()
        }
    }

    public var id: ID { underlyingKey.id }

    public func subscribe(
      context: LoadContext<Entity>,
      subscriber: SharedSubscriber<Entity>
    ) -> SharedSubscription {
        @SharedReader(underlyingKey) var underlying
        let cancellable = $underlying.publisher
            .sink { completion in
                switch completion {
                case let .failure(error):
                    subscriber.yield(throwing: error)
                case .finished:
                    break
                }
            } receiveValue: { newValue in
                if let newValue {
                    subscriber.yield(newValue)
                } else {
                    // Follow `Shared(_:)` semantics, where the last non-nil value is kept, if the underlying state becomes `nil`.
                }
            }

        return SharedSubscription { [cancellable] in
            cancellable.cancel()
        }
    }
}

Now, while this works when running on device or in the simulator, it does not work correctly in Xcode Previews. Setting an initial value for the underlying shared key does not get forwarded to the UnwrappedSharingKey somehow. I need to explicitly update the state using withLock in a #Preview macro.

@ViewAction(for: Feature.self)
public struct Screen: View {
    public init(store: StoreOf<Feature>) {
        self.store = store
    }

    public var store: StoreOf<Feature>

    public var body: some View {
        // `store.user` uses the `UnwrappedSharingKey` with an underlying key pointing to the `.currentUser` key.
        Text("Welcome, \(store.user.displayName ?? "Guest") 👋")
    }
}

#Preview {
    // Setting a default value for the underlying `Shared` property does not initialise the `Shared` using `UnwrappedSharingKey` with the current value of `.currentUser`.
    // We have to explicitly set a value using `$user.withLock` for the preview to behave as expected.
    @Shared(.currentUser) var user = .init(displayName: "Maurício")

    // Commenting out the next line makes the preview work.
    // $user.withLock { $0 = .init(displayName: "Maurício!") }
    return Screen(
        store: .init(
            initialState: .init(),
            reducer: { Feature() }
        )
    )
}

My question is if there is something inherently wrong with our implementation of a UnwrappedSharingKey or if this is a bad idea overall and if you'd suggest to pass down the SharedReader from the root feature.

Or, if there is another option that we have overlooked which would give us the desired ergonomics working with optional shared state.

Any pointer is much apprechiated!

Thanks,
Maurício

[stephencelis]

Sharing comes with tools for explicitly deriving non-optional shared values from optional ones:

if let sharedUser = SharedReader($currentUser) {
  // 'sharedUser' is 'SharedReader<User>'
}

Does this help with your use case?

[mAu888]

Thanks for the fast reply, @stephencelis.

This is basically the situation we want to avoid. Because in that case we either need to always unwrap the Shared<User?> in any feature we need a honest User, or we always need to pass the Shared<User> from the parent feature, which in turn only moves the if let one hierarchy up.

Basically, we want to move the unwrapping to the SharedReaderKey definition, so that we can do something like the following.

public extension SharedReaderKey where Self == UnwrappedSharingKey<User, FileStorageKey<User?>.Default>.Default {
    static var honestUser: Self {
        return Self[.unwrapped(.currentUser), default: .init()]
    }
}

// In ChildFeature.swift
struct ChildFeature {
  // This is of type `SharedReader<User>`, because we guarantee
  // that we will render `ChildFeature` only when `User` is present.
  // In case it is not present, we default to some value and use `reportIssue`.
  @SharedReader(\.honestUser) var honestUser
}

I also saw that there are some issues with the #Preview macro and swift-sharing, so maybe our implementation is indeed working and the fact that it does not in previews is related to these quirks 🤷