PeriodicSyncStrategy class

A reusable periodic synchronization strategy that separates technical implementation from business logic.

This strategy implements a periodic timer that orchestrates the sync process:

1. Push pending local events to remote
2. Pull remote events and apply them locally

Business logic (API calls, repository-specific rules) is provided through callbacks.

Example usage:

final strategy = PeriodicSyncStrategy(
  syncInterval: Duration(seconds: 5),
  repositoryNames: ['user', 'counter_log'],
  onFetchEvents: (repositoryName) async {
    // Fetch events from your API
    final response = await api.fetchEvents(repositoryName);
    return response.events;
  },
  onPushEvents: (repositoryName, events) async {
    // Push events to your API
    return await api.pushEvents(repositoryName, events);
  },
  onBuildSyncFilter: (repositoryName) async {
    // Return filter parameters based on last sync state
    final lastSeq = await storage.getLastSequence(repositoryName);
    return lastSeq != null ? {'afterSequence': lastSeq} : null;
  },
  onSaveSyncState: (repositoryName, events) async {
    // Save sync state after applying events
    if (events.isNotEmpty) {
      final maxSeq = events.map((e) => e['sequence']).reduce(max);
      await storage.saveLastSequence(repositoryName, maxSeq);
    }
  },
);

final client = LocalFirstClient(
  repositories: [userRepository, counterLogRepository],
  localStorage: SqliteLocalFirstStorage(),
  syncStrategies: [strategy],
);

await client.initialize();
await strategy.start();