normalized-cache/com.apollographql.cache.normalized.api/NormalizedCache

NormalizedCache

interface NormalizedCache : ReadOnlyNormalizedCache

A provider of Record for reading requests from cache.

To serialize a Record to a standardized form use recordAdapter() which handles call custom scalar types registered on the ApolloClient

If a NormalizedCache cannot return all the records needed to read a response, it will be considered a cache miss.

A NormalizedCache is recommended to implement support for CacheHeaders specified in the cacheHeaders of merge .

A NormalizedCache can choose to store records in any manner.

Inheritors

MemoryCache

Types

Companion

object Companion

Functions

allRecords

suspend fun NormalizedCache.allRecords(): Map<CacheKey, Record>

clearAll

abstract suspend fun clearAll()

Clears all records from the cache.

open suspend fun close()

dump

abstract suspend fun dump(): Map<@JvmSuppressWildcards KClass<*>, Map<CacheKey, Record>>

garbageCollect

suspend fun NormalizedCache.garbageCollect(maxAgeProvider: MaxAgeProvider, maxStale: Duration = Duration.ZERO, clock: () -> Long = { currentTimeMillis() }): GarbageCollectResult

Perform garbage collection on the cache.

loadRecord

abstract suspend fun loadRecord(key: CacheKey, cacheHeaders: CacheHeaders): Record?

loadRecords

abstract suspend fun loadRecords(keys: Collection<CacheKey>, cacheHeaders: CacheHeaders): Collection<Record>

Calls through to NormalizedCache.loadRecord. Implementations should override this method if the underlying storage technology can offer an optimized manner to read multiple records. There is no guarantee on the order of returned Record

merge

abstract suspend fun merge(record: Record, cacheHeaders: CacheHeaders, recordMerger: RecordMerger): Set<String>

abstract suspend fun merge(records: Collection<Record>, cacheHeaders: CacheHeaders, recordMerger: RecordMerger): Set<String>

Calls through to NormalizedCache.merge. Implementations should override this method if the underlying storage technology can offer an optimized manner to store multiple records.

remove

abstract suspend fun remove(cacheKey: CacheKey, cascade: Boolean): Boolean

Remove a record and potentially its referenced records from this cache and all chained caches

abstract suspend fun remove(cacheKeys: Collection<CacheKey>, cascade: Boolean): Int

Calls through to NormalizedCache.remove. Implementations should override this method if the underlying storage technology can offer an optimized manner to remove multiple records.

removeDanglingReferences

suspend fun NormalizedCache.removeDanglingReferences(): RemovedFieldsAndRecords

Remove all dangling references in the cache. A field is a dangling reference if its value (or, for lists, any of its values) is a reference to a record that does not exist.

removeStaleFields

suspend fun NormalizedCache.removeStaleFields(maxAgeProvider: MaxAgeProvider, maxStale: Duration = Duration.ZERO, clock: () -> Long = { currentTimeMillis() }): RemovedFieldsAndRecords

Remove all stale fields in the cache. A field is stale if its received date is older than its max age (configurable via maxAgeProvider) or if its expiration date has passed. A maximum staleness can be passed.

removeUnreachableRecords

suspend fun NormalizedCache.removeUnreachableRecords(): Set<CacheKey>

Remove all unreachable records in the cache. A record is unreachable if there exists no chain of references from the root record to it.

sizeOfRecord

open fun sizeOfRecord(record: Record): Int

Returns the size in bytes of a Record. This is an optional operation that can be implemented by the caches for debug purposes, otherwise it defaults to -1, meaning unknown size.

trim

open suspend fun trim(maxSizeBytes: Long, trimFactor: Float = 0.1f): Long

Trims the cache if its size exceeds maxSizeBytes. The amount of data to remove is determined by trimFactor. The oldest records are removed according to their updated date.