feat(llc)!: let a TokenManager switch users

STYLE_GUIDE.md

@@ -842,6 +842,13 @@ debugging, and refactoring significantly harder. Instead of `setUp`, use local
 helper functions called inside each test block. For cleanup, prefer `addTearDown`
 over the global `tearDown` callback.
 
+The rule targets shared state, not pure construction. A deterministic fixture
+builder that holds no state — a signed token, an encoded payload, a fixed
+timestamp — may live under `test/helpers/` and be imported by several test files:
+copies of one tend to drift, and a subtly wrong fixture is harder to spot than a
+shared one. Anything that holds state between tests, or that arranges a scenario
+rather than building a value, stays local to the test file.
+
 ### Prefer more test files, avoid long test files
 
 Organize tests into smaller files grouped by feature, widget, or behavior. Split

melos.yaml

@@ -19,6 +19,7 @@ command:
     # List of all the dependencies used in the project.
     dependencies:
       cached_network_image_ce: ^4.9.0
+      clock: ^1.1.2
       collection: ^1.19.0
       cross_file: ^0.3.4+2
       dio: ^5.8.0+1
@@ -53,6 +54,7 @@ command:
     dev_dependencies:
       alchemist: ^0.13.0
       build_runner: ^2.10.5
+      fake_async: ^1.3.3
       json_serializable: ^6.9.5
       melos: ^6.2.0
       mocktail: ^1.0.4

packages/stream_core/CHANGELOG.md

@@ -1,24 +1,34 @@
 ## Upcoming
 
+### 💥 BREAKING CHANGES
+
+- Removed the `userId` parameter from `UserToken.anonymous`, anonymous tokens always use `User.anonymousUserId`
+- Removed the `TokenManager.tokenProvider` setter, use `setTokenProvider` instead
+- `TokenManager.userId` is now nullable, and is `null` until an identity is configured
+- `User` now requires a user of type `UserType.anonymous` to carry `User.anonymousUserId` as its id. A mismatch fails to compile in a const context, and throws in debug mode otherwise
+
 ### ✨ Features
 
-- Added `AuthInterceptor.withProvider`, which takes a `TokenManager Function()` getter instead of a fixed `TokenManager` instance. This lets callers swap the active `TokenManager` at runtime — e.g. after a guest token exchange resolves a server-assigned user id — and have the interceptor pick up the new instance (and its `userId`) on the next request. The existing `AuthInterceptor(dio, tokenManager)` constructor is unchanged.
-- Added `teams` field to `User` class.
-- Added optional `onTokenUpdated` callback to `TokenManager`, invoked after every successful
-  token load.
-- Added optional `rawValue` parameter to `UserToken.anonymous` so anonymous tokens can carry
-  a JWT (e.g. call-restricted tokens for closed livestreams).
+- Added `TokenManager.setTokenProvider`, which points an existing manager at another user and expires the cached token; handed the identity it already has, it does nothing
+- Added optional `onTokenUpdated` callback to `TokenManager`, invoked after every successful token load
+- Added optional `rawValue` to `UserToken.anonymous`, so an anonymous token can carry a JWT granting restricted access; its `user_id` claim must be `!anon`
+- Added `UserToken.expiresAt`, from the token's `exp` claim, and `UserToken.isExpired`, which takes an optional `leeway`
+- Added `User.anonymousUserId`, the id every anonymous user has
+- Added `TokenManager.unconfigured`, for a client that exists before its user does, and `TokenManager.reset`, which drops the configured identity and its cached token
+- Added `teams` field to `User` class
 
-### 🐞 Fixed
+### 🐛 Bug Fixes
 
-- `TokenManager.getToken()` now returns the cached token instead of contacting the
-  `TokenProvider` on every call.
-- The `TokenManager.tokenProvider` setter now stores the new provider, previously it only
-  expired the cached token.
+- Fixed three faults in `TokenManager`'s token cache: `getToken` contacted the provider on every call instead of returning the cached token, handed out a token that had already expired rather than replacing it, and cached one that finished loading after `expireToken` or `setTokenProvider` had invalidated it. A static provider is left alone, having nothing fresher to give
+- Fixed `DynamicTokenProvider` accepting a token issued for a different user than the one requested
 
 ### 🔄 Changed
 
