Étude de cas : Application Todo complète

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();

  final storage = await HiveStorageAdapter.open('qora_cache');
  final connectivity = SimulatedConnectivityManager();

  final client = PersistQoraClient(
    storage: storage,
    persistDuration: const Duration(days: 30),
    config: QoraClientConfig(
      defaultOptions: const QoraOptions(
        staleTime: Duration(minutes: 5),
        networkMode: NetworkMode.offlineFirst,
      ),
      reconnectStrategy: const ReconnectStrategy(
        maxConcurrent: 3,
        jitter: Duration(milliseconds: 150),
      ),
      debugMode: kDebugMode,
    ),
  );

  registerAllSerializers(client);
  await client.hydrate(); // ← chauffer le cache avant la première frame

  runApp(
    QoraScope(
      client: client,
      connectivityManager: connectivity,
      lifecycleManager: FlutterLifecycleManager(qoraClient: client),
      child: OfflineBannerWrapper(child: _App(auth: AuthService(), connectivity: connectivity)),
    ),
  );
}

InfiniteQueryBuilder<TodosPage, int>(
  queryKey: ['todos', auth.id],
  fetcher: (page) => api.getTodosPage(auth.id, page),
  options: InfiniteQueryOptions(
    initialPageParam: 1,
    getNextPageParam: (last, all) => last.hasMore ? all.length + 1 : null,
  ),
  builder: (context, state, controller) {
    // ... gestion de l'état
    final allItems = [
      ..._pendingTodos, // éléments optimistes en premier
      ...state.data!.flatten((p) => p.todos),
    ];

    return RefreshIndicator(
      onRefresh: () => controller.refetch(),
      child: ListView.builder(
        itemCount: allItems.length + 1, // +1 pour la sentinelle
        itemBuilder: (context, index) {
          if (index == allItems.length) {
            // Sentinelle: fetcher la page suivante automatiquement quand défilée en vue
            if (state.hasNextPage && !state.isFetchingNextPage) {
              controller.fetchNextPage();
            }
            return state.isFetchingNextPage
                ? const _PageLoader()
                : const SizedBox.shrink();
          }
          final todo = allItems[index];
          return todo.isOptimistic
              ? TodoTile(todo: todo) // optimiste: sans callbacks de mutation
              : _MutableTodoTile(todo: todo, api: api, auth: auth);
        },
      ),
    );
  },
)

QoraMutationBuilder<Todo, CreateTodoInput, List<Todo>>(
  mutator: api.createTodo,
  options: MutationOptions(
    offlineQueue: true,
    optimisticResponse: (input) => Todo.optimistic(title: input.title),
    onMutate: (input) async {
      // Snapshot de la liste en attente courante pour le rollback
      final snapshot = List<Todo>.from(_pendingTodos);
      setState(() => _pendingTodos.add(Todo.optimistic(title: input.title)));
      return snapshot;
    },
    onSuccess: (_, __, ___) async {
      setState(() => _pendingTodos.clear());
      context.qora.invalidate(['todos', auth.id]);
    },
    onError: (_, __, snapshot) async {
      // Restaurer la liste en attente pré-mutation
      setState(() => _pendingTodos = snapshot ?? []);
    },
  ),
  builder: (context, state, mutate) {
    return FloatingActionButton(
      onPressed: state.isPending ? null : () => _showCreateDialog(mutate),
      child: state.isPending
          ? const CircularProgressIndicator(strokeWidth: 2)
          : const Icon(Icons.add),
    );
  },
)

class _MutableTodoTile extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return QoraMutationBuilder<Todo, ToggleTodoInput, void>(
      mutator: api.toggleTodo,
      options: MutationOptions(
        onSuccess: (_, __, ___) async =>
            context.qora.invalidate(['todos', auth.id]),
      ),
      builder: (context, toggleState, toggle) {
        return QoraMutationBuilder<void, int, void>(
          mutator: api.deleteTodo,
          options: MutationOptions(
            onSuccess: (_, __, ___) async =>
                context.qora.invalidate(['todos', auth.id]),
          ),
          builder: (context, deleteState, delete) {
            return TodoTile(
              todo: todo,
              onToggle: toggleState.isPending ? null
                  : () => toggle(ToggleTodoInput(id: todo.id, completed: !todo.completed)),
              onDelete: deleteState.isPending ? null
                  : () => delete(todo.id),
            );
          },
        );
      },
    );
  }
}

case InfiniteFailure(:final error, :final previousData):
  if (previousData != null) {
    // Afficher les données périmées + bannière d'erreur en haut
    return Column(
      children: [
        _ErrorBanner(error: error, onRetry: controller.fetchNextPage),
        Expanded(child: _buildList(previousData, controller)),
      ],
    );
  }
  // Aucune donnée du tout : écran d'erreur complet avec réessai
  return _ErrorView(error: error, onRetry: controller.refetch);

class SimulatedConnectivityManager implements ConnectivityManager {
  final _controller = StreamController<NetworkStatus>.broadcast();
  NetworkStatus _status = NetworkStatus.online;

  @override
  Stream<NetworkStatus> get statusStream => _controller.stream;

  @override
  NetworkStatus get currentStatus => _status;

  void toggle() {
    _status = _status == NetworkStatus.online
        ? NetworkStatus.offline
        : NetworkStatus.online;
    _controller.add(_status);
  }

  @override
  void dispose() => _controller.close();
}