Repository Public
1//2// SP Chat iOS3// File: SPChat-iOS/Core/Sync/SyncEngine.swift4// Description: Follows the server's change feed (SSE `GET /api/events`, pull `GET /api/sync`) while the app is active:5// reconnects with backoff, keeps its cursor in the local store and hands batched refresh plans to the app.6//7// Author: Simon-Pierre Boucher8// Contact: contact@spboucher.ai9//1011import Foundation12import Observation1314@MainActor15@Observable16final class SyncEngine {17 enum Status: Equatable, Sendable { case idle, connecting, live, waiting }18 private(set) var status: Status = .idle19 private(set) var lastChangeAt: Date?20 /// Last sequence number applied (nil until the first contact with the server).21 private(set) var cursor: Int?2223 @ObservationIgnored private let api: ChatAPI24 @ObservationIgnored private let store: LocalStore25 @ObservationIgnored private let waitUntilOnline: () async -> Void26 /// Applies a plan (re-reads what changed). Set by `AppEnvironment`.27 @ObservationIgnored var onPlan: ((SyncPlan) async -> Void)?28 @ObservationIgnored private var feedTask: Task<Void, Never>?29 @ObservationIgnored private var flushTask: Task<Void, Never>?30 @ObservationIgnored private var pending = SyncPlan()31 @ObservationIgnored private var loadedCursor = false32 static let cursorKey = "sync.cursor"3334 init(api: ChatAPI, store: LocalStore, waitUntilOnline: @escaping () async -> Void) { self.api = api; self.store = store; self.waitUntilOnline = waitUntilOnline }3536 private func loadCursor() async {37 guard !loadedCursor else { return }38 loadedCursor = true39 cursor = await store.value(Int.self, for: Self.cursorKey)40 }41 private func advance(to seq: Int) {42 guard seq > (cursor ?? -1) else { return }43 cursor = seq44 let store = store45 Task { await store.setValue(seq, for: Self.cursorKey) }46 }4748 /// Opens the feed (app active, signed in). Idempotent.49 func start() {50 guard feedTask == nil else { return }51 feedTask = Task { [weak self] in await self?.run() }52 }5354 /// Closes the feed (background, sign-out). The cursor is kept: the next start replays what was missed.55 func stop() {56 feedTask?.cancel(); feedTask = nil57 flushTask?.cancel(); flushTask = nil58 status = .idle59 }6061 func reset() async {62 stop(); cursor = nil; pending = SyncPlan(); loadedCursor = true63 // the store itself is wiped by the caller; nothing else to forget64 }6566 /// Pull variant (foreground, background refresh): what changed since the cursor, as one plan.67 /// Returns nil when the server could not be reached.68 @discardableResult69 func pull() async -> SyncPlan? {70 await loadCursor()71 guard let after = cursor else {72 // first contact: everything was just loaded; only remember where the feed stands73 guard let r = try? await api.sync(after: 0) else { return nil }74 advance(to: r.head)75 return SyncPlan()76 }77 guard let r = try? await api.sync(after: after) else { return nil }78 var plan = SyncPlan()79 if r.truncated { plan = .all; advance(to: r.head) } else { advance(to: max(plan.absorb(r.events, cursor: after), r.head)) }80 if !plan.isEmpty { lastChangeAt = Date(); await onPlan?(plan) }81 return plan82 }8384 private func run() async {85 await loadCursor()86 var failures = 087 while !Task.isCancelled {88 await waitUntilOnline()89 if Task.isCancelled { return }90 if cursor == nil { _ = await pull() }91 guard let after = cursor else { await backoff(&failures); continue }92 status = .connecting93 do {94 switch try await api.openEvents(after: after) {95 case .json: break96 case .events(let bytes):97 for try await sse in SSEStream.events(from: bytes) {98 if Task.isCancelled { return }99 handle(SyncFeedEvent(sse: sse))100 failures = 0101 }102 }103 } catch let e as APIError where e.kind == .locked { status = .idle; feedTask = nil; return }104 catch { }105 if Task.isCancelled { return }106 await backoff(&failures)107 }108 }109110 private func backoff(_ failures: inout Int) async {111 status = .waiting112 failures += 1113 let delay = min(1000 * (1 << min(failures, 5)), 30_000) + Int.random(in: 0...500)114 try? await Task.sleep(for: .milliseconds(delay))115 }116117 /// Applies one feed event. Changes are batched: a burst (a turn writes several rows) becomes one plan.118 func handle(_ event: SyncFeedEvent) {119 switch event {120 case .hello: status = .live121 case .change(let e):122 let before = cursor ?? -1123 advance(to: pending.absorb([e], cursor: before))124 scheduleFlush()125 case .resync(let head):126 pending = .all; advance(to: head); scheduleFlush()127 case .other: break128 }129 }130131 private func scheduleFlush() {132 guard flushTask == nil else { return }133 flushTask = Task { [weak self] in134 try? await Task.sleep(for: .milliseconds(350))135 guard let self, !Task.isCancelled else { return }136 self.flushTask = nil137 await self.flush()138 }139 }140141 /// Hands the batched plan to the app now (tests call it directly).142 func flush() async {143 flushTask?.cancel(); flushTask = nil144 let plan = pending; pending = SyncPlan()145 guard !plan.isEmpty else { return }146 lastChangeAt = Date()147 await onPlan?(plan)148 }149}150