Persistance

import 'package:qora/qora.dart';

final client = PersistQoraClient(
  storage: InMemoryStorageAdapter(), // remplacer par un vrai adaptateur (voir ci-dessous)
  persistDuration: const Duration(days: 7),
  config: const QoraClientConfig(
    defaultOptions: QoraOptions(staleTime: Duration(minutes: 5)),
    debugMode: true, // affiche les logs [PersistQora]
  ),
);

// Objet unique
client.registerSerializer<User>(
  QoraSerializer(
    toJson: (user) => user.toJson(),
    fromJson: User.fromJson,
  ),
  name: 'User', // nom explicite : voir la section Obfuscation ci-dessous
);

// Collection
client.registerSerializer<List<Post>>(
  QoraSerializer(
    toJson: (posts) => posts.map((p) => p.toJson()).toList(),
    fromJson: (json) => (json as List).map((e) => Post.fromJson(e)).toList(),
  ),
  name: 'List<Post>',
);

// Primitif : aucune conversion nécessaire
client.registerSerializer<int>(
  QoraSerializer(toJson: (n) => n, fromJson: (json) => json as int),
  name: 'int',
);

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

  await storage.init();         // ouvrir la base de données / le fichier
  await client.hydrate();       // chauffer le cache depuis le disque

  runApp(QoraScope(client: client, child: const MyApp()));
}

void main() {
  WidgetsFlutterBinding.ensureInitialized();

  runApp(
    QoraScope(
      client: client,
      child: FutureBuilder<void>(
        future: storage.init().then((_) => client.hydrate()),
        builder: (context, snapshot) {
          if (snapshot.connectionState != ConnectionState.done) {
            return const MaterialApp(home: SplashScreen());
          }
          return const MyApp();
        },
      ),
    ),
  );
}

// staleTime: 5 minutes
// Si le dernier fetch était il y a 3 minutes → encore frais → pas de spinner au redémarrage
// Si le dernier fetch était il y a 8 minutes → afficher les données en cache + refetch en arrière-plan

final client = PersistQoraClient(
  storage: adapter,
  persistDuration: const Duration(days: 7), // valeur par défaut
);

// Forcer la persistance de la valeur courante en cache avec un TTL personnalisé
await client.persistQuery<User>(['users', userId], ttl: const Duration(hours: 1));

factory User.fromJson(dynamic json) {
  final map = json as Map<String, dynamic>;
  return User(
    id: map['id'] as int,
    name: map['name'] as String,
    // Ajouté en v2 : valeur par défaut chaîne vide pour les entrées persistées par v1
    avatarUrl: map['avatarUrl'] as String? ?? '',
  );
}

// Correct : Stable : le nom est codé en dur, ne change jamais
client.registerSerializer<User>(userSerializer, name: 'User');
client.registerSerializer<List<Post>>(postListSerializer, name: 'List<Post>');

// Incorrect : Non sûr sur Flutter Web / --obfuscate
client.registerSerializer<User>(userSerializer); // name par défaut à User.toString()

// Incorrect : Non gérable à grande échelle
client.registerSerializer<User>(...);
client.registerSerializer<Post>(...);
client.registerSerializer<Comment>(...);
client.registerSerializer<Product>(...);
// 20 lignes de plus...
await client.hydrate();

// Pas d'import Qora : le modèle est entièrement portable
class User {
  final int id;
  final String name;

  const User({required this.id, required this.name});

  factory User.fromJson(dynamic json) {
    final map = json as Map<String, dynamic>;
    return User(id: map['id'] as int, name: map['name'] as String);
  }

  Map<String, dynamic> toJson() => {'id': id, 'name': name};
}

import 'package:qora/qora.dart';
import 'user.dart';

final userSerializer = QoraSerializer<User>(
  toJson: (u) => u.toJson(),
  fromJson: User.fromJson,
);

final userListSerializer = QoraSerializer<List<User>>(
  toJson: (list) => list.map((u) => u.toJson()).toList(),
  fromJson: (json) => (json as List).map(User.fromJson).toList(),
);

import 'package:qora/qora.dart';
import '../../features/user/models/user_serializer.dart';
import '../../features/post/models/post_serializer.dart';
import '../../features/product/models/product_serializer.dart';

void registerAllSerializers(PersistQoraClient client) {
  client.registerSerializer<User>(userSerializer, name: 'User');
  client.registerSerializer<List<User>>(userListSerializer, name: 'List<User>');
  client.registerSerializer<Post>(postSerializer, name: 'Post');
  client.registerSerializer<Product>(productSerializer, name: 'Product');
}

registerAllSerializers(client); // ← appel unique, quel que soit le nombre de modèles
await client.hydrate();
runApp(...);

import 'package:qora/qora.dart';

class User {
  // ...

  static const serializer = QoraSerializer<User>(
    toJson: _encode,
    fromJson: User.fromJson,
  );

  static Map<String, dynamic> _encode(User u) => u.toJson();
}

client.registerSerializer<User>(User.serializer, name: 'User');

import 'package:flutter/material.dart';
import 'package:qora_flutter/qora_flutter.dart';
import 'package:qora/qora.dart';

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

  final storage = InMemoryStorageAdapter(); // remplacer par HiveStorageAdapter()
  await storage.init();

  final client = PersistQoraClient(
    storage: storage,
    persistDuration: const Duration(days: 7),
    config: const QoraClientConfig(
      defaultOptions: QoraOptions(staleTime: Duration(minutes: 5)),
    ),
  );

  client.registerSerializer<User>(
    QoraSerializer(toJson: (u) => u.toJson(), fromJson: User.fromJson),
    name: 'User',
  );
  client.registerSerializer<List<Post>>(
    QoraSerializer(
      toJson: (posts) => posts.map((p) => p.toJson()).toList(),
      fromJson: (json)  => (json as List).map((e) => Post.fromJson(e)).toList(),
    ),
    name: 'List<Post>',
  );

  await client.hydrate(); // chauffer le cache depuis le disque

  runApp(
    QoraScope(
      client: client,
      lifecycleManager: FlutterLifecycleManager(qoraClient: client),
      child: const MyApp(),
    ),
  );
}

class PostsScreen extends StatelessWidget {
  const PostsScreen({super.key});

  @override
  Widget build(BuildContext context) {
    return QoraBuilder<List<Post>>(
      queryKey: ['posts'],
      fetcher: PostApi.fetchAll,
      // Si les données hydratées existent : affichées instantanément, pas de spinner.
      // Si périmées : affichées immédiatement pendant le refetch en arrière-plan.
      builder: (context, state, fetchStatus) => switch (state) {
        Initial() => const SizedBox.shrink(),
        Loading(previousData: null) => const CircularProgressIndicator(),
        Loading(:final previousData?) => PostList(previousData),
        Success(:final data) => PostList(data),
        Failure(:final error, previousData: null) => ErrorView('$error'),
        Failure(:final error, :final previousData?) => Column(children: [
            PostList(previousData),
            ErrorBanner('Rafraîchissement échoué : $error'),
          ]),
      },
    );
  }
}

Future<void> logout() async {
  await api.logout();

  // Vide le cache + le stockage de façon atomique (réinitialisation complète)
  client.clear(); 

  // Ou bien, vider seulement la mémoire et conserver le stockage persistant
  // client.clearCache();

  Navigator.pushReplacementNamed(context, '/login');
}