SaasFork Core

Bibliothèque centrale pour les applications développées avec SaasFork. Cette bibliothèque fournit des outils, utilitaires et modèles réutilisables dans tous vos projets.

Fonctionnalités principales

1. Système de journalisation (Logger)

Un système de journalisation unifié et configurable pour faciliter le débogage et le suivi d'événements.

Utilisation basique

import 'package:saasfork_core/saasfork_core.dart';

// Messages informatifs
log('Application démarrée');
Logger.info('Configuration chargée', tag: 'CONFIG');

// Avertissements
warn('Tentative de reconnexion', tag: 'NETWORK');
Logger.warn('Cache expiré');

// Erreurs
error('Échec de la synchronisation', 
      error: e, 
      stackTrace: stackTrace, 
      tag: 'SYNC');

Fonctionnalités du Logger

• Formatage automatique avec horodatage et niveau de priorité
• Catégorisation par tags
• Support complet des erreurs et stack traces
• Prêt à être connecté à des services distants comme Sentry ou Firebase Crashlytics

2. Modèles de données

Des modèles pour les entités communes dans les applications SaaS, avec sérialisation/désérialisation intégrée.

UserModel

Modèle pour représenter un utilisateur dans l'application :

final user = UserModel(
  uid: 'user123',
  email: 'user@example.com',
  username: 'johndoe',
  claims: UserClaims(role: Roles.admin)
);

// Vérifier si l'utilisateur est vide
if (user.isEmpty) {
  // Traitement pour utilisateur non initialisé
}

// Création d'une copie modifiée
final updatedUser = user.copyWith(username: 'newusername');

// Conversion vers/depuis JSON
final json = user.toJson();
final userFromJson = UserModel.fromJson(json);

// Conversion vers/depuis Map
final map = user.toMap();
final userFromMap = UserModel.fromMap(map);

UserClaims et gestion des rôles

Gestion des droits et rôles utilisateur :

// Rôles disponibles
enum Roles { visitor, user, admin, moderator }

// Création des claims
final claims = UserClaims(role: Roles.user);

// Modification des claims
final adminClaims = claims.copyWith(role: Roles.admin);

// Sérialisation/désérialisation
final jsonMap = claims.toJson(); // Retourne un Map<String, dynamic>
final claimsFromJson = UserClaims.fromJson(jsonMap);

3. Système de notification

Un système complet pour afficher des notifications à l'utilisateur, intégré avec Riverpod.

Types de notifications

enum NotificationType { error, success, info, warning }

Utilisation basique

import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:saasfork_core/saasfork_core.dart';

// Dans un widget ConsumerWidget ou ConsumerStatefulWidget
class MyWidget extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Accéder au contrôleur de notification
    final notifier = ref.read(notificationProvider.notifier);
    
    // Afficher différents types de notifications
    notifier.showSuccess('Opération réussie', title: 'Bravo');
    notifier.showError('Une erreur s\'est produite');
    notifier.showInfo('Information importante');
    notifier.showWarning('Attention', title: 'Avertissement');
    
    // Écouter l'état des notifications
    final notification = ref.watch(notificationProvider);
    if (notification.hasNotification) {
      // Traiter la notification (par exemple, afficher un toast ou une snackbar)
      
      // Effacer la notification après traitement
      notifier.clear();
    }
    
    return Container();
  }
}

4. Système de configuration

Un système de configuration centralisé qui permet de gérer les paramètres de l'application et les variables d'environnement.

Initialisation

import 'package:saasfork_core/saasfork_core.dart';

await SFConfig.initialize(
  envFilePath: '.env', // Chemin vers votre fichier .env
  defaultConfig: {
    'app.name': 'Mon Application',
    'app.version': '1.0.0',
    'api.url': 'https://api.example.com',
  },
  environment: 'dev', // ou 'prod', 'staging', etc.
);

Accès aux valeurs de configuration

// Accès à une valeur avec type spécifié et valeur par défaut
final appName = SFConfig.get<String>('app.name', defaultValue: 'Application');
final debugMode = SFConfig.get<bool>('app.debug', defaultValue: false);
final apiTimeout = SFConfig.get<int>('api.timeout', defaultValue: 30);

// Vérification de l'environnement courant
if (SFConfig.isDevelopment) {
  // Code spécifique à l'environnement de développement
}

if (SFConfig.isProduction) {
  // Code spécifique à l'environnement de production
}

// Obtenir l'environnement actuel
final env = SFConfig.environment; // 'dev', 'prod', etc.

Accès à une section de configuration

// Récupérer toutes les configurations commençant par 'api.'
final apiConfig = SFConfig.getSection('api');
// Résultat: { 'url': 'https://api.example.com', 'timeout': 30, ... }

// Utilisation
final apiUrl = apiConfig['url'] as String;

Intégration avec fichier .env

SFConfig se base sur flutter_dotenv pour charger les variables d'environnement à partir d'un fichier .env:

# Exemple de fichier .env
APP_NAME=Mon Application
APP_VERSION=1.0.0
API_URL=https://api.exemple.com
DEBUG_MODE=true

Ces variables seront disponibles via SFConfig, avec conversion automatique des types pour les booléens, entiers et nombres à virgule flottante.

Exemple pratique avec AppConfig

Créez une classe wrapper pour centraliser la configuration de votre application:

class AppConfig {
  static T? get<T>(String key, {T? defaultValue}) {
    return SFConfig.get<T>(key, defaultValue: defaultValue);
  }

  static Map<String, dynamic> getDefaultConfig() {
    return {'app.name': 'Clink2Pay', 'app.version': '1.0.0'};
  }

  static Future<void> initialize({String environment = 'dev'}) async {
    final defaultConfig = getDefaultConfig();

    if (defaultConfig.containsKey(environment)) {
      final envSpecificConfig =
          defaultConfig[environment] as Map<String, dynamic>;

      // Remplacer les valeurs par défaut
      defaultConfig.addAll(envSpecificConfig);

      // Supprimer la section d'environnement après fusion
      defaultConfig.remove(environment);
      defaultConfig.remove('dev');
      defaultConfig.remove('prod');
    }

    await SFConfig.initialize(
      envFilePath: '.env',
      defaultConfig: defaultConfig,
      environment: environment,
    );
  }
}

Utilisation dans votre application:

// Initialiser au démarrage de l'application
await AppConfig.initialize(environment: 'prod');

// Accéder aux valeurs de configuration
final appName = AppConfig.get<String>('app.name');
final isDebug = AppConfig.get<bool>('app.debug', defaultValue: false);

Web Functions Utilities

The web_functions.dart utility provides a set of helper functions for web-specific operations.

getLocalhostUrl()

Retrieves the current URL (protocol, hostname, and port) in a web environment.

String url = getLocalhostUrl();