# API Reference Generated reference for every public export of `ocache`. For task-oriented guides, start with [Caching Functions](/docs/functions) and [Caching HTTP Handlers](/docs/handler). ### `BlobValue` ```ts type BlobValue = ArrayBufferView | ArrayBufferLike; ``` What a byte backend may return: a view, or the buffer behind one. --- ### `CachedEventHandler` ```ts type CachedEventHandler = EventHandler & ``` Cached handler with resource-level cache management methods. Each method covers GET and HEAD variants in every base prefix. --- ### `cachedFunction` ```ts const cachedFunction = defineCachedFunction; ``` Alias for [`defineCachedFunction`](#definecachedfunction). --- ### `CacheStatus` ```ts type CacheStatus = "hit" | "stale" | "revalidated" | "miss"; ``` Result of one cache call. - `"hit"`: returned a fresh stored value. - `"stale"`: returned stale data and started background revalidation. - `"revalidated"`: replaced an old value before returning. - `"miss"`: resolved a value when none existed. --- ### `composeStorage` ```ts function composeStorage( layers: ReadonlyArray, opts: ComposeStorageOptions = ``` Combines several backends into one tiered [`StorageInterface`](#storageinterface). Reads try each layer in order and stop at the first hit, promoting it into every earlier layer. Writes and deletes reach every layer. A layer that throws is skipped rather than failing the operation, so a shared remote layer can be down while a local one still serves. This is a backend, not a cache option: the cache above it sees one store with one declaration, so nothing in the key, the entry, or the purge path changes. **Example:** ```ts const storage = composeStorage([ { storage: createMemoryStorage({ maxBytes: 64 * 1024 * 1024 }), ttl: 60 }, createBlobStorage(redis), ]); ``` --- ### `createBlobStorage` ```ts function createBlobStorage(backend: BlobBackend): StorageInterface; ``` Adapts a byte-only backend into a [`StorageInterface`](#storageinterface), storing each entry as one frame. The entry's metadata travels as JSON and its payload travels as itself, appended after it. That keeps a response body — text or binary — out of the JSON document: text pays no escaping in either direction, and bytes pay no base64 and no 4/3 expansion in the backend. The payload is the one named by {@link CacheEntry.payload}, which the producer of the entry declares — `http/entry.ts` for a response body, `cache.ts` for a byte value. Nothing here infers a payload from a value's shape. This declares `binary`, because the frame carries the declared payload as bytes. Every other member of the entry is JSON, exactly as it would be on a serializing backend: a byte view hidden somewhere ocache did not put one does not survive, on this backend or on any other JSON-shaped one. A frame written by a different version is read as a miss, so a format change costs one revalidation rather than a mangled entry. **Example:** ```ts const storage = createBlobStorage({ get: (key) => unstorage.getItemRaw(key), set: (key, value, opts) => value === null ? unstorage.removeItem(key) : unstorage.setItemRaw(key, value, opts), }); ``` --- ### `createMemoryStorage` ```ts function createMemoryStorage(opts: MemoryStorageOptions = ``` Creates Map-based memory storage with TTLs in seconds and LRU eviction. --- ### `defineCachedFunction` ```ts function defineCachedFunction( fn: (...args: ArgsT) => T | Promise, opts: CacheOptions = ``` Wraps a function with caching, SWR, integrity checks, and request deduplication. **Parameters:** - **`fn`** — Function to cache. - **`opts`** — Cache options. **Returns:** — The cached function and its cache management methods. --- ### `defineCachedHandler` ```ts function defineCachedHandler( handler: EventHandler, opts: CachedEventHandlerOptions = ``` Wraps an HTTP handler with response caching and conditional response support. Only GET and HEAD requests without Range are cacheable. Only 200, 203, 301, and 308 responses are stored. Response Cache-Control and Vary headers can prevent storage. **Parameters:** - **`handler`** — Handler to cache. - **`opts`** — Cache and HTTP options. **Returns:** — A cached handler with resource-level cache management methods. --- ### `EventHandler` ```ts type EventHandler = ( ``` Handler that receives an HTTP event. --- ### `expireCache` ```ts async function expireCache( input: ``` Marks matching entries as stale without removing them. SWR may serve the stale value within its original stale window. Without SWR, the next call revalidates before returning. Pass the original lifetime options to preserve the remaining storage TTL. This function throws when `options.storage` is unset. **Parameters:** - **`input`** — Cache options and function arguments. **Example:** ```ts await expireCache({ options: { name: "fetchUser", getKey: (id: string) => id, maxAge: 60, swr: true, storage }, args: ["user-123"], }); ``` --- ### `invalidateCache` ```ts async function invalidateCache( input: ``` Removes matching entries from all base prefixes. Pass the original options object or the same explicit storage backend. This function throws when `options.storage` is unset because no global store exists. Prefer the cached function's `.invalidate()` method when available. **Parameters:** - **`input`** — Cache options and function arguments. **Example:** ```ts await invalidateCache({ options: { name: "fetchUser", getKey: (id: string) => id, storage }, args: ["user-123"], }); ``` --- ### `resolveCacheKeys` ```ts async function resolveCacheKeys( input: ``` Returns one storage key per base prefix. Pass the same `getKey`, `name`, `group`, and `base` options as the cached function. This helper computes keys without accessing storage. **Parameters:** - **`input`** — Cache options and function arguments. **Returns:** — Storage keys in base-prefix order. **Example:** ```ts const keys = await resolveCacheKeys({ options: { name: "fetchUser", getKey: (id: string) => id }, args: ["user-123"], }); ``` --- ### `resolveSignal` ```ts function resolveSignal(event: HTTPEvent): AbortSignal | undefined; ``` The deadline signal of the resolution this event leads, if it leads one. --- ### `StorageOption` ```ts type StorageOption = StorageInterface | (() => StorageInterface); ``` A storage instance or a late-bound storage factory. The cache calls a factory once, on the first cache operation.