Skip to main content

smart_refresh_token 0.2.0 copy "smart_refresh_token: ^0.2.0" to clipboard
smart_refresh_token: ^0.2.0 copied to clipboard

Race-free automatic access/refresh token handling for Dio. Single-flight refresh, request replay, proactive JWT expiry refresh, logout-safe, and pluggable secure storage on every platform.

example/lib/main.dart

import 'package:dio/dio.dart';
import 'package:flutter/material.dart';
import 'package:smart_refresh_token/smart_refresh_token.dart';

import 'fake_server.dart';
import 'secure_token_storage.dart';

void main() => runApp(const DemoApp(storage: SecureTokenStorage()));

/// Demo of smart_refresh_token against an in-app fake server.
class DemoApp extends StatefulWidget {
  const DemoApp({super.key, required this.storage, this.server});

  /// Where tokens are kept (secure storage in the real app, in-memory in
  /// tests).
  final TokenStorage storage;

  /// Optional server override (tests use zero latency).
  final FakeServer? server;

  @override
  State<DemoApp> createState() => _DemoAppState();
}

class _DemoAppState extends State<DemoApp> {
  late final FakeServer server = widget.server ?? FakeServer();
  late final Dio dio;
  late final RefreshTokenInterceptor auth;
  late final TokenRefreshLifecycleObserver lifecycle;
  final List<String> logs = [];

  @override
  void initState() {
    super.initState();
    dio = Dio(BaseOptions(baseUrl: 'https://api.example.com'))
      ..httpClientAdapter = server; // remove this line for a real backend

    auth = RefreshTokenInterceptor(
      dio: dio,
      tokenStorage: widget.storage,
      // The whole refresh integration: call your endpoint, parse the result.
      tokenRefresher: (current, client) async {
        final res = await client.post<Map<String, dynamic>>(
          '/auth/refresh',
          data: {'refresh_token': current.refreshToken},
        );
        return Credentials.fromOAuthJson(res.data!, previous: current);
      },
      onAuthFailure: (reason) => log('Session ended: ${reason.message}'),
      refreshConfig: RefreshConfig(
        expirationBuffer: const Duration(seconds: 5),
        onRefreshStart: () => log('Refreshing token...'),
        onRefreshSuccess: (c) => log('Refreshed -> ${c.accessToken}'),
        onRefreshFailure: (e) => log('Refresh failed (${e.type.name})'),
      ),
    );
    dio.interceptors.add(auth);
    lifecycle = TokenRefreshLifecycleObserver(auth)..start();
  }

  @override
  void dispose() {
    lifecycle.stop();
    auth.dispose();
    super.dispose();
  }

  void log(String message) {
    if (!mounted) return;
    final time = DateTime.now().toIso8601String().substring(11, 19);
    setState(() => logs.insert(0, '$time  $message'));
  }

  Future<void> login() async {
    final res = await dio.post<Map<String, dynamic>>(
      '/auth/login',
      data: {'user': 'ada', 'password': 'demo'},
      options: Options().skipAuth(), // no token needed to log in
    );
    await auth.setCredentials(Credentials.fromOAuthJson(res.data!));
    log('Logged in');
  }

  Future<void> loadProfile() async {
    try {
      final res = await dio.get<Map<String, dynamic>>('/me');
      log('GET /me -> ${res.data!['user']}');
    } on DioException catch (e) {
      log('GET /me failed: ${e.error ?? e.message}');
    }
  }

  Future<void> burst() async {
    final before = server.refreshCalls;
    final results = await Future.wait([
      for (var i = 0; i < 10; i++)
        dio
            .get<dynamic>('/items/$i')
            .then((_) => true, onError: (Object _) => false),
    ]);
    final ok = results.where((r) => r).length;
    log('10 parallel requests: $ok succeeded, '
        '${server.refreshCalls - before} refresh call(s)');
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'smart_refresh_token demo',
      debugShowCheckedModeBanner: false,
      theme: ThemeData(colorSchemeSeed: Colors.indigo, useMaterial3: true),
      home: Scaffold(
        appBar: AppBar(title: const Text('smart_refresh_token')),
        body: StreamBuilder<AuthStatus>(
          stream: auth.authStatus,
          builder: (context, snapshot) {
            final status = snapshot.data ?? AuthStatus.unknown;
            return Column(
              crossAxisAlignment: CrossAxisAlignment.stretch,
              children: [
                ListTile(
                  leading: Icon(
                    status == AuthStatus.authenticated
                        ? Icons.verified_user
                        : Icons.no_accounts,
                  ),
                  title: Text('Status: ${status.name}'),
                  subtitle:
                      Text('Refresh calls so far: ${server.refreshCalls}'),
                ),
                Padding(
                  padding: const EdgeInsets.symmetric(horizontal: 16),
                  child: Wrap(
                    spacing: 8,
                    runSpacing: 8,
                    children: status == AuthStatus.authenticated
                        ? [
                            FilledButton(
                              onPressed: loadProfile,
                              child: const Text('GET /me'),
                            ),
                            FilledButton.tonal(
                              onPressed: burst,
                              child: const Text('10 parallel requests'),
                            ),
                            OutlinedButton(
                              onPressed: () {
                                server.expireAccessTokens();
                                log('Server: access tokens invalidated');
                              },
                              child: const Text('Expire access token'),
                            ),
                            OutlinedButton(
                              onPressed: () {
                                server.revokeRefreshTokens();
                                log('Server: refresh token revoked');
                              },
                              child: const Text('Revoke refresh token'),
                            ),
                            TextButton(
                              onPressed: () async {
                                await auth.clearTokens();
                                log('Logged out');
                              },
                              child: const Text('Log out'),
                            ),
                          ]
                        : [
                            FilledButton(
                              key: const Key('login'),
                              onPressed: login,
                              child: const Text('Log in'),
                            ),
                          ],
                  ),
                ),
                const Divider(height: 32),
                Expanded(
                  child: ListView(
                    padding: const EdgeInsets.symmetric(horizontal: 16),
                    children: [
                      for (final line in logs)
                        Text(
                          line,
                          style: const TextStyle(fontFamily: 'monospace'),
                        ),
                    ],
                  ),
                ),
              ],
            );
          },
        ),
      ),
    );
  }
}
2
likes
150
points
116
downloads

Documentation

API reference

Publisher

unverified uploader

Weekly Downloads

Race-free automatic access/refresh token handling for Dio. Single-flight refresh, request replay, proactive JWT expiry refresh, logout-safe, and pluggable secure storage on every platform.

Repository (GitHub)
View/report issues

Topics

#dio #authentication #jwt #oauth #interceptor

License

MIT (license)

Dependencies

dio, flutter

More

Packages that depend on smart_refresh_token