feat(sync): add cross-platform sync managers for iOS, Android, and Web
- iOS: PlatformSyncManager — URLSession, delta sync, batch upload, offline queue, HMAC auth - Android: PlatformApiClient + SyncRepository — HttpURLConnection, Room integration, offline queue - Web: platform-sync.ts + use-sync.ts — fetch client, localStorage queue, React hook with 60s auto-sync All consume platform-service /timers/*, /routines/*, /households/* endpoints. Sync protocol: syncVersion optimistic concurrency, delta sync via ?since=, batch upsert for offline flush.
This commit is contained in:
saravanakumardb1
parent
8b6f44ac9a
commit
af33a2c86d
@ -0,0 +1,180 @@
|
|||||||
|
package com.chronomind.app.sync
|
||||||
|
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import java.io.OutputStreamWriter
|
||||||
|
import java.net.HttpURLConnection
|
||||||
|
import java.net.URL
|
||||||
|
|
||||||
|
// ── DTOs ──────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class SyncTimerDTO(
|
||||||
|
val id: String,
|
||||||
|
val label: String,
|
||||||
|
val description: String? = null,
|
||||||
|
val type: String,
|
||||||
|
val state: String,
|
||||||
|
val urgency: String,
|
||||||
|
val duration: Double,
|
||||||
|
val targetTime: String,
|
||||||
|
val createdAt: String,
|
||||||
|
val startedAt: String? = null,
|
||||||
|
val pausedAt: String? = null,
|
||||||
|
val firedAt: String? = null,
|
||||||
|
val completedAt: String? = null,
|
||||||
|
val cascade: CascadeDTO? = null,
|
||||||
|
val pomodoro: PomodoroDTO? = null,
|
||||||
|
val isCalendarSync: Boolean = false,
|
||||||
|
val category: String? = null,
|
||||||
|
val syncVersion: Int = 1
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class CascadeDTO(
|
||||||
|
val preset: String,
|
||||||
|
val intervals: List<Int>
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class PomodoroDTO(
|
||||||
|
val focusMinutes: Int,
|
||||||
|
val shortBreakMinutes: Int,
|
||||||
|
val longBreakMinutes: Int,
|
||||||
|
val roundsBeforeLong: Int,
|
||||||
|
val currentRound: Int = 1,
|
||||||
|
val isBreak: Boolean = false,
|
||||||
|
val totalRoundsCompleted: Int = 0
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class UpdateTimerDTO(
|
||||||
|
val state: String? = null,
|
||||||
|
val pausedAt: String? = null,
|
||||||
|
val firedAt: String? = null,
|
||||||
|
val completedAt: String? = null,
|
||||||
|
val syncVersion: Int = 1
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class BatchRequest(val timers: List<SyncTimerDTO>)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class BatchResult(
|
||||||
|
val synced: List<String> = emptyList(),
|
||||||
|
val conflicts: List<SyncConflict> = emptyList(),
|
||||||
|
val errors: List<String> = emptyList()
|
||||||
|
)
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class SyncConflict(val id: String, val serverVersion: Int)
|
||||||
|
|
||||||
|
// ── API Client ────────────────────────────────────────────────
|
||||||
|
|
||||||
|
class PlatformApiClient(
|
||||||
|
private val baseUrl: String = "https://api.chronomind.app",
|
||||||
|
private var authToken: String? = null
|
||||||
|
) {
|
||||||
|
private val json = Json { ignoreUnknownKeys = true; encodeDefaults = true }
|
||||||
|
|
||||||
|
fun setAuthToken(token: String?) { authToken = token }
|
||||||
|
|
||||||
|
// GET /timers/sync?since=<ISO>
|
||||||
|
fun pullDelta(since: String?): List<SyncTimerDTO> {
|
||||||
|
val url = if (since != null) "$baseUrl/timers/sync?since=$since" else "$baseUrl/timers/sync"
|
||||||
|
val response = get(url)
|
||||||
|
return json.decodeFromString(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
// POST /timers
|
||||||
|
fun createTimer(dto: SyncTimerDTO): SyncTimerDTO {
|
||||||
|
val body = json.encodeToString(SyncTimerDTO.serializer(), dto)
|
||||||
|
val response = post("$baseUrl/timers", body)
|
||||||
|
return json.decodeFromString(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
// PUT /timers/:id
|
||||||
|
fun updateTimer(id: String, dto: UpdateTimerDTO): SyncTimerDTO {
|
||||||
|
val body = json.encodeToString(UpdateTimerDTO.serializer(), dto)
|
||||||
|
val response = put("$baseUrl/timers/$id", body)
|
||||||
|
return json.decodeFromString(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
// DELETE /timers/:id
|
||||||
|
fun deleteTimer(id: String) {
|
||||||
|
delete("$baseUrl/timers/$id")
|
||||||
|
}
|
||||||
|
|
||||||
|
// POST /timers/batch
|
||||||
|
fun batchUpsert(timers: List<SyncTimerDTO>): BatchResult {
|
||||||
|
val body = json.encodeToString(BatchRequest.serializer(), BatchRequest(timers))
|
||||||
|
val response = post("$baseUrl/timers/batch", body)
|
||||||
|
return json.decodeFromString(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
// GET /routines/sync?since=<ISO>
|
||||||
|
fun pullRoutinesDelta(since: String?): String {
|
||||||
|
val url = if (since != null) "$baseUrl/routines/sync?since=$since" else "$baseUrl/routines/sync"
|
||||||
|
return get(url)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── HTTP helpers ──────────────────────────────────────────
|
||||||
|
|
||||||
|
private fun get(url: String): String {
|
||||||
|
val conn = openConnection(url, "GET")
|
||||||
|
return readResponse(conn)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun post(url: String, body: String): String {
|
||||||
|
val conn = openConnection(url, "POST")
|
||||||
|
writeBody(conn, body)
|
||||||
|
return readResponse(conn)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun put(url: String, body: String): String {
|
||||||
|
val conn = openConnection(url, "PUT")
|
||||||
|
writeBody(conn, body)
|
||||||
|
return readResponse(conn)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun delete(url: String) {
|
||||||
|
val conn = openConnection(url, "DELETE")
|
||||||
|
val code = conn.responseCode
|
||||||
|
conn.disconnect()
|
||||||
|
if (code !in 200..299) throw SyncException("DELETE failed: $code")
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun openConnection(url: String, method: String): HttpURLConnection {
|
||||||
|
val conn = URL(url).openConnection() as HttpURLConnection
|
||||||
|
conn.requestMethod = method
|
||||||
|
conn.setRequestProperty("Content-Type", "application/json")
|
||||||
|
conn.setRequestProperty("x-request-id", java.util.UUID.randomUUID().toString())
|
||||||
|
conn.connectTimeout = 15_000
|
||||||
|
conn.readTimeout = 15_000
|
||||||
|
authToken?.let { conn.setRequestProperty("Authorization", "Bearer $it") }
|
||||||
|
return conn
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun writeBody(conn: HttpURLConnection, body: String) {
|
||||||
|
conn.doOutput = true
|
||||||
|
OutputStreamWriter(conn.outputStream, Charsets.UTF_8).use { it.write(body) }
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun readResponse(conn: HttpURLConnection): String {
|
||||||
|
val code = conn.responseCode
|
||||||
|
if (code == 409) {
|
||||||
|
conn.disconnect()
|
||||||
|
throw SyncConflictException("Conflict: server has newer version")
|
||||||
|
}
|
||||||
|
if (code !in 200..299) {
|
||||||
|
conn.disconnect()
|
||||||
|
throw SyncException("HTTP $code")
|
||||||
|
}
|
||||||
|
val response = conn.inputStream.bufferedReader().use { it.readText() }
|
||||||
|
conn.disconnect()
|
||||||
|
return response
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class SyncException(message: String) : Exception(message)
|
||||||
|
class SyncConflictException(message: String) : Exception(message)
|
||||||
@ -0,0 +1,245 @@
|
|||||||
|
package com.chronomind.app.sync
|
||||||
|
|
||||||
|
import android.content.Context
|
||||||
|
import android.content.SharedPreferences
|
||||||
|
import com.chronomind.app.data.TimerDao
|
||||||
|
import com.chronomind.app.data.TimerEntity
|
||||||
|
import com.chronomind.app.data.toEntity
|
||||||
|
import com.chronomind.app.data.toTimer
|
||||||
|
import com.chronomind.app.engine.*
|
||||||
|
import dagger.hilt.android.qualifiers.ApplicationContext
|
||||||
|
import kotlinx.coroutines.Dispatchers
|
||||||
|
import kotlinx.coroutines.flow.MutableStateFlow
|
||||||
|
import kotlinx.coroutines.flow.StateFlow
|
||||||
|
import kotlinx.coroutines.withContext
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
|
import kotlinx.serialization.encodeToString
|
||||||
|
import kotlinx.serialization.json.Json
|
||||||
|
import java.text.SimpleDateFormat
|
||||||
|
import java.util.*
|
||||||
|
import javax.inject.Inject
|
||||||
|
import javax.inject.Singleton
|
||||||
|
|
||||||
|
// ── Offline Queue Item ────────────────────────────────────────
|
||||||
|
|
||||||
|
@Serializable
|
||||||
|
data class OfflineQueueItem(
|
||||||
|
val id: String,
|
||||||
|
val action: String, // "create", "update", "delete"
|
||||||
|
val timer: SyncTimerDTO? = null,
|
||||||
|
val enqueuedAt: String
|
||||||
|
)
|
||||||
|
|
||||||
|
// ── Sync Repository ───────────────────────────────────────────
|
||||||
|
|
||||||
|
@Singleton
|
||||||
|
class SyncRepository @Inject constructor(
|
||||||
|
@ApplicationContext private val context: Context,
|
||||||
|
private val timerDao: TimerDao
|
||||||
|
) {
|
||||||
|
private val prefs: SharedPreferences = context.getSharedPreferences("chronomind_sync", Context.MODE_PRIVATE)
|
||||||
|
private val api = PlatformApiClient()
|
||||||
|
private val json = Json { ignoreUnknownKeys = true; encodeDefaults = true }
|
||||||
|
private val isoFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.US).apply {
|
||||||
|
timeZone = TimeZone.getTimeZone("UTC")
|
||||||
|
}
|
||||||
|
|
||||||
|
private val _isSyncing = MutableStateFlow(false)
|
||||||
|
val isSyncing: StateFlow<Boolean> = _isSyncing
|
||||||
|
|
||||||
|
private val _pendingChanges = MutableStateFlow(0)
|
||||||
|
val pendingChanges: StateFlow<Int> = _pendingChanges
|
||||||
|
|
||||||
|
private val _lastError = MutableStateFlow<String?>(null)
|
||||||
|
val lastError: StateFlow<String?> = _lastError
|
||||||
|
|
||||||
|
var syncEnabled: Boolean
|
||||||
|
get() = prefs.getBoolean("sync_enabled", false)
|
||||||
|
set(value) = prefs.edit().putBoolean("sync_enabled", value).apply()
|
||||||
|
|
||||||
|
var lastSyncDate: String?
|
||||||
|
get() = prefs.getString("last_sync", null)
|
||||||
|
private set(value) = prefs.edit().putString("last_sync", value).apply()
|
||||||
|
|
||||||
|
init {
|
||||||
|
_pendingChanges.value = loadOfflineQueue().size
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Auth
|
||||||
|
|
||||||
|
fun setAuthToken(token: String?) {
|
||||||
|
api.setAuthToken(token)
|
||||||
|
prefs.edit().putString("auth_token", token).apply()
|
||||||
|
}
|
||||||
|
|
||||||
|
fun restoreAuthToken() {
|
||||||
|
val token = prefs.getString("auth_token", null)
|
||||||
|
if (token != null) api.setAuthToken(token)
|
||||||
|
}
|
||||||
|
|
||||||
|
val isAuthenticated: Boolean get() = prefs.getString("auth_token", null) != null
|
||||||
|
|
||||||
|
// MARK: - Full Sync
|
||||||
|
|
||||||
|
suspend fun sync(): SyncResult = withContext(Dispatchers.IO) {
|
||||||
|
if (!syncEnabled || !isAuthenticated) {
|
||||||
|
return@withContext SyncResult(emptyList(), emptyList(), "Not authenticated or sync disabled")
|
||||||
|
}
|
||||||
|
|
||||||
|
_isSyncing.value = true
|
||||||
|
_lastError.value = null
|
||||||
|
|
||||||
|
try {
|
||||||
|
// 1. Pull delta
|
||||||
|
val pulled = api.pullDelta(lastSyncDate)
|
||||||
|
|
||||||
|
// 2. Merge pulled timers into Room
|
||||||
|
for (dto in pulled) {
|
||||||
|
val entity = dtoToEntity(dto)
|
||||||
|
timerDao.upsert(entity)
|
||||||
|
}
|
||||||
|
|
||||||
|
// 3. Push offline queue
|
||||||
|
val queue = loadOfflineQueue()
|
||||||
|
var conflicts = emptyList<SyncConflict>()
|
||||||
|
if (queue.isNotEmpty()) {
|
||||||
|
val timersToSync = queue.mapNotNull { it.timer }
|
||||||
|
if (timersToSync.isNotEmpty()) {
|
||||||
|
val result = api.batchUpsert(timersToSync)
|
||||||
|
conflicts = result.conflicts
|
||||||
|
clearSyncedFromQueue(result.synced)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 4. Update last sync
|
||||||
|
lastSyncDate = isoFormat.format(Date())
|
||||||
|
_pendingChanges.value = loadOfflineQueue().size
|
||||||
|
|
||||||
|
SyncResult(pulled, conflicts, null)
|
||||||
|
} catch (e: Exception) {
|
||||||
|
_lastError.value = e.message
|
||||||
|
SyncResult(emptyList(), emptyList(), e.message)
|
||||||
|
} finally {
|
||||||
|
_isSyncing.value = false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Enqueue Changes
|
||||||
|
|
||||||
|
fun enqueueCreate(timer: CMTimer) {
|
||||||
|
val dto = timerToDTO(timer)
|
||||||
|
enqueue(OfflineQueueItem(timer.id, "create", dto, isoFormat.format(Date())))
|
||||||
|
}
|
||||||
|
|
||||||
|
fun enqueueUpdate(timer: CMTimer) {
|
||||||
|
val dto = timerToDTO(timer)
|
||||||
|
enqueue(OfflineQueueItem(timer.id, "update", dto, isoFormat.format(Date())))
|
||||||
|
}
|
||||||
|
|
||||||
|
fun enqueueDelete(timerId: String) {
|
||||||
|
enqueue(OfflineQueueItem(timerId, "delete", null, isoFormat.format(Date())))
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Offline Queue Persistence
|
||||||
|
|
||||||
|
private fun enqueue(item: OfflineQueueItem) {
|
||||||
|
val queue = loadOfflineQueue().toMutableList()
|
||||||
|
queue.removeAll { it.id == item.id }
|
||||||
|
queue.add(item)
|
||||||
|
saveOfflineQueue(queue)
|
||||||
|
_pendingChanges.value = queue.size
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun loadOfflineQueue(): List<OfflineQueueItem> {
|
||||||
|
val raw = prefs.getString("offline_queue", null) ?: return emptyList()
|
||||||
|
return try {
|
||||||
|
json.decodeFromString(raw)
|
||||||
|
} catch (_: Exception) {
|
||||||
|
emptyList()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun saveOfflineQueue(queue: List<OfflineQueueItem>) {
|
||||||
|
prefs.edit().putString("offline_queue", json.encodeToString(queue)).apply()
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun clearSyncedFromQueue(syncedIds: List<String>) {
|
||||||
|
val queue = loadOfflineQueue().toMutableList()
|
||||||
|
queue.removeAll { syncedIds.contains(it.id) }
|
||||||
|
saveOfflineQueue(queue)
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - DTO Conversion
|
||||||
|
|
||||||
|
private fun timerToDTO(timer: CMTimer): SyncTimerDTO {
|
||||||
|
return SyncTimerDTO(
|
||||||
|
id = timer.id,
|
||||||
|
label = timer.label,
|
||||||
|
description = timer.description,
|
||||||
|
type = timer.type.name.lowercase(),
|
||||||
|
state = timer.state.name.lowercase(),
|
||||||
|
urgency = timer.urgency.name.lowercase(),
|
||||||
|
duration = timer.duration,
|
||||||
|
targetTime = isoFormat.format(timer.targetTime),
|
||||||
|
createdAt = isoFormat.format(timer.createdAt),
|
||||||
|
startedAt = timer.startedAt?.let { isoFormat.format(it) },
|
||||||
|
pausedAt = timer.pausedAt?.let { isoFormat.format(it) },
|
||||||
|
firedAt = timer.firedAt?.let { isoFormat.format(it) },
|
||||||
|
completedAt = timer.completedAt?.let { isoFormat.format(it) },
|
||||||
|
cascade = if (timer.cascade.intervals.isNotEmpty()) CascadeDTO(
|
||||||
|
preset = timer.cascade.preset.name.lowercase(),
|
||||||
|
intervals = timer.cascade.intervals
|
||||||
|
) else null,
|
||||||
|
pomodoro = timer.pomodoro?.let { pom ->
|
||||||
|
PomodoroDTO(
|
||||||
|
focusMinutes = pom.focusMinutes,
|
||||||
|
shortBreakMinutes = pom.shortBreakMinutes,
|
||||||
|
longBreakMinutes = pom.longBreakMinutes,
|
||||||
|
roundsBeforeLong = pom.roundsBeforeLong,
|
||||||
|
currentRound = pom.currentRound,
|
||||||
|
isBreak = pom.isBreak,
|
||||||
|
totalRoundsCompleted = pom.totalRoundsCompleted
|
||||||
|
)
|
||||||
|
},
|
||||||
|
category = timer.category,
|
||||||
|
syncVersion = 1
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun dtoToEntity(dto: SyncTimerDTO): TimerEntity {
|
||||||
|
return TimerEntity(
|
||||||
|
id = dto.id,
|
||||||
|
label = dto.label,
|
||||||
|
description = dto.description,
|
||||||
|
type = dto.type,
|
||||||
|
state = dto.state,
|
||||||
|
urgency = dto.urgency,
|
||||||
|
duration = dto.duration,
|
||||||
|
targetTime = parseIso(dto.targetTime),
|
||||||
|
createdAt = parseIso(dto.createdAt),
|
||||||
|
startedAt = dto.startedAt?.let { parseIso(it) },
|
||||||
|
pausedAt = dto.pausedAt?.let { parseIso(it) },
|
||||||
|
firedAt = dto.firedAt?.let { parseIso(it) },
|
||||||
|
completedAt = dto.completedAt?.let { parseIso(it) },
|
||||||
|
cascadePreset = dto.cascade?.preset,
|
||||||
|
cascadeIntervalsJson = dto.cascade?.intervals?.let { json.encodeToString(it) },
|
||||||
|
pomodoroJson = dto.pomodoro?.let { json.encodeToString(it) },
|
||||||
|
warningsJson = null,
|
||||||
|
isCalendarSync = dto.isCalendarSync,
|
||||||
|
calendarEventId = null,
|
||||||
|
category = dto.category
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun parseIso(str: String): Long {
|
||||||
|
return try { isoFormat.parse(str)?.time ?: 0L } catch (_: Exception) { 0L }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Sync Result
|
||||||
|
|
||||||
|
data class SyncResult(
|
||||||
|
val pulled: List<SyncTimerDTO>,
|
||||||
|
val conflicts: List<SyncConflict>,
|
||||||
|
val error: String?
|
||||||
|
)
|
||||||
449
ios/ChronoMind/Shared/Cloud/PlatformSyncManager.swift
Normal file
449
ios/ChronoMind/Shared/Cloud/PlatformSyncManager.swift
Normal file
@ -0,0 +1,449 @@
|
|||||||
|
// ── Platform Sync Manager ─────────────────────────────────────
|
||||||
|
// Cross-platform sync via platform-service REST API
|
||||||
|
// Replaces iCloud KV store with proper delta sync + conflict resolution
|
||||||
|
// Endpoints: /timers, /timers/sync, /timers/batch, /routines/*
|
||||||
|
|
||||||
|
import Foundation
|
||||||
|
import Combine
|
||||||
|
|
||||||
|
@MainActor
|
||||||
|
final class PlatformSyncManager: ObservableObject {
|
||||||
|
static let shared = PlatformSyncManager()
|
||||||
|
|
||||||
|
// MARK: - Published State
|
||||||
|
|
||||||
|
@Published var isSyncing = false
|
||||||
|
@Published var lastSyncDate: Date?
|
||||||
|
@Published var syncEnabled: Bool {
|
||||||
|
didSet {
|
||||||
|
UserDefaults.standard.set(syncEnabled, forKey: Keys.syncEnabled)
|
||||||
|
if syncEnabled { schedulePeriodicSync() } else { cancelPeriodicSync() }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
@Published var pendingChanges: Int = 0
|
||||||
|
@Published var lastError: String?
|
||||||
|
|
||||||
|
// MARK: - Config
|
||||||
|
|
||||||
|
private let baseURL: String
|
||||||
|
private let session: URLSession
|
||||||
|
private var authToken: String?
|
||||||
|
private var syncTask: Task<Void, Never>?
|
||||||
|
private let encoder: JSONEncoder
|
||||||
|
private let decoder: JSONDecoder
|
||||||
|
|
||||||
|
private struct Keys {
|
||||||
|
static let syncEnabled = "chronomind-platform-sync-enabled"
|
||||||
|
static let lastSync = "chronomind-platform-last-sync"
|
||||||
|
static let offlineQueue = "chronomind-offline-queue"
|
||||||
|
static let authToken = "chronomind-auth-token"
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Init
|
||||||
|
|
||||||
|
private init() {
|
||||||
|
// Default to localhost for dev; production URL via Info.plist or env
|
||||||
|
baseURL = Bundle.main.object(forInfoDictionaryKey: "PLATFORM_SERVICE_URL") as? String
|
||||||
|
?? "https://api.chronomind.app"
|
||||||
|
|
||||||
|
let config = URLSessionConfiguration.default
|
||||||
|
config.timeoutIntervalForRequest = 15
|
||||||
|
config.waitsForConnectivity = true
|
||||||
|
session = URLSession(configuration: config)
|
||||||
|
|
||||||
|
encoder = JSONEncoder()
|
||||||
|
encoder.dateEncodingStrategy = .iso8601
|
||||||
|
|
||||||
|
decoder = JSONDecoder()
|
||||||
|
decoder.dateDecodingStrategy = .iso8601
|
||||||
|
|
||||||
|
syncEnabled = UserDefaults.standard.bool(forKey: Keys.syncEnabled)
|
||||||
|
authToken = UserDefaults.standard.string(forKey: Keys.authToken)
|
||||||
|
|
||||||
|
if let date = UserDefaults.standard.object(forKey: Keys.lastSync) as? Date {
|
||||||
|
lastSyncDate = date
|
||||||
|
}
|
||||||
|
|
||||||
|
loadOfflineQueue()
|
||||||
|
|
||||||
|
if syncEnabled {
|
||||||
|
schedulePeriodicSync()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Auth
|
||||||
|
|
||||||
|
func setAuthToken(_ token: String?) {
|
||||||
|
authToken = token
|
||||||
|
if let token = token {
|
||||||
|
UserDefaults.standard.set(token, forKey: Keys.authToken)
|
||||||
|
} else {
|
||||||
|
UserDefaults.standard.removeObject(forKey: Keys.authToken)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var isAuthenticated: Bool { authToken != nil }
|
||||||
|
|
||||||
|
// MARK: - Sync Operations
|
||||||
|
|
||||||
|
/// Full delta sync: pull changes since last sync, push local changes
|
||||||
|
func sync(localTimers: [CMTimer]) async -> SyncResult {
|
||||||
|
guard syncEnabled, isAuthenticated else {
|
||||||
|
return SyncResult(pulled: [], conflicts: [], error: "Not authenticated or sync disabled")
|
||||||
|
}
|
||||||
|
|
||||||
|
isSyncing = true
|
||||||
|
lastError = nil
|
||||||
|
defer { isSyncing = false }
|
||||||
|
|
||||||
|
do {
|
||||||
|
// 1. Pull remote changes since last sync
|
||||||
|
let pulled = try await pullDelta()
|
||||||
|
|
||||||
|
// 2. Push local offline queue
|
||||||
|
let batchResult = try await pushOfflineQueue()
|
||||||
|
|
||||||
|
// 3. Update last sync timestamp
|
||||||
|
lastSyncDate = Date()
|
||||||
|
UserDefaults.standard.set(lastSyncDate, forKey: Keys.lastSync)
|
||||||
|
|
||||||
|
return SyncResult(
|
||||||
|
pulled: pulled,
|
||||||
|
conflicts: batchResult.conflicts,
|
||||||
|
error: nil
|
||||||
|
)
|
||||||
|
} catch {
|
||||||
|
lastError = error.localizedDescription
|
||||||
|
return SyncResult(pulled: [], conflicts: [], error: error.localizedDescription)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Pull timers modified since last sync
|
||||||
|
func pullDelta() async throws -> [SyncTimerDTO] {
|
||||||
|
var urlString = "\(baseURL)/timers/sync"
|
||||||
|
if let lastSync = lastSyncDate {
|
||||||
|
let iso = ISO8601DateFormatter().string(from: lastSync)
|
||||||
|
urlString += "?since=\(iso)"
|
||||||
|
}
|
||||||
|
|
||||||
|
guard let url = URL(string: urlString) else {
|
||||||
|
throw SyncError.invalidURL
|
||||||
|
}
|
||||||
|
|
||||||
|
let (data, response) = try await authenticatedRequest(url: url, method: "GET")
|
||||||
|
try validateResponse(response)
|
||||||
|
return try decoder.decode([SyncTimerDTO].self, from: data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Push a single timer change to the server
|
||||||
|
func pushTimer(_ timer: CMTimer) async throws -> SyncTimerDTO {
|
||||||
|
guard let url = URL(string: "\(baseURL)/timers") else {
|
||||||
|
throw SyncError.invalidURL
|
||||||
|
}
|
||||||
|
|
||||||
|
let dto = timerToDTO(timer)
|
||||||
|
let body = try encoder.encode(dto)
|
||||||
|
let (data, response) = try await authenticatedRequest(url: url, method: "POST", body: body)
|
||||||
|
try validateResponse(response)
|
||||||
|
return try decoder.decode(SyncTimerDTO.self, from: data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Update an existing timer on the server
|
||||||
|
func updateTimer(_ timer: CMTimer, syncVersion: Int) async throws -> SyncTimerDTO {
|
||||||
|
guard let url = URL(string: "\(baseURL)/timers/\(timer.id)") else {
|
||||||
|
throw SyncError.invalidURL
|
||||||
|
}
|
||||||
|
|
||||||
|
var dto = timerToUpdateDTO(timer)
|
||||||
|
dto.syncVersion = syncVersion
|
||||||
|
let body = try encoder.encode(dto)
|
||||||
|
let (data, response) = try await authenticatedRequest(url: url, method: "PUT", body: body)
|
||||||
|
|
||||||
|
if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 409 {
|
||||||
|
throw SyncError.conflict
|
||||||
|
}
|
||||||
|
|
||||||
|
try validateResponse(response)
|
||||||
|
return try decoder.decode(SyncTimerDTO.self, from: data)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Delete a timer on the server
|
||||||
|
func deleteTimer(id: String) async throws {
|
||||||
|
guard let url = URL(string: "\(baseURL)/timers/\(id)") else {
|
||||||
|
throw SyncError.invalidURL
|
||||||
|
}
|
||||||
|
|
||||||
|
let (_, response) = try await authenticatedRequest(url: url, method: "DELETE")
|
||||||
|
try validateResponse(response)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Batch upsert (flush offline queue)
|
||||||
|
func pushOfflineQueue() async throws -> BatchResult {
|
||||||
|
let queue = loadOfflineQueueItems()
|
||||||
|
guard !queue.isEmpty else {
|
||||||
|
return BatchResult(synced: [], conflicts: [], errors: [])
|
||||||
|
}
|
||||||
|
|
||||||
|
guard let url = URL(string: "\(baseURL)/timers/batch") else {
|
||||||
|
throw SyncError.invalidURL
|
||||||
|
}
|
||||||
|
|
||||||
|
let body = try encoder.encode(["timers": queue])
|
||||||
|
let (data, response) = try await authenticatedRequest(url: url, method: "POST", body: body)
|
||||||
|
try validateResponse(response)
|
||||||
|
|
||||||
|
let result = try decoder.decode(BatchResult.self, from: data)
|
||||||
|
|
||||||
|
// Clear synced items from queue
|
||||||
|
clearOfflineQueue(syncedIds: result.synced)
|
||||||
|
pendingChanges = loadOfflineQueueItems().count
|
||||||
|
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Offline Queue
|
||||||
|
|
||||||
|
func enqueueChange(_ timer: CMTimer, action: OfflineAction) {
|
||||||
|
var queue = loadOfflineQueueItems()
|
||||||
|
// Replace existing entry for same timer ID
|
||||||
|
queue.removeAll { $0.id == timer.id }
|
||||||
|
queue.append(OfflineQueueItem(
|
||||||
|
id: timer.id,
|
||||||
|
action: action,
|
||||||
|
timer: timerToDTO(timer),
|
||||||
|
enqueuedAt: Date()
|
||||||
|
))
|
||||||
|
saveOfflineQueue(queue)
|
||||||
|
pendingChanges = queue.count
|
||||||
|
}
|
||||||
|
|
||||||
|
func enqueueDelete(timerId: String) {
|
||||||
|
var queue = loadOfflineQueueItems()
|
||||||
|
queue.removeAll { $0.id == timerId }
|
||||||
|
queue.append(OfflineQueueItem(
|
||||||
|
id: timerId,
|
||||||
|
action: .delete,
|
||||||
|
timer: nil,
|
||||||
|
enqueuedAt: Date()
|
||||||
|
))
|
||||||
|
saveOfflineQueue(queue)
|
||||||
|
pendingChanges = queue.count
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Periodic Sync
|
||||||
|
|
||||||
|
private func schedulePeriodicSync() {
|
||||||
|
cancelPeriodicSync()
|
||||||
|
syncTask = Task { [weak self] in
|
||||||
|
while !Task.isCancelled {
|
||||||
|
try? await Task.sleep(nanoseconds: 60 * 1_000_000_000) // 60 seconds
|
||||||
|
guard let self = self, self.syncEnabled else { break }
|
||||||
|
_ = await self.sync(localTimers: [])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private func cancelPeriodicSync() {
|
||||||
|
syncTask?.cancel()
|
||||||
|
syncTask = nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Network Helpers
|
||||||
|
|
||||||
|
private func authenticatedRequest(url: URL, method: String, body: Data? = nil) async throws -> (Data, URLResponse) {
|
||||||
|
var request = URLRequest(url: url)
|
||||||
|
request.httpMethod = method
|
||||||
|
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
|
||||||
|
request.setValue(UUID().uuidString, forHTTPHeaderField: "x-request-id")
|
||||||
|
|
||||||
|
if let token = authToken {
|
||||||
|
request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
|
||||||
|
}
|
||||||
|
|
||||||
|
if let body = body {
|
||||||
|
request.httpBody = body
|
||||||
|
}
|
||||||
|
|
||||||
|
return try await session.data(for: request)
|
||||||
|
}
|
||||||
|
|
||||||
|
private func validateResponse(_ response: URLResponse) throws {
|
||||||
|
guard let http = response as? HTTPURLResponse else {
|
||||||
|
throw SyncError.invalidResponse
|
||||||
|
}
|
||||||
|
guard (200...299).contains(http.statusCode) else {
|
||||||
|
throw SyncError.httpError(http.statusCode)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Offline Queue Persistence
|
||||||
|
|
||||||
|
private func loadOfflineQueue() {
|
||||||
|
pendingChanges = loadOfflineQueueItems().count
|
||||||
|
}
|
||||||
|
|
||||||
|
private func loadOfflineQueueItems() -> [OfflineQueueItem] {
|
||||||
|
guard let data = UserDefaults.standard.data(forKey: Keys.offlineQueue) else { return [] }
|
||||||
|
return (try? JSONDecoder().decode([OfflineQueueItem].self, from: data)) ?? []
|
||||||
|
}
|
||||||
|
|
||||||
|
private func saveOfflineQueue(_ queue: [OfflineQueueItem]) {
|
||||||
|
if let data = try? JSONEncoder().encode(queue) {
|
||||||
|
UserDefaults.standard.set(data, forKey: Keys.offlineQueue)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private func clearOfflineQueue(syncedIds: [String]) {
|
||||||
|
var queue = loadOfflineQueueItems()
|
||||||
|
queue.removeAll { syncedIds.contains($0.id) }
|
||||||
|
saveOfflineQueue(queue)
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - DTO Conversion
|
||||||
|
|
||||||
|
private func timerToDTO(_ timer: CMTimer) -> SyncTimerDTO {
|
||||||
|
SyncTimerDTO(
|
||||||
|
id: timer.id,
|
||||||
|
label: timer.label,
|
||||||
|
description: timer.description,
|
||||||
|
type: timer.type.rawValue,
|
||||||
|
state: timer.state.rawValue,
|
||||||
|
urgency: timer.urgency.rawValue,
|
||||||
|
duration: timer.duration ?? 0,
|
||||||
|
targetTime: timer.targetTime,
|
||||||
|
createdAt: timer.createdAt,
|
||||||
|
startedAt: timer.startedAt,
|
||||||
|
pausedAt: timer.pausedAt,
|
||||||
|
firedAt: timer.firedAt,
|
||||||
|
completedAt: timer.completedAt,
|
||||||
|
cascade: timer.cascade.intervals.isEmpty ? nil : CascadeDTO(
|
||||||
|
preset: timer.cascade.preset.rawValue,
|
||||||
|
intervals: timer.cascade.intervals
|
||||||
|
),
|
||||||
|
pomodoro: timer.pomodoroConfig.map { config in
|
||||||
|
PomodoroDTO(
|
||||||
|
focusMinutes: config.workMinutes,
|
||||||
|
shortBreakMinutes: config.breakMinutes,
|
||||||
|
longBreakMinutes: config.longBreakMinutes,
|
||||||
|
roundsBeforeLong: config.rounds,
|
||||||
|
currentRound: timer.pomodoroState?.currentRound ?? 1,
|
||||||
|
isBreak: timer.pomodoroState?.isBreak ?? false,
|
||||||
|
totalRoundsCompleted: timer.pomodoroState?.completedRounds ?? 0
|
||||||
|
)
|
||||||
|
},
|
||||||
|
isCalendarSync: false,
|
||||||
|
category: timer.category,
|
||||||
|
syncVersion: 1
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private func timerToUpdateDTO(_ timer: CMTimer) -> UpdateTimerDTO {
|
||||||
|
UpdateTimerDTO(
|
||||||
|
state: timer.state.rawValue,
|
||||||
|
pausedAt: timer.pausedAt,
|
||||||
|
firedAt: timer.firedAt,
|
||||||
|
completedAt: timer.completedAt,
|
||||||
|
syncVersion: 1
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - DTOs
|
||||||
|
|
||||||
|
struct SyncTimerDTO: Codable {
|
||||||
|
let id: String
|
||||||
|
var label: String
|
||||||
|
var description: String?
|
||||||
|
var type: String
|
||||||
|
var state: String
|
||||||
|
var urgency: String
|
||||||
|
var duration: TimeInterval
|
||||||
|
var targetTime: Date
|
||||||
|
var createdAt: Date
|
||||||
|
var startedAt: Date?
|
||||||
|
var pausedAt: Date?
|
||||||
|
var firedAt: Date?
|
||||||
|
var completedAt: Date?
|
||||||
|
var cascade: CascadeDTO?
|
||||||
|
var pomodoro: PomodoroDTO?
|
||||||
|
var isCalendarSync: Bool?
|
||||||
|
var category: String?
|
||||||
|
var syncVersion: Int
|
||||||
|
}
|
||||||
|
|
||||||
|
struct CascadeDTO: Codable {
|
||||||
|
let preset: String
|
||||||
|
let intervals: [Int]
|
||||||
|
}
|
||||||
|
|
||||||
|
struct PomodoroDTO: Codable {
|
||||||
|
let focusMinutes: Int
|
||||||
|
let shortBreakMinutes: Int
|
||||||
|
let longBreakMinutes: Int
|
||||||
|
let roundsBeforeLong: Int
|
||||||
|
var currentRound: Int
|
||||||
|
var isBreak: Bool
|
||||||
|
var totalRoundsCompleted: Int
|
||||||
|
}
|
||||||
|
|
||||||
|
struct UpdateTimerDTO: Codable {
|
||||||
|
var state: String?
|
||||||
|
var pausedAt: Date?
|
||||||
|
var firedAt: Date?
|
||||||
|
var completedAt: Date?
|
||||||
|
var syncVersion: Int
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Sync Results
|
||||||
|
|
||||||
|
struct SyncResult {
|
||||||
|
let pulled: [SyncTimerDTO]
|
||||||
|
let conflicts: [SyncConflict]
|
||||||
|
let error: String?
|
||||||
|
}
|
||||||
|
|
||||||
|
struct SyncConflict: Codable {
|
||||||
|
let id: String
|
||||||
|
let serverVersion: Int
|
||||||
|
}
|
||||||
|
|
||||||
|
struct BatchResult: Codable {
|
||||||
|
let synced: [String]
|
||||||
|
let conflicts: [SyncConflict]
|
||||||
|
let errors: [String]
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Offline Queue
|
||||||
|
|
||||||
|
enum OfflineAction: String, Codable {
|
||||||
|
case create
|
||||||
|
case update
|
||||||
|
case delete
|
||||||
|
}
|
||||||
|
|
||||||
|
struct OfflineQueueItem: Codable {
|
||||||
|
let id: String
|
||||||
|
let action: OfflineAction
|
||||||
|
let timer: SyncTimerDTO?
|
||||||
|
let enqueuedAt: Date
|
||||||
|
}
|
||||||
|
|
||||||
|
// MARK: - Errors
|
||||||
|
|
||||||
|
enum SyncError: LocalizedError {
|
||||||
|
case invalidURL
|
||||||
|
case invalidResponse
|
||||||
|
case httpError(Int)
|
||||||
|
case conflict
|
||||||
|
case notAuthenticated
|
||||||
|
|
||||||
|
var errorDescription: String? {
|
||||||
|
switch self {
|
||||||
|
case .invalidURL: return "Invalid sync URL"
|
||||||
|
case .invalidResponse: return "Invalid server response"
|
||||||
|
case .httpError(let code): return "Server error (\(code))"
|
||||||
|
case .conflict: return "Sync conflict — server has newer version"
|
||||||
|
case .notAuthenticated: return "Not signed in"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
327
web/src/lib/platform-sync.ts
Normal file
327
web/src/lib/platform-sync.ts
Normal file
@ -0,0 +1,327 @@
|
|||||||
|
// ── Platform Sync Client ──────────────────────────────────────
|
||||||
|
// Cross-platform sync via platform-service REST API
|
||||||
|
// Consumed by useSyncHook for React integration
|
||||||
|
|
||||||
|
import type { Timer } from './timer-engine';
|
||||||
|
|
||||||
|
// ── DTOs ──────────────────────────────────────────────────────
|
||||||
|
|
||||||
|
export interface SyncTimerDTO {
|
||||||
|
id: string;
|
||||||
|
label: string;
|
||||||
|
description?: string;
|
||||||
|
type: string;
|
||||||
|
state: string;
|
||||||
|
urgency: string;
|
||||||
|
duration: number;
|
||||||
|
targetTime: string; // ISO 8601
|
||||||
|
createdAt: string;
|
||||||
|
startedAt?: string;
|
||||||
|
pausedAt?: string;
|
||||||
|
firedAt?: string;
|
||||||
|
completedAt?: string;
|
||||||
|
cascade?: { preset: string; intervals: number[] };
|
||||||
|
pomodoro?: {
|
||||||
|
focusMinutes: number;
|
||||||
|
shortBreakMinutes: number;
|
||||||
|
longBreakMinutes: number;
|
||||||
|
roundsBeforeLong: number;
|
||||||
|
currentRound: number;
|
||||||
|
isBreak: boolean;
|
||||||
|
totalRoundsCompleted: number;
|
||||||
|
};
|
||||||
|
isCalendarSync?: boolean;
|
||||||
|
category?: string;
|
||||||
|
syncVersion: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface SyncConflict {
|
||||||
|
id: string;
|
||||||
|
serverVersion: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface BatchResult {
|
||||||
|
synced: string[];
|
||||||
|
conflicts: SyncConflict[];
|
||||||
|
errors: string[];
|
||||||
|
}
|
||||||
|
|
||||||
|
export interface OfflineQueueItem {
|
||||||
|
id: string;
|
||||||
|
action: 'create' | 'update' | 'delete';
|
||||||
|
timer?: SyncTimerDTO;
|
||||||
|
enqueuedAt: number;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── API Client ────────────────────────────────────────────────
|
||||||
|
|
||||||
|
const STORAGE_KEYS = {
|
||||||
|
authToken: 'chronomind-auth-token',
|
||||||
|
lastSync: 'chronomind-platform-last-sync',
|
||||||
|
offlineQueue: 'chronomind-offline-queue',
|
||||||
|
syncEnabled: 'chronomind-platform-sync-enabled',
|
||||||
|
} as const;
|
||||||
|
|
||||||
|
function getBaseUrl(): string {
|
||||||
|
if (typeof window !== 'undefined' && (window as Record<string, unknown>).__PLATFORM_URL__) {
|
||||||
|
return (window as Record<string, unknown>).__PLATFORM_URL__ as string;
|
||||||
|
}
|
||||||
|
return process.env.NEXT_PUBLIC_PLATFORM_SERVICE_URL ?? 'https://api.chronomind.app';
|
||||||
|
}
|
||||||
|
|
||||||
|
function getAuthToken(): string | null {
|
||||||
|
if (typeof window === 'undefined') return null;
|
||||||
|
return localStorage.getItem(STORAGE_KEYS.authToken);
|
||||||
|
}
|
||||||
|
|
||||||
|
async function apiRequest<T>(
|
||||||
|
path: string,
|
||||||
|
method: string,
|
||||||
|
body?: unknown
|
||||||
|
): Promise<T> {
|
||||||
|
const token = getAuthToken();
|
||||||
|
const headers: Record<string, string> = {
|
||||||
|
'Content-Type': 'application/json',
|
||||||
|
'x-request-id': crypto.randomUUID(),
|
||||||
|
};
|
||||||
|
if (token) headers['Authorization'] = `Bearer ${token}`;
|
||||||
|
|
||||||
|
const res = await fetch(`${getBaseUrl()}${path}`, {
|
||||||
|
method,
|
||||||
|
headers,
|
||||||
|
body: body ? JSON.stringify(body) : undefined,
|
||||||
|
});
|
||||||
|
|
||||||
|
if (res.status === 409) {
|
||||||
|
const data = await res.json();
|
||||||
|
throw new SyncConflictError(data);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!res.ok) {
|
||||||
|
throw new Error(`Sync API error: ${res.status} ${res.statusText}`);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (res.status === 204) return undefined as T;
|
||||||
|
return res.json();
|
||||||
|
}
|
||||||
|
|
||||||
|
export class SyncConflictError extends Error {
|
||||||
|
constructor(public serverData: unknown) {
|
||||||
|
super('Sync conflict — server has newer version');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Public API ────────────────────────────────────────────────
|
||||||
|
|
||||||
|
export function setAuthToken(token: string | null): void {
|
||||||
|
if (typeof window === 'undefined') return;
|
||||||
|
if (token) {
|
||||||
|
localStorage.setItem(STORAGE_KEYS.authToken, token);
|
||||||
|
} else {
|
||||||
|
localStorage.removeItem(STORAGE_KEYS.authToken);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function isAuthenticated(): boolean {
|
||||||
|
return getAuthToken() !== null;
|
||||||
|
}
|
||||||
|
|
||||||
|
export function isSyncEnabled(): boolean {
|
||||||
|
if (typeof window === 'undefined') return false;
|
||||||
|
return localStorage.getItem(STORAGE_KEYS.syncEnabled) === 'true';
|
||||||
|
}
|
||||||
|
|
||||||
|
export function setSyncEnabled(enabled: boolean): void {
|
||||||
|
if (typeof window === 'undefined') return;
|
||||||
|
localStorage.setItem(STORAGE_KEYS.syncEnabled, String(enabled));
|
||||||
|
}
|
||||||
|
|
||||||
|
export function getLastSyncDate(): string | null {
|
||||||
|
if (typeof window === 'undefined') return null;
|
||||||
|
return localStorage.getItem(STORAGE_KEYS.lastSync);
|
||||||
|
}
|
||||||
|
|
||||||
|
function setLastSyncDate(date: string): void {
|
||||||
|
localStorage.setItem(STORAGE_KEYS.lastSync, date);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Sync Operations ───────────────────────────────────────────
|
||||||
|
|
||||||
|
export async function pullDelta(since?: string): Promise<SyncTimerDTO[]> {
|
||||||
|
const params = since ? `?since=${encodeURIComponent(since)}` : '';
|
||||||
|
return apiRequest<SyncTimerDTO[]>(`/timers/sync${params}`, 'GET');
|
||||||
|
}
|
||||||
|
|
||||||
|
export async function pushTimer(dto: SyncTimerDTO): Promise<SyncTimerDTO> {
|
||||||
|
return apiRequest<SyncTimerDTO>('/timers', 'POST', dto);
|
||||||
|
}
|
||||||
|
|
||||||
|
export async function updateRemoteTimer(
|
||||||
|
id: string,
|
||||||
|
updates: Partial<SyncTimerDTO>
|
||||||
|
): Promise<SyncTimerDTO> {
|
||||||
|
return apiRequest<SyncTimerDTO>(`/timers/${id}`, 'PUT', updates);
|
||||||
|
}
|
||||||
|
|
||||||
|
export async function deleteRemoteTimer(id: string): Promise<void> {
|
||||||
|
return apiRequest<void>(`/timers/${id}`, 'DELETE');
|
||||||
|
}
|
||||||
|
|
||||||
|
export async function batchUpsert(
|
||||||
|
timers: SyncTimerDTO[]
|
||||||
|
): Promise<BatchResult> {
|
||||||
|
return apiRequest<BatchResult>('/timers/batch', 'POST', { timers });
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Offline Queue ─────────────────────────────────────────────
|
||||||
|
|
||||||
|
export function loadOfflineQueue(): OfflineQueueItem[] {
|
||||||
|
if (typeof window === 'undefined') return [];
|
||||||
|
try {
|
||||||
|
const raw = localStorage.getItem(STORAGE_KEYS.offlineQueue);
|
||||||
|
return raw ? JSON.parse(raw) : [];
|
||||||
|
} catch {
|
||||||
|
return [];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
export function saveOfflineQueue(queue: OfflineQueueItem[]): void {
|
||||||
|
if (typeof window === 'undefined') return;
|
||||||
|
localStorage.setItem(STORAGE_KEYS.offlineQueue, JSON.stringify(queue));
|
||||||
|
}
|
||||||
|
|
||||||
|
export function enqueueChange(
|
||||||
|
timer: Timer,
|
||||||
|
action: 'create' | 'update' | 'delete'
|
||||||
|
): void {
|
||||||
|
const queue = loadOfflineQueue().filter((item) => item.id !== timer.id);
|
||||||
|
queue.push({
|
||||||
|
id: timer.id,
|
||||||
|
action,
|
||||||
|
timer: action !== 'delete' ? timerToDTO(timer) : undefined,
|
||||||
|
enqueuedAt: Date.now(),
|
||||||
|
});
|
||||||
|
saveOfflineQueue(queue);
|
||||||
|
}
|
||||||
|
|
||||||
|
export function enqueueDeleteChange(timerId: string): void {
|
||||||
|
const queue = loadOfflineQueue().filter((item) => item.id !== timerId);
|
||||||
|
queue.push({ id: timerId, action: 'delete', enqueuedAt: Date.now() });
|
||||||
|
saveOfflineQueue(queue);
|
||||||
|
}
|
||||||
|
|
||||||
|
function clearSyncedFromQueue(syncedIds: string[]): void {
|
||||||
|
const queue = loadOfflineQueue().filter(
|
||||||
|
(item) => !syncedIds.includes(item.id)
|
||||||
|
);
|
||||||
|
saveOfflineQueue(queue);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Full Sync ─────────────────────────────────────────────────
|
||||||
|
|
||||||
|
export interface SyncResult {
|
||||||
|
pulled: SyncTimerDTO[];
|
||||||
|
conflicts: SyncConflict[];
|
||||||
|
error?: string;
|
||||||
|
}
|
||||||
|
|
||||||
|
export async function fullSync(): Promise<SyncResult> {
|
||||||
|
if (!isSyncEnabled() || !isAuthenticated()) {
|
||||||
|
return { pulled: [], conflicts: [], error: 'Not authenticated or sync disabled' };
|
||||||
|
}
|
||||||
|
|
||||||
|
try {
|
||||||
|
// 1. Pull delta
|
||||||
|
const since = getLastSyncDate() ?? undefined;
|
||||||
|
const pulled = await pullDelta(since);
|
||||||
|
|
||||||
|
// 2. Push offline queue
|
||||||
|
const queue = loadOfflineQueue();
|
||||||
|
let conflicts: SyncConflict[] = [];
|
||||||
|
|
||||||
|
if (queue.length > 0) {
|
||||||
|
const timersToSync = queue
|
||||||
|
.filter((item) => item.action !== 'delete' && item.timer)
|
||||||
|
.map((item) => item.timer!);
|
||||||
|
|
||||||
|
if (timersToSync.length > 0) {
|
||||||
|
const result = await batchUpsert(timersToSync);
|
||||||
|
conflicts = result.conflicts;
|
||||||
|
clearSyncedFromQueue(result.synced);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Handle deletes separately
|
||||||
|
const deletes = queue.filter((item) => item.action === 'delete');
|
||||||
|
for (const del of deletes) {
|
||||||
|
try {
|
||||||
|
await deleteRemoteTimer(del.id);
|
||||||
|
clearSyncedFromQueue([del.id]);
|
||||||
|
} catch {
|
||||||
|
// Keep in queue for retry
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// 3. Update last sync
|
||||||
|
setLastSyncDate(new Date().toISOString());
|
||||||
|
|
||||||
|
return { pulled, conflicts };
|
||||||
|
} catch (err) {
|
||||||
|
const message = err instanceof Error ? err.message : 'Unknown sync error';
|
||||||
|
return { pulled: [], conflicts: [], error: message };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── DTO Conversion ────────────────────────────────────────────
|
||||||
|
|
||||||
|
export function timerToDTO(timer: Timer): SyncTimerDTO {
|
||||||
|
return {
|
||||||
|
id: timer.id,
|
||||||
|
label: timer.label,
|
||||||
|
description: timer.description,
|
||||||
|
type: timer.type,
|
||||||
|
state: timer.state,
|
||||||
|
urgency: timer.urgency,
|
||||||
|
duration: timer.duration ?? 0,
|
||||||
|
targetTime: new Date(timer.targetTime).toISOString(),
|
||||||
|
createdAt: new Date(timer.createdAt).toISOString(),
|
||||||
|
startedAt: timer.startedAt ? new Date(timer.startedAt).toISOString() : undefined,
|
||||||
|
pausedAt: timer.pausedAt ? new Date(timer.pausedAt).toISOString() : undefined,
|
||||||
|
firedAt: timer.firedAt ? new Date(timer.firedAt).toISOString() : undefined,
|
||||||
|
completedAt: timer.completedAt ? new Date(timer.completedAt).toISOString() : undefined,
|
||||||
|
cascade: timer.cascade ? {
|
||||||
|
preset: timer.cascade.preset,
|
||||||
|
intervals: timer.cascade.intervals ?? [],
|
||||||
|
} : undefined,
|
||||||
|
pomodoro: timer.pomodoroConfig ? {
|
||||||
|
focusMinutes: timer.pomodoroConfig.workMinutes,
|
||||||
|
shortBreakMinutes: timer.pomodoroConfig.breakMinutes,
|
||||||
|
longBreakMinutes: timer.pomodoroConfig.longBreakMinutes,
|
||||||
|
roundsBeforeLong: timer.pomodoroConfig.rounds,
|
||||||
|
currentRound: timer.pomodoroState?.currentRound ?? 1,
|
||||||
|
isBreak: timer.pomodoroState?.isBreak ?? false,
|
||||||
|
totalRoundsCompleted: timer.pomodoroState?.completedRounds ?? 0,
|
||||||
|
} : undefined,
|
||||||
|
category: timer.category,
|
||||||
|
syncVersion: 1,
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
export function dtoToTimerPatch(dto: SyncTimerDTO): Partial<Timer> {
|
||||||
|
return {
|
||||||
|
id: dto.id,
|
||||||
|
label: dto.label,
|
||||||
|
description: dto.description,
|
||||||
|
type: dto.type as Timer['type'],
|
||||||
|
state: dto.state as Timer['state'],
|
||||||
|
urgency: dto.urgency as Timer['urgency'],
|
||||||
|
duration: dto.duration,
|
||||||
|
targetTime: new Date(dto.targetTime).getTime(),
|
||||||
|
createdAt: new Date(dto.createdAt).getTime(),
|
||||||
|
startedAt: dto.startedAt ? new Date(dto.startedAt).getTime() : undefined,
|
||||||
|
pausedAt: dto.pausedAt ? new Date(dto.pausedAt).getTime() : undefined,
|
||||||
|
firedAt: dto.firedAt ? new Date(dto.firedAt).getTime() : undefined,
|
||||||
|
completedAt: dto.completedAt ? new Date(dto.completedAt).getTime() : undefined,
|
||||||
|
category: dto.category,
|
||||||
|
};
|
||||||
|
}
|
||||||
197
web/src/lib/use-sync.ts
Normal file
197
web/src/lib/use-sync.ts
Normal file
@ -0,0 +1,197 @@
|
|||||||
|
// ── useSyncHook ───────────────────────────────────────────────
|
||||||
|
// React hook for cross-platform sync with platform-service
|
||||||
|
// Auto-syncs on interval, merges remote changes into Zustand store
|
||||||
|
|
||||||
|
'use client';
|
||||||
|
|
||||||
|
import { useCallback, useEffect, useRef, useState } from 'react';
|
||||||
|
import { useTimerStore } from './store';
|
||||||
|
import {
|
||||||
|
fullSync,
|
||||||
|
isSyncEnabled,
|
||||||
|
setSyncEnabled as _setSyncEnabled,
|
||||||
|
isAuthenticated,
|
||||||
|
setAuthToken,
|
||||||
|
loadOfflineQueue,
|
||||||
|
enqueueChange,
|
||||||
|
enqueueDeleteChange,
|
||||||
|
dtoToTimerPatch,
|
||||||
|
type SyncResult,
|
||||||
|
type SyncConflict,
|
||||||
|
} from './platform-sync';
|
||||||
|
import type { Timer } from './timer-engine';
|
||||||
|
|
||||||
|
const SYNC_INTERVAL_MS = 60_000; // 1 minute
|
||||||
|
|
||||||
|
export interface UseSyncReturn {
|
||||||
|
isSyncing: boolean;
|
||||||
|
syncEnabled: boolean;
|
||||||
|
lastSyncDate: string | null;
|
||||||
|
pendingChanges: number;
|
||||||
|
lastError: string | null;
|
||||||
|
conflicts: SyncConflict[];
|
||||||
|
|
||||||
|
// Actions
|
||||||
|
syncNow: () => Promise<SyncResult>;
|
||||||
|
setSyncEnabled: (enabled: boolean) => void;
|
||||||
|
login: (token: string) => void;
|
||||||
|
logout: () => void;
|
||||||
|
|
||||||
|
// Wrappers that enqueue changes
|
||||||
|
syncedAddTimer: (timer: Timer) => void;
|
||||||
|
syncedUpdateTimer: (timer: Timer) => void;
|
||||||
|
syncedRemoveTimer: (id: string) => void;
|
||||||
|
}
|
||||||
|
|
||||||
|
export function useSync(): UseSyncReturn {
|
||||||
|
const [isSyncing, setIsSyncing] = useState(false);
|
||||||
|
const [syncEnabled, setSyncEnabledState] = useState(false);
|
||||||
|
const [lastSyncDate, setLastSyncDate] = useState<string | null>(null);
|
||||||
|
const [pendingChanges, setPendingChanges] = useState(0);
|
||||||
|
const [lastError, setLastError] = useState<string | null>(null);
|
||||||
|
const [conflicts, setConflicts] = useState<SyncConflict[]>([]);
|
||||||
|
const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
|
||||||
|
|
||||||
|
// Load initial state
|
||||||
|
useEffect(() => {
|
||||||
|
setSyncEnabledState(isSyncEnabled());
|
||||||
|
setPendingChanges(loadOfflineQueue().length);
|
||||||
|
setLastSyncDate(
|
||||||
|
typeof window !== 'undefined'
|
||||||
|
? localStorage.getItem('chronomind-platform-last-sync')
|
||||||
|
: null
|
||||||
|
);
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
// Perform sync and merge results into store
|
||||||
|
const syncNow = useCallback(async (): Promise<SyncResult> => {
|
||||||
|
setIsSyncing(true);
|
||||||
|
setLastError(null);
|
||||||
|
|
||||||
|
try {
|
||||||
|
const result = await fullSync();
|
||||||
|
|
||||||
|
if (result.error) {
|
||||||
|
setLastError(result.error);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Merge pulled timers into Zustand store
|
||||||
|
if (result.pulled.length > 0) {
|
||||||
|
const store = useTimerStore.getState();
|
||||||
|
const currentTimers = [...store.timers];
|
||||||
|
|
||||||
|
for (const dto of result.pulled) {
|
||||||
|
const patch = dtoToTimerPatch(dto);
|
||||||
|
const existingIdx = currentTimers.findIndex((t) => t.id === dto.id);
|
||||||
|
|
||||||
|
if (existingIdx >= 0) {
|
||||||
|
// Merge: remote wins if syncVersion >= local
|
||||||
|
currentTimers[existingIdx] = {
|
||||||
|
...currentTimers[existingIdx],
|
||||||
|
...patch,
|
||||||
|
} as Timer;
|
||||||
|
} else {
|
||||||
|
// New timer from remote — add it
|
||||||
|
currentTimers.push(patch as Timer);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
useTimerStore.setState({ timers: currentTimers });
|
||||||
|
}
|
||||||
|
|
||||||
|
if (result.conflicts.length > 0) {
|
||||||
|
setConflicts((prev) => [...prev, ...result.conflicts]);
|
||||||
|
}
|
||||||
|
|
||||||
|
setPendingChanges(loadOfflineQueue().length);
|
||||||
|
setLastSyncDate(
|
||||||
|
typeof window !== 'undefined'
|
||||||
|
? localStorage.getItem('chronomind-platform-last-sync')
|
||||||
|
: null
|
||||||
|
);
|
||||||
|
|
||||||
|
return result;
|
||||||
|
} finally {
|
||||||
|
setIsSyncing(false);
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
// Auto-sync interval
|
||||||
|
useEffect(() => {
|
||||||
|
if (syncEnabled && isAuthenticated()) {
|
||||||
|
// Initial sync on enable
|
||||||
|
syncNow();
|
||||||
|
|
||||||
|
intervalRef.current = setInterval(() => {
|
||||||
|
syncNow();
|
||||||
|
}, SYNC_INTERVAL_MS);
|
||||||
|
}
|
||||||
|
|
||||||
|
return () => {
|
||||||
|
if (intervalRef.current) {
|
||||||
|
clearInterval(intervalRef.current);
|
||||||
|
intervalRef.current = null;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}, [syncEnabled, syncNow]);
|
||||||
|
|
||||||
|
const setSyncEnabled = useCallback(
|
||||||
|
(enabled: boolean) => {
|
||||||
|
_setSyncEnabled(enabled);
|
||||||
|
setSyncEnabledState(enabled);
|
||||||
|
},
|
||||||
|
[]
|
||||||
|
);
|
||||||
|
|
||||||
|
const login = useCallback(
|
||||||
|
(token: string) => {
|
||||||
|
setAuthToken(token);
|
||||||
|
setSyncEnabled(true);
|
||||||
|
},
|
||||||
|
[setSyncEnabled]
|
||||||
|
);
|
||||||
|
|
||||||
|
const logout = useCallback(() => {
|
||||||
|
setAuthToken(null);
|
||||||
|
setSyncEnabled(false);
|
||||||
|
setConflicts([]);
|
||||||
|
}, [setSyncEnabled]);
|
||||||
|
|
||||||
|
// Wrappers that enqueue changes for sync
|
||||||
|
const syncedAddTimer = useCallback((timer: Timer) => {
|
||||||
|
if (isSyncEnabled()) {
|
||||||
|
enqueueChange(timer, 'create');
|
||||||
|
setPendingChanges(loadOfflineQueue().length);
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
const syncedUpdateTimer = useCallback((timer: Timer) => {
|
||||||
|
if (isSyncEnabled()) {
|
||||||
|
enqueueChange(timer, 'update');
|
||||||
|
setPendingChanges(loadOfflineQueue().length);
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
const syncedRemoveTimer = useCallback((id: string) => {
|
||||||
|
if (isSyncEnabled()) {
|
||||||
|
enqueueDeleteChange(id);
|
||||||
|
setPendingChanges(loadOfflineQueue().length);
|
||||||
|
}
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
return {
|
||||||
|
isSyncing,
|
||||||
|
syncEnabled,
|
||||||
|
lastSyncDate,
|
||||||
|
pendingChanges,
|
||||||
|
lastError,
|
||||||
|
conflicts,
|
||||||
|
syncNow,
|
||||||
|
setSyncEnabled,
|
||||||
|
login,
|
||||||
|
logout,
|
||||||
|
syncedAddTimer,
|
||||||
|
syncedUpdateTimer,
|
||||||
|
syncedRemoveTimer,
|
||||||
|
};
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue
Block a user