-- Raised the minimum Dart SDK to `^3.12.0`.
+- Raised the minimum Dart SDK to `^3.12.0`
+- Anonymous requests now always send `user_id=!anon`, rather than whatever id the `TokenManager` was configured with
+- `DynamicTokenProvider` checks the token type before its user id, so a token of the wrong type is reported as such instead of as a mismatched user
+- `TokenManager.getToken` fails when `reset` runs while the token is loading, and rejects a token whose `user_id` is not the user it was loading for; a `setTokenProvider` during a load still serves the caller that started it
+- `AuthInterceptor` no longer attempts a token refresh when the manager has no identity, so the original token-expired error is surfaced rather than a failure to load a token
 
 ## 0.4.0
 

packages/stream_core/lib/src/api/interceptors/auth_interceptor.dart

@@ -4,63 +4,26 @@ import '../../errors.dart';
 import '../../user.dart';
 import '../stream_core_dio_error.dart';
 
-/// Provides the [TokenManager] currently in use by an [AuthInterceptor].
-///
-/// A getter rather than a fixed reference so the caller can swap the underlying
-/// [TokenManager] at runtime — e.g. after a guest token exchange resolves a
-/// server-assigned user id — and have the interceptor pick up the new instance.
-typedef TokenManagerProvider = TokenManager Function();
-
 /// Authentication interceptor that refreshes the token if
 /// an auth error is received
 class AuthInterceptor extends QueuedInterceptor {
-  /// Initialize a new auth interceptor backed by a fixed [tokenManager].
-  ///
-  /// Use this when the [TokenManager] never changes for the lifetime of the
-  /// interceptor. If you need to swap the manager at runtime — e.g. after a
-  /// guest token exchange resolves a server-assigned user id — use
-  /// [AuthInterceptor.withProvider] instead.
-  AuthInterceptor(
-    this._dio,
-    TokenManager tokenManager,
-  ) : _tokenManager = tokenManager,
-      _tokenManagerProvider = null;
-
-  /// Initialize a new auth interceptor backed by a [_tokenManagerProvider].
-  ///
-  /// The provider is a getter rather than a fixed reference so the caller can
-  /// swap the underlying [TokenManager] — e.g. after a guest token exchange
-  /// resolves a server-assigned user id — and have this interceptor pick up
-  /// the new instance on its next request.
-  AuthInterceptor.withProvider(
-    this._dio, {
-    required TokenManagerProvider this._tokenManagerProvider,
-  }) : _tokenManager = null;
+  /// Initialize a new auth interceptor
+  AuthInterceptor(this._dio, this._tokenManager);
 
   final Dio _dio;
 
-  final TokenManager? _tokenManager;
-
-  /// Provides the token manager currently in use.
-  final TokenManagerProvider? _tokenManagerProvider;
-
-  /// The token manager currently in use.
-  TokenManager get _effectiveTokenManager => _tokenManager ?? _tokenManagerProvider!.call();
+  /// The token manager used in the client
+  final TokenManager _tokenManager;
 
   @override
   Future<void> onRequest(
     RequestOptions options,
     RequestInterceptorHandler handler,
   ) async {
     try {
-      final token = await _effectiveTokenManager.getToken();
+      final token = await _tokenManager.getToken();
 
-      // Re-read the token manager after awaiting the token: loading it may
-      // have swapped in a new manager carrying a server-resolved user id
-      // (e.g. a guest exchange). Reading `userId` here keeps the `user_id`
-      // query parameter consistent with the identity in the `Authorization`
-      // header below.
-      options.queryParameters['user_id'] = _effectiveTokenManager.userId;
+      options.queryParameters['user_id'] = token.userId;
       options.headers['Authorization'] = token.rawValue;
       options.headers['stream-auth-type'] = token.authType.headerValue;
 
@@ -94,11 +57,12 @@ class AuthInterceptor extends QueuedInterceptor {
 
     final error = StreamApiError.fromJson(data);
     if (error.isTokenExpiredError) {
-      final tokenManager = _effectiveTokenManager;
-      // Don't try to refresh the token if we're using a static provider
-      if (tokenManager.usesStaticProvider) return handler.next(err);
+      // Don't try to refresh the token when there is no user to load one for,
+      // or when the provider would return the same token again.
+      final canRefresh = _tokenManager.userId != null && !_tokenManager.usesStaticProvider;
+      if (!canRefresh) return handler.next(err);
       // Otherwise, mark the current token as expired.
-      tokenManager.expireToken();
+      _tokenManager.expireToken();
 
       try {
         final options = err.requestOptions;