sync/io.github.maniramezan.kommon.sync/SyncResourceAdapter

SyncResourceAdapter

interface SyncResourceAdapter<E : SyncableEntity<E>, U, D, C>

Resource-specific glue for the generic loop in SyncEngine. Implement one of these (plus the wire DTO mapping) to make a new resource syncable — the contract logic (ack guard, pending guard, full-snapshot reconciliation, pagination drain, fullResyncRequired) lives in the engine, not here, so it holds identically for every resource.

Type Parameters

entity type (carries SyncableEntity bookkeeping)

upsert DTO, D delete DTO, C server-change DTO

Properties

resourceName

abstract val resourceName: String

Functions

activeRows

abstract suspend fun activeRows(): List<E>

Active (non-deleted) rows, for full-snapshot tombstone reconciliation.

api

abstract suspend fun api(request: SyncRequest<U, D>): SyncResponse<C>

changeKey

abstract fun changeKey(change: C): String

findExisting

abstract suspend fun findExisting(change: C): E?

isChangeDeleted

abstract fun isChangeDeleted(change: C): Boolean

pending

abstract suspend fun pending(): List<E>

purgeSynced

abstract suspend fun purgeSynced()

Drop clean synced rows for fullResyncRequired.

reload

abstract suspend fun reload(entity: E): E?

Re-read the row for the ack guard (detects edits made during the in-flight request).

syncKey

abstract fun syncKey(entity: E): String

Canonical business key; MUST equal the server's applied[].key and changeKey.

toDelete

abstract fun toDelete(entity: E): D

toEntity

abstract fun toEntity(change: C, existing: E?): E

toUpsert

abstract fun toUpsert(entity: E): U

upsert

abstract suspend fun upsert(entity: E)

upsertAll

open suspend fun upsertAll(entities: List<E>)

Writes a batch of rows produced from one ack set, one page of server changes, or one tombstone sweep. The default calls upsert per row; override it to write the batch in a single database transaction. The engine reads rows before calling this method, so a transaction around these writes alone does not make its guards atomic with concurrent local edits. Adapters must also enforce conditional writes against the current local version when local editing can race sync persistence.