lazypock 0.3.0 → 0.5.0

package/src/lazypock.ts

@@ -19,6 +19,13 @@ import {
 	type UpdateData,
 	type SystemFields,
 	type RequestOptions,
+	type ListOptions,
+	type ReadOptions,
+	type FilterString,
+	type SortString,
+	type ExpandString,
+	type FilterOp,
+	type FieldKey,
 } from "./types";
 import { RealtimeService, wsUrlFromBaseUrl } from "./realtime";
 import {
@@ -32,8 +39,6 @@ import { CollectionsService } from "./collections";
 import type { CollectionSchema, SchemaField } from "./schema";
 import { generateTypes, collectionTypeName } from "./codegen";
 import { fieldTypeScriptType, fieldTypeKind, schemaFieldType } from "./typegen";
-import { CacheStore, type CacheConfig, type CacheRequestOptions } from "./cache";
-import { resolveCacheDirective } from "./cache";
 
 export {
 	AuthStore,
@@ -66,26 +71,15 @@ export type {
 	FileRecord,
 	CollectionSchema,
 	SchemaField,
+	// schema-driven query typing
+	ListOptions,
+	ReadOptions,
+	FilterString,
+	SortString,
+	ExpandString,
+	FilterOp,
+	FieldKey,
 };
-export type { CacheConfig, CacheRequestOptions };
-export { CacheStore, resolveCacheDirective };
-
-/**
- * Callable cache namespace: `client.cache(config)` configures, and
- * `client.cache.deleteByPrefix(...)` etc. manage cached entries.
- */
-export interface CacheController {
-	/** Configure the query cache at runtime. */
-	(config?: CacheConfig): LazypockClient;
-	/** Delete every entry whose key starts with `prefix` (e.g. `getList:posts`). */
-	deleteByPrefix(prefix: string): void;
-	/** Invalidate a collection's cached entries (alias of invalidateCache). */
-	invalidate(namespace: string): void;
-	/** Drop every cached entry. */
-	clear(): void;
-	/** Cache hit/miss/entry stats, or null when never configured. */
-	stats(): { hits: number; misses: number; entries: number } | null;
-}
 
 /** Options for constructing a {@link LazypockClient}. */
 export interface LazypockClientOptions {
@@ -97,24 +91,6 @@ export interface LazypockClientOptions {
 	authStore?: AuthStore;
 	/** Real-time service for Phoenix Channel WebSocket subscriptions */
 	realtime?: RealtimeService;
-	/**
-	 * Query cache configuration. Disabled by default.
-	 *
-	 * ```ts
-	 * const client = createClient({
-	 *   baseUrl: '...',
-	 *   cache: {
-	 *     enabled: true,
-	 *     defaultTTL: 30_000,
-	 *     store: myStorage,      // optional persistence (same interface as auth)
-	 *   },
-	 * });
-	 * ```
-	 *
-	 * When enabled, readable GETs are cached. Requests can opt out via
-	 * `{ cache: false }`, or opt in with a custom TTL via `{ ttl: ms }`.
-	 */
-	cache?: CacheConfig;
 	/**
 	 * Optional schema types for generating typed services at runtime.
 	 * When provided, `collection()` returns a service whose create/update
@@ -149,9 +125,6 @@ export class LazypockClient {
 	readonly files: FilesService;
 	private collectionCache = new Map<string, CollectionService>();
 	private schemaByName?: Map<string, CollectionSchema>;
-	private cacheStore?: CacheStore;
-	/** Namespace → realtime unsubscribe; used for realtime-driven invalidation. */
-	private realtimeInvalidators = new Map<string, () => void>();
 
 	/**
 	 * Create a new Lazypock client.
@@ -169,14 +142,6 @@ export class LazypockClient {
 		}
 		this.files = new FilesService(this.http);
 		this.collections = new CollectionsService(this.http, this.realtime);
-		if (options.cache) {
-			this.cacheStore = new CacheStore({
-				defaultTTL: options.cache.defaultTTL,
-				store: options.cache.store,
-				maxEntries: options.cache.maxEntries,
-			});
-			this.http.setCache(this.cacheStore, options.cache.enabled ?? false);
-		}
 		if (options.types?.schemas) {
 			this.schemaByName = new Map(
 				options.types.schemas.map((s) => [s.name, s]),
@@ -195,7 +160,7 @@ export class LazypockClient {
 	 * @param name The collection name.
 	 * @returns A {@link CollectionService} instance.
 	 */
-	collection(name: string): CollectionService<unknown> {
+	collection(name: string, schema?: CollectionSchema): CollectionService<unknown> {
 		let svc = this.collectionCache.get(name);
 		if (!svc) {
 			svc = new CollectionService(
@@ -203,6 +168,8 @@ export class LazypockClient {
 				name,
 				this.authStore,
 				this.realtime,
+				// Prefer the explicit schema, then the client-level `types.schemas`.
+				schema ?? this.schemaByName?.get(name),
 			);
 			this.collectionCache.set(name, svc);
 		}
@@ -265,100 +232,6 @@ export class LazypockClient {
 		return this;
 	}
 
-	// ── Query cache (opt-in by default; opt-out per request) ──
-
-	/**
-	 * Configure the query cache at runtime (also a namespace for cache
-	 * management methods).
-	 *
-	 * ```ts
-	 * client.cache({ enabled: true, defaultTTL: 30_000 });
-	 * client.cache.deleteByPrefix('getList:posts');  // all list caches for posts
-	 * client.cache.deleteByPrefix('getOne:posts');   // all one-record caches
-	 * ```
-	 *
-	 * When enabled, GET requests cache their payload; mutations invalidate the
-	 * affected collection automatically. Individual requests can opt out with
-	 * `{ cache: false }` or override the TTL with `{ ttl: ms }`.
-	 */
-	readonly cache: CacheController = Object.assign(
-		((config?: CacheConfig) => {
-			if (!this.cacheStore) {
-				// Lazy-create so `.cache({ enabled: true })` works even when the
-				// constructor wasn't given cache config.
-				this.cacheStore = new CacheStore({
-					defaultTTL: config?.defaultTTL,
-					store: config?.store,
-					maxEntries: config?.maxEntries,
-				});
-				this.http.setCache(this.cacheStore, config?.enabled ?? true);
-			} else {
-				if (config?.enabled !== undefined) {
-					this.http.setCache(this.cacheStore, config.enabled);
-				}
-			}
-			return this;
-		}) as (config?: CacheConfig) => LazypockClient,
-		{
-			deleteByPrefix: (prefix: string) => this.cacheStore?.deleteByPrefix(prefix),
-			invalidate: (namespace: string) => this.cacheStore?.invalidate(namespace),
-			clear: () => {
-				this.cacheStore?.clear();
-				for (const unsub of this.realtimeInvalidators.values()) unsub();
-				this.realtimeInvalidators.clear();
-			},
-			stats: () => (this.cacheStore ? this.cacheStore.stats() : null),
-		},
-	);
-
-	/**
-	 * Drop every cached entry (all collections / namespaces).
-	 * Also disables realtime-driven invalidation subscriptions.
-	 */
-	clearCache(): this {
-		this.cacheStore?.clear();
-		for (const unsub of this.realtimeInvalidators.values()) unsub();
-		this.realtimeInvalidators.clear();
-		return this;
-	}
-
-	/**
-	 * Invalidate cached entries for a collection (or custom namespace).
-	 * Runs automatically on mutations — call explicitly when data changed
-	 * out-of-band (e.g. another client wrote to the same collection).
-	 */
-	invalidateCache(namespace: string): this {
-		this.cacheStore?.invalidate(namespace);
-		return this;
-	}
-
-	/**
-	 * Cache hit/miss/entry statistics.
-	 * Returns null when caching was never configured.
-	 */
-	cacheStats(): { hits: number; misses: number; entries: number } | null {
-		return this.cacheStore ? this.cacheStore.stats() : null;
-	}
-
-	/**
-	 * Subscribe a collection's cache to realtime invalidation: any inbound
-	 * create/update/delete event for the collection clears its cached entries.
-	 * Returns an unsubscribe function.
-	 */
-	invalidateCacheOnRealtime(collectionName: string): () => void {
-		if (!this.cacheStore) {
-			// ensure a store exists so invalidation has somewhere to go
-			this.cache({ enabled: false });
-		}
-		const existing = this.realtimeInvalidators.get(collectionName);
-		if (existing) return existing;
-		const unsub = this.collection(collectionName).subscribe(() => {
-			this.cacheStore?.invalidate(collectionName);
-		});
-		this.realtimeInvalidators.set(collectionName, unsub);
-		return unsub;
-	}
-
 	// ── Auth ──
 
 	/** Check whether any superuser exists (for login vs setup screen routing). */
@@ -418,7 +291,7 @@ export class LazypockClient {
 				this.authStore.setCollectionName(collection);
 				this.authStore.set(data.token, data.record as unknown as AuthModel);
 			}
-	} else {
+		} else {
 			// Superuser login — PocketBase parity: `_superusers` is an auth collection.
 			// Falls back to the legacy /superusers/login for older servers.
 			try {

package/src/types.ts

@@ -65,18 +65,6 @@ export interface RequestOptions {
 	signal?: AbortSignal;
 	/** Custom fetch implementation (for RN or test mocking) */
 	fetch?: typeof globalThis.fetch;
-	/**
-	 * Cache control for this request (see {@link CacheRequestOptions}).
-	 * Resolved against the client's global cache config when unset.
-	 */
-	cache?: boolean | number | { ttl?: number; key?: string };
-	/** Alias of `cache: <ms>` — cache this GET for `ttl` milliseconds. */
-	ttl?: number;
-	/**
-	 * Extra cache namespaces to invalidate when this mutation succeeds.
-	 * The current collection is always invalidated automatically.
-	 */
-	invalidate?: string[];
 	/**
 	 * Request identifier used by the auto-cancellation mechanism.
 	 *
@@ -99,6 +87,17 @@ export interface RequestOptions {
 	 * Alias of `requestKey` (PocketBase `$cancelKey` compat).
 	 */
 	cancelKey?: string;
+	/**
+	 * Coalesce concurrent identical requests (same `requestKey`) onto a single
+	 * in-flight promise instead of aborting the earlier one.
+	 *
+	 * When enabled, a request arriving while another with the same key is still
+	 * pending awaits the same result — no duplicate network request, and the
+	 * caller of the first request never sees an abort rejection.
+	 *
+	 * @default false (auto-cancellation aborts the earlier duplicate)
+	 */
+	singleFlight?: boolean;
 }
 
 export class ApiError extends Error {
@@ -119,3 +118,107 @@ export class ApiError extends Error {
 		this.isAbort = isAbort;
 	}
 }
+
+// ── Schema-driven query typing ─────────────────────────
+// Template-literal helpers that turn a concrete record shape `T` (e.g. a
+// codegen-generated interface) into validated/suggestable query strings:
+//   - select("title", "published")          → field names checked
+//   - getList(1, 20, { sort: "-created" })   → "created" suggested
+//   - getList(1, 20, { filter: "title ~ 'x'" }) → field + operator suggested
+//   - getList(1, 20, { expand: "author" })   → field suggested (schema-checked at runtime)
+// When `T` is the untyped {@link ApiRecord}, every helper degrades to `string`.
+
+/**
+ * String keys of a record shape (excludes methods/symbols).
+ * Falls back to `string` when `T` has no known keys (e.g. `unknown`), so
+ * untyped services accept any field name.
+ */
+export type FieldKey<T> = Extract<keyof T, string> extends never
+	? string
+	: Extract<keyof T, string>;
+
+/** Valid filter operators, matching the backend FilterCompiler. */
+export type FilterOp =
+	| "="
+	| "!="
+	| "~"
+	| "!~"
+	| ">"
+	| ">="
+	| "<"
+	| "<=";
+
+/** One `field op value` clause. */
+type FilterClause<T> = `${FieldKey<T>} ${FilterOp} ${string}`;
+
+/**
+ * Type-checked filter expression (PocketBase syntax).
+ *
+ * ```ts
+ * getList(1, 20, { filter: "title ~ 'x' && published = true" })
+ * getList(1, 20, { filter: "(title = 'a' || title = 'b')" })
+ * ```
+ *
+ * The first clause's field name + operator are validated; the rest of the
+ * expression (values, `&&`/`||`, parens, `!`) is free-form.
+ */
+export type FilterString<T> =
+	| FilterClause<T>
+	| `${FilterClause<T>}${string}`;
+
+/** A single `[+|-]field` sort token. */
+type SortField<T> = `${"" | "-" | "+"}${FieldKey<T>}`;
+
+/**
+ * Type-checked sort string: `field`, `-field` (desc), `+field`, or
+ * comma-separated combinations (e.g. `"-created,title"`).
+ */
+export type SortString<T> = SortField<T> | `${SortField<T>},${string}`;
+
+/**
+ * Type-checked expand string: comma-separated relation field names
+ * (e.g. `"author"` or `"author,category"`). Non-relation fields are
+ * warned about at runtime when a schema is available.
+ */
+export type ExpandString<T> = FieldKey<T> | `${FieldKey<T>},${string}`;
+
+/**
+ * Query options for list/read operations, typed against a record shape `T`.
+ *
+ * `filter`, `sort`, `expand` and `fields` are recognized; any other key is
+ * passed through as a raw query parameter (PocketBase-compatible).
+ */
+export interface ListOptions<T = ApiRecord> {
+	/**
+	 * PocketBase filter expression. Field names + operators are type-checked
+	 * when `T` is a concrete shape.
+	 */
+	filter?: FilterString<T>;
+	/**
+	 * Sort field(s): `field`, `-field` (descending), comma-separated.
+	 */
+	sort?: SortString<T>;
+	/**
+	 * Comma-separated relation field names to expand.
+	 */
+	expand?: ExpandString<T>;
+	/**
+	 * Explicit field projection (overrides {@link CollectionService.select}).
+	 */
+	fields?: string;
+	/**
+	 * Raw query parameters — any other key is passed through verbatim.
+	 */
+	[key: string]: unknown;
+}
+
+/**
+ * Options for single-record reads (`getOne`): expand + explicit fields.
+ */
+export interface ReadOptions<T = ApiRecord> {
+	/** Comma-separated relation field names to expand. */
+	expand?: ExpandString<T>;
+	/** Explicit field projection (overrides {@link CollectionService.select}). */
+	fields?: string;
+}
+

package/src/cache.ts

@@ -1,314 +0,0 @@
-// ── Cache Store ──────────────────────────────────────────
-// Pluggable query-cache for GET responses. Mirrors the AuthStore pattern:
-// a default memory store (Map) with an optional custom storage adapter
-// (localStorage, AsyncStorage, IndexedDB, ...) for cross-page persistence.
-
-import type { StorageAdapter } from "./auth";
-
-/** Options for enabling/customising the client's query cache. */
-export interface CacheConfig {
-	/**
-	 * Master switch. When `true`, readable GET requests are cached with the
-	 * default TTL unless a request opts out via `{ cache: false }`.
-	 *
-	 * When `false` (default), caching is disabled unless a request opts in
-	 * via `{ cache: true }` or `{ ttl: <ms> }`. Opt-in works regardless.
-	 */
-	enabled?: boolean;
-	/**
-	 * Default time-to-live for cached entries, in milliseconds.
-	 * @default 60_000 (1 minute)
-	 */
-	defaultTTL?: number;
-	/**
-	 * Optional persistence backend (same interface as AuthStore's storage).
-	 * Defaults to an in-memory Map — swap for `localStorage` / `AsyncStorage`
-	 * to keep the cache across page reloads / app restarts.
-	 */
-	store?: StorageAdapter;
-	/**
-	 * Max number of entries to keep in memory (LRU eviction).
-	 * @default 500
-	 */
-	maxEntries?: number;
-	/**
-	 * When true and the client has an active realtime subscription for a
-	 * collection, inbound create/update/delete events invalidate that
-	 * collection's cached entries automatically.
-	 * @default false — only local mutations invalidate (explicit + predictable)
-	 */
-	invalidateOnRealtime?: boolean;
-}
-
-/** Per-request cache controls (mixed into {@link RequestOptions}). */
-export interface CacheRequestOptions {
-	/**
-	 * Cache control for this request:
-	 * - `true` — cache with the default (or global) TTL
-	 * - `false` — always fetch fresh, bypass cache (and don't store the result)
-	 * - a number — cache with this TTL in milliseconds
-	 * - an object — `{ ttl, key }` for finer control
-	 *
-	 * When unset, the global `cache.enabled` flag decides.
-	 */
-	cache?: boolean | number | { ttl?: number; key?: string };
-	/** Alias of `cache: <ms>` (convenience, reads naturally). */
-	ttl?: number;
-	/**
-	 * Extra cache namespaces to invalidate when this mutation succeeds.
-	 * The current collection is always invalidated automatically.
-	 * @example create({ ... }, { invalidate: ['users'] })
-	 */
-	invalidate?: string[];
-}
-
-/** A single cached entry. */
-interface CacheEntry<T = unknown> {
-	value: T;
-	expiresAt: number;
-	/** Namespace (collection name) this entry belongs to — for invalidation. */
-	namespace?: string;
-	/** Prefix tags (e.g. `getList:posts`) for deleteByPrefix. */
-	tags?: string[];
-}
-
-/** LRU-ish memory store + optional persistent adapter hybrid. */
-export class CacheStore {
-	private memory = new Map<string, CacheEntry>();
-	private readonly ttl: number;
-	private readonly persistence?: StorageAdapter;
-	private readonly maxEntries: number;
-	private hits = 0;
-	private misses = 0;
-	private namespaceEntries = new Map<string, Set<string>>();
-	/** Key → set of prefix tags registered for that key (e.g. `getList:posts`). */
-	private prefixEntries = new Map<string, Set<string>>();
-
-	constructor(config: {
-		defaultTTL?: number;
-		store?: StorageAdapter;
-		maxEntries?: number;
-	} = {}) {
-		this.ttl = config.defaultTTL ?? 60_000;
-		this.persistence = config.store;
-		this.maxEntries = config.maxEntries ?? 500;
-	}
-
-	/** Resolve the effective TTL: request override → global default. */
-	private resolveTTL(ttl?: number): number {
-		return ttl && ttl > 0 ? ttl : this.ttl;
-	}
-
-	/**
-	 * Read a cached value. Fast sync path (memory) with async persistence
-	 * fallback for adapters whose `get` returns a Promise.
-	 * @param key Cache key (e.g. `"GET /posts?page=1"`).
-	 * @returns The cached value, or undefined when absent/expired (the hit is
-	 * cleared on expiry so a stale value is never served).
-	 */
-	async get<T = unknown>(key: string): Promise<T | undefined> {
-		const mem = this.memory.get(key);
-		if (mem !== undefined) {
-			if (Date.now() > mem.expiresAt) {
-				this.delete(key);
-				this.misses++;
-				return undefined;
-			}
-			// refresh recency for LRU eviction
-			this.memory.delete(key);
-			this.memory.set(key, mem);
-			this.hits++;
-			return mem.value as T;
-		}
-		if (this.persistence) {
-			const entry = await this.readPersisted(key);
-			if (entry) {
-				if (Date.now() > entry.expiresAt) {
-					this.delete(key);
-					this.misses++;
-					return undefined;
-				}
-				this.hits++;
-				return entry.value as T;
-			}
-		}
-		this.misses++;
-		return undefined;
-	}
-
-	/**
-	 * Store a value.
-	 * @param key Cache key.
-	 * @param value The response payload.
-	 * @param ttlOverride Optional TTL override (ms).
-	 * @param namespace Optional namespace for group invalidation.
-	 */
-	set(
-		key: string,
-		value: unknown,
-		ttlOverride?: number,
-		namespace?: string,
-		tags?: string[],
-	): void {
-		const expiresAt = Date.now() + this.resolveTTL(ttlOverride);
-		const entry: CacheEntry = { value, expiresAt, namespace, tags };
-		this.memory.set(key, entry);
-
-		// LRU eviction when over capacity
-		if (this.memory.size > this.maxEntries) {
-			const oldest = this.memory.keys().next().value as string | undefined;
-			if (oldest !== undefined) this.delete(oldest);
-		}
-
-		if (namespace) {
-			let keys = this.namespaceEntries.get(namespace);
-			if (!keys) {
-				keys = new Set();
-				this.namespaceEntries.set(namespace, keys);
-			}
-			keys.add(key);
-		}
-
-		for (const tag of tags ?? []) {
-			let keys = this.prefixEntries.get(tag);
-			if (!keys) {
-				keys = new Set();
-				this.prefixEntries.set(tag, keys);
-			}
-			keys.add(key);
-		}
-
-		if (this.persistence) {
-			void this.persistence.set(this.persistKey(key), JSON.stringify(entry));
-		}
-	}
-
-	/**
-	 * Invalidate entries belonging to a namespace (e.g. a collection name).
-	 * Also clears the namespace index entry.
-	 */
-	invalidate(namespace: string): void {
-		const keys = Array.from(this.namespaceEntries.get(namespace) ?? []);
-		for (const key of keys) this.delete(key);
-		this.namespaceEntries.delete(namespace);
-	}
-
-	/** Remove a single key. */
-	delete(key: string): void {
-		const entry = this.memory.get(key);
-		if (entry?.namespace) {
-			const set = this.namespaceEntries.get(entry.namespace);
-			if (set) {
-				set.delete(key);
-				if (set.size === 0) this.namespaceEntries.delete(entry.namespace);
-			}
-		}
-		for (const tag of entry?.tags ?? []) {
-			const set = this.prefixEntries.get(tag);
-			if (set) {
-				set.delete(key);
-				if (set.size === 0) this.prefixEntries.delete(tag);
-			}
-		}
-		this.memory.delete(key);
-		if (this.persistence) {
-			void this.persistence.remove(this.persistKey(key));
-		}
-	}
-
-	/**
-	 * Delete every entry whose key starts with `prefix`.
-	 *
-	 * Useful for fine-grained invalidation, e.g.:
-	 * ```ts
-	 * client.cache.deleteByPrefix('getList:posts'); // delete all getList cache
-	 * client.cache.deleteByPrefix('getOne:posts');  // delete all getOne cache
-	 * ```
-	 */
-	deleteByPrefix(prefix: string): void {
-		if (!prefix) return;
-		// exact tag match (fast path — the common `op:collection` case)
-		const tagged = this.prefixEntries.get(prefix);
-		if (tagged) {
-			for (const key of Array.from(tagged)) this.delete(key);
-			this.prefixEntries.delete(prefix);
-			return;
-		}
-		// general prefix scan (e.g. `posts` matches any `op:posts`/`GET /posts`)
-		for (const key of Array.from(this.memory.keys())) {
-			if (key.startsWith(prefix)) this.delete(key);
-		}
-	}
-
-	/** Drop every cached entry (memory + persistence). */
-	clear(): void {
-		this.memory.clear();
-		this.namespaceEntries.clear();
-		this.prefixEntries.clear();
-		// Best-effort: clear all persisted keys via the adapter. The adapter has
-		// no list API, so we track a prefix index in memory only — a full
-		// persistence wipe is only possible if the adapter supports enumeration.
-		// Most use localStorage directly; callers may also recreate the client.
-	}
-
-	/** Cache hit/miss/entry statistics. */
-	stats(): { hits: number; misses: number; entries: number } {
-		return { hits: this.hits, misses: this.misses, entries: this.memory.size };
-	}
-
-	private persistKey(key: string): string {
-		return "lazypock:cache:" + key;
-	}
-
-	private async readPersisted(key: string): Promise<CacheEntry | undefined> {
-		if (!this.persistence) return undefined;
-		const raw = await this.persistence.get(this.persistKey(key));
-		if (raw == null) return undefined;
-		try {
-			const entry = JSON.parse(raw) as CacheEntry;
-			// Re-hydrate a copy in memory (TTL checked by caller)
-			this.memory.set(key, entry);
-			if (entry.namespace) {
-				let keys = this.namespaceEntries.get(entry.namespace);
-				if (!keys) {
-					keys = new Set();
-					this.namespaceEntries.set(entry.namespace, keys);
-				}
-				keys.add(key);
-			}
-			for (const tag of entry.tags ?? []) {
-				let keys = this.prefixEntries.get(tag);
-				if (!keys) {
-					keys = new Set();
-					this.prefixEntries.set(tag, keys);
-				}
-				keys.add(key);
-			}
-			return entry;
-		} catch {
-			void this.persistence.remove(this.persistKey(key));
-			return undefined;
-		}
-	}
-}
-
-// ── Helpers ──
-
-/** Resolve per-request cache options into a usable directive. */
-export function resolveCacheDirective(opts?: {
-	cache?: boolean | number | { ttl?: number; key?: string };
-	ttl?: number;
-}): { enabled: boolean; ttl?: number; key?: string } | null {
-	if (!opts) return null;
-	// convenience alias: ttl: 5000  →  cache for 5s
-	if (typeof opts.ttl === "number" && opts.ttl > 0) {
-		return { enabled: true, ttl: opts.ttl };
-	}
-	const c = opts.cache;
-	if (c === undefined) return null; // use global enabled flag
-	if (c === true) return { enabled: true };
-	if (c === false) return { enabled: false };
-	if (typeof c === "number") return { enabled: true, ttl: c > 0 ? c : undefined };
-	// object form
-	return { enabled: true, ttl: c.ttl, key: c.key };
-}