[Question]: My watched ObservableObjectAtom isn't updating, am I configuring something wrong?

[felixakiragreen]

Checklist

• This is not a bug caused by platform.
• Reviewed the README and documentation.
• Checked existing issues & PRs to ensure not duplicated.

What happened?

(I apologize if this is not a bug, I wasn't sure which category of issue to file this under.)
(I have been using Atoms for a few weeks, with zero issues. I've been able to get almost everything working except this one last thing. I got a stuck on it a week ago, left it and moved on, but now I've come back to it and after a day of trying to get it working, I'm stumped.)

Context:

1. I have an AccountStore, (most of which was copied from the Apple Passkey Sample Code) that is working correctly (when I use it as an EnvironmentObject. Here is part of it, shortened for brevity:

public final class AccountStore: NSObject, ObservableObject, ASAuthorizationControllerDelegate {
   @Published public private(set) var currentUser: User? = .default

   @MainActor
   public func signIn(username: String) async throws {
      // ... 
   }

   @MainActor
   public func signOut() {
      // ... 
   }

   // ...
}

2. Since I've managed to move the rest of my data model over to Atoms, the only thing left is Auth & fetching the User (Player). Here are the Atoms I created in order to try to do this:

struct AccountStoreAtom: ObservableObjectAtom, Hashable {
	func object(context: Context) -> AccountStore {
		AccountStore()
	}
}

struct FetchPlayerAtom: ThrowingTaskAtom, Hashable {
	func defaultValue(context: Context) -> Player? {
		return nil
	}
	
	func value(context: Context) async throws -> Player {
		print("FetchPlayerAtom().value")
		return try await BackendAPI.fetchPlayer()
	}
}

struct PlayerAtom: ValueAtom, Hashable {
	func value(context: Context) -> Player? {
		let accountStore = context.watch(AccountStoreAtom())
		print("PlayerAtom().value", accountStore.currentUser as Any)
		
		if case let .authenticated(username) = accountStore.currentUser {
			print("PlayerAtom().value.authenticated()", username)
			let fetchPlayerPhase = context.watch(FetchPlayerAtom().phase)
			
			if case let .success(player) = fetchPlayerPhase {
				print("PlayerAtom().value.success()", player)
				return player
			}
		}
		
		return nil
	}
}

struct GameScreenAtom: ValueAtom, Hashable {
	func value(context: Context) -> GameScreen {
		let player = context.watch(PlayerAtom())
		
		print("GameScreenAtom().value", player as Any)

		if player == nil {
			return .mainMenu
		}
	
		if player!.isPlaying {
			return .homeBase
		}
	
		return .setupNew
	}
}

Expected Behavior

After logging in, the AccountStore publishes to currentUser, setting it to authenticated.

I expect that:

1. The PlayerAtom(), which is watching AccountStoreAtom(), would notice that currentUser was updated. (Not happening)
2. Then it would watch the FetchPlayerAtom(), and return the Player after it's fetched.
3. Finally, the GameScreenAtom(), which is watching the PlayerAtom(), would notice that a Player now exists, and would set the gameScreen accordingly.

Reproduction Steps

I don't have a great way to help you reproduce this yet, I'm hoping that you can spot if I'm doing anything incorrectly in my code. If not, then I'll try to put together a reproducible example.

I'm attaching a Screen Recording of this. If you watch it, please play attention to the orange 🏗 Debug Values at the top of the screen. You will note that when the EnvObject.currentScreen updates (which is computed in the same way, from the AccountStore), the Atom.GameScreen does not.

Swift Version

5

Library Version

0.2.0

Platform

iOS

Scrrenshot/Video/Gif

RPReplay_Final1659150219.MP4

[ra1028]

Hi @felixakiragreen ✋
I'll look into it a bit deeper later but from a grance I suspect the cause is that AccountStore is inherited from NSObject.
Normally @/Published is suppoesed to connect with objectWillChange publisher by probably reflection and it sends an event every time any of @/Published values are updated, but it might fail due to NSObject.
So I'd suggest you to try isolating the delegate conformance from the AccountStore itself and make a dedicated object for it.

Pseudo code is something like this:

final class AccountStore: ObservableObject {
    let delegate = AuthDelegate()
}

final class AuthDelegate: NSObject, ASAuthorizationControllerDelegate { ... }

[felixakiragreen]

Hi @ra1028 thank you for your reply.
After testing your method out, I was not able to get it to work.
However, you did give me an idea: changing how the Atom watches the AccountStore, so that it doesn't rely on ObservableObject.

Instead of creating an AccountStoreAtom, I created a NotificationAtom that watches NotificationCenter:

struct NotificationAtom: AsyncSequenceAtom, Hashable {
	let name: Notification.Name
	
	func sequence(context: Context) -> NotificationCenter.Notifications {
		NotificationCenter.default.notifications(named: name)
	}
}

In the AccountStore I post a notification:

func didFinishSignIn(_ username: String) {
	NotificationCenter.default.post(name: .UserSignedIn, object: username)
}

And in the PlayerAtom() I watch for this and then fetch the player:

struct PlayerAtom: ValueAtom, Hashable {
	func value(context: Context) -> Player? {
		let notificationPhase = context.watch(NotificationAtom(name: .UserSignedIn))
		
		if case .success = notificationPhase {
			let fetchPlayerPhase = context.watch(FetchPlayerAtom().phase)
			
			if case let .success(player) = fetchPlayerPhase {
				return player
			}
		}
		
		return nil
	}
}

Works perfectly! Thank you very much for your help!

[ra1028]

@felixakiragreen

Upon looking into this issue more carefully, I realized that when an ObservableObjectAtom is being watched from another atom, the property of the ObservableObject is not updated at the time it notifies update through objectWillChange publisher.
That's because the objectWillChange notifies updates on willSet timing and a new value of the property hasn't been set at that time.
I have created a patched branch for this, so please try it and let me know if it fixes your original problem.
Meanwhile, let me reopen this issue.

https://github.com/ra1028/swiftui-atom-properties/tree/feat/observable-object-did-update

[ra1028]

I was able to confirm that the solution I mentioned above works by unit test and a tiny reproducible example project, and it's now merged into main, please play around with it if you're still interested.

[felixakiragreen]

@ra1028 sorry for the delay - I just updated the package to follow the main branch (instead of latest release version), and I can confirm that watching ObservableObjects works now! 🙏

PS. this is very minor, please ignore, but it would make me so happy if the name of the package was Atoms instead of swiftui-atom-properties because then it would look the same as my other packages:

(Not the name on Github, just the Swift Package(name: "..."))

[ra1028]

@felixakiragreen
Thanks for checking! Good to know.

As for the package name, kebab-case package names are getting to be standard nowadays, for instance, Apple's Swift frameworks or TCA, so I still would like to continue using it.