Implementing Efficient Data Synchronization for Offline-First Mobile Applications

// Example: Local state management with eventual consistency
class OfflineDataManager {
  constructor(localDB, remoteAPI) {
    this.localDB = localDB;
    this.remoteAPI = remoteAPI;
    this.syncQueue = [];
  }

  async saveData(data) {
    // Step 1: Save to local database immediately
    const localRecord = await this.localDB.save({
      ...data,
      syncStatus: 'pending',
      localTimestamp: Date.now(),
      id: generateLocalId()
    });

    // Step 2: Update UI optimistically
    this.emit('dataChanged', localRecord);

    // Step 3: Queue for sync
    this.syncQueue.push({
      operation: 'CREATE',
      data: localRecord,
      retryCount: 0
    });

    // Step 4: Attempt sync if online
    if (this.isOnline()) {
      this.processSyncQueue();
    }

    return localRecord;
  }
}

javascript
// Strategy 1: Timestamp-based tracking
class TimestampTracker {
  async trackChange(record) {
    return {
      ...record,
      lastModified: Date.now(),
      deviceId: getDeviceId(),
      syncVersion: 0
    };
  }

  async getChangedRecords(lastSyncTime) {
    return this.localDB.query({
      where: { lastModified: { $gt: lastSyncTime } }
    });
  }
}

// Strategy 2: Operation log tracking
class OperationLog {
  async recordOperation(type, data, metadata) {
    const operation = {
      id: generateUUID(),
      type, // CREATE, UPDATE, DELETE
      data,
      timestamp: Date.now(),
      synced: false,
      metadata
    };

    await this.logDB.insert(operation);
    return operation;
  }

  async getUnsyncedOperations() {
    return this.logDB.query({
      where: { synced: false },
      orderBy: 'timestamp'
    });
  }
}

// Strategy 3: Version vector tracking
class VersionVector {
  constructor(deviceId) {
    this.deviceId = deviceId;
    this.vectors = {}; // { device1: 5, device2: 3 }
  }

  incrementLocal() {
    this.vectors[this.deviceId] = (this.vectors[this.deviceId] || 0) + 1;
    return this.vectors;
  }

  isNewer(otherVector) {
    // Compare vectors to determine if any changes are newer
    let hasNewer = false;

    // Check all known devices
    Object.keys({...this.vectors, ...otherVector}).forEach(deviceId => {
      const localVersion = this.vectors[deviceId] || 0;
     }
}
}