@prisma/orm-extension-middleware-cache 8.0.0-rc.14-dev.8 → 8.0.0-rc.14-dev.9

package/README.md

@@ -9,11 +9,107 @@ pnpm add @prisma/orm-extension-middleware-cache
 The whole surface is the package root:
 
 ```ts
-import { cache, cacheAnnotation, type CacheStore } from '@prisma/orm-extension-middleware-cache';
+import {
+  cacheAnnotation,
+  createCacheMiddleware,
+  createInMemoryCacheStore,
+  deriveKeyFromContentHash,
+  type CacheStore,
+} from '@prisma/orm-extension-middleware-cache';
 ```
 
 ## Responsibilities
 
-A runtime middleware that short-circuits repeated reads: on a hit it returns cached rows and never invokes the driver; on a miss it buffers the driver's rows and commits them to the store only when the execution completes successfully. Cache keys come from the family runtime's content hash of the execution, or from a per-query `cacheAnnotation({ key })` override; `ttl` and `skip` are per-query too. Connection- and transaction-scoped executions bypass the cache.
+A read-through cache middleware: on a hit it returns cached rows and never invokes the driver; on a miss it buffers the driver's rows and stores them when the read completes. A read opts in with `cacheAnnotation({ key?, meta?, bypass? })`: `key` names the entry, otherwise the `deriveKey` option computes it (default: the family runtime's content hash, `deriveKeyFromContentHash`); `meta` is handed to the store with the entry; `bypass: true` skips the cache for that call. Connection- and transaction-scoped executions bypass the cache.
 
-It ships an in-memory LRU-with-TTL store and exposes the `CacheStore` interface so Redis, Memcached, or any other backend can be dropped in.
+How long an entry lives is the store's policy. The default store, `createInMemoryCacheStore({ maxEntries?, ttlMs?, clock? })`, keeps up to 1000 values for 60 seconds each; `ttlMs: Infinity` never expires. A key's version is kept for `ttlMs` after the `unset` that moved it. Versions are not bounded by `maxEntries`. A forgotten version reads as 0, so with a finite `ttlMs` a read that takes longer than `ttlMs` and overlaps an `invalidate` can store stale rows. With `ttlMs: Infinity`, the versions of invalidated keys are never forgotten and grow with the number of distinct keys invalidated. A `maxEntries` that is not a positive integer or a `ttlMs` that is not positive throws `RUNTIME.ARGUMENT_INVALID`. Implement the `CacheStore` interface to use Redis, Memcached, or any other backend.
+
+## The store
+
+The store is a cache of values; this middleware stores `CachedRows`, the raw rows of one read.
+
+```ts
+interface CacheEntry<TMeta = unknown, TValue = CachedRows> {
+  readonly key: string;
+  readonly meta: TMeta | undefined;
+  readonly version: number;
+  readonly data: { readonly empty: true } | { readonly empty: false; readonly value: TValue };
+}
+
+interface CacheStore<TMeta = unknown, TValue = CachedRows> {
+  get(target: {
+    readonly key: string;
+    readonly meta: TMeta | undefined;
+  }): Promise<CacheEntry<TMeta, TValue>>;
+  set(entry: CacheEntry<TMeta, TValue>, value: TValue): Promise<boolean>;
+  unset(target: {
+    readonly keys: readonly string[] | undefined;
+    readonly meta: TMeta | undefined;
+  }): Promise<void>;
+}
+
+type CachedRows = readonly Record<string, unknown>[];
+```
+
+The store keeps a version per key, even for a key that holds no value; a key never seen has version 0, and only `unset` changes it. `get({ key, meta })` always returns a `CacheEntry` with the key, the read annotation's `meta`, the current version and `data`, which is `{ empty: true }` on a miss. A store that matches `meta` folds the versions of whatever `meta` names into that version, and does the same when `set` compares, so an `invalidate({ meta })` refuses an overlapping read's `set` even for a key the store has never seen. `set(entry, value)` stores `value` if and only if the key's version still equals `entry.version`, and returns whether it stored; there is no unconditional write, so a prefill is `get` then `set`. `unset` removes every value named in `keys` (`undefined` or non-empty) and every value that matches `meta`, increments the version of every key it removes or would remove, and an `unset` by key also drops that key from any `meta` index. `set` must be atomic against `unset`: one synchronous step in memory, or one script on a server. Keep a moved version at least as long as a read can take; the default store keeps it for `ttlMs`. The store interprets `meta` in all three methods; the middleware never does. A store that cannot act on a `meta` given to `unset` must throw: the default store throws `RUNTIME.CACHE_STORE_META_UNSUPPORTED`. `unset` must not run queries through the runtime that uses the middleware. A store used with this middleware holds rows: `createCacheMiddleware` takes a `CacheStore<TMeta, CachedRows>`, and a store of any other value type, `unknown` included, is a type error. `TValue` defaults to `CachedRows`, so `CacheStore<TMeta>` is a store of rows; it exists so the same store type can serve other caches. The default store, `createInMemoryCacheStore()`, holds rows unless you give it another value type.
+
+## Typed meta
+
+`CacheStore<TMeta>`, `createCacheMiddleware` and `cacheAnnotation<TMeta>` take the shape of `meta` as a type parameter; it defaults to `unknown`. `createCacheMiddleware` infers it from the store, so `invalidate` accepts only that shape:
+
+```typescript
+interface TagMeta {
+  tags: string[];
+}
+
+class TagStore implements CacheStore<TagMeta> {
+  // get({ key, meta }), set(entry, value) and unset({ keys, meta }), with meta: TagMeta | undefined
+}
+
+const cache = createCacheMiddleware({ store: new TagStore() }); // CacheMiddleware<TagMeta>
+await cache.invalidate({ meta: { tags: ['users'] } }); // compiles
+await cache.invalidate({ meta: { tag: 'users' } }); // type error
+```
+
+Nothing ties the annotation's `TMeta` to the store's at compile time, because the annotation is written where the query is and the store where the middleware is set up. A store package should therefore export a wrapper typed with its own meta, so the two agree:
+
+```typescript
+export const cached = (o: CacheAnnotationOptions<TagMeta>) => cacheAnnotation<TagMeta>(o);
+```
+
+## Deriving keys
+
+`createCacheMiddleware({ deriveKey })` computes the key of every cached read whose annotation has no `key`. Build on the default to add a prefix:
+
+```ts
+const cache = createCacheMiddleware({
+  deriveKey: async (exec, ctx) => `users:${await deriveKeyFromContentHash(exec, ctx)}`,
+});
+```
+
+An explicit annotation `key` is used literally and bypasses `deriveKey`, so a tenant or namespace prefix must be part of it too. A derivation that returns the same key for different plans serves one plan's rows to the other, and one that drops the content hash no longer changes on a schema migration. If `deriveKey` throws, the read fails.
+
+## Invalidation
+
+`invalidate({ keys?, meta? })` removes entries through one `store.unset({ keys, meta })` call, and does nothing when there are no keys and no `meta`.
+
+```ts
+const cache = createCacheMiddleware();
+
+await db.orm.public.User.first({ id: 1 }, (meta) =>
+  meta.annotate(cacheAnnotation({ key: 'user-1' })),
+);
+
+await db.orm.public.User.where({ id: 1 }).update({ name: 'Alicia' });
+await cache.invalidate({ keys: ['user-1'] });
+```
+
+A read that missed before an `invalidate` and finishes after it does not store its rows. Its `store.get` returned an empty entry with, say, version 3; the `unset` moves the key to version 4; `store.set(entry, rows)` then returns `false`. This works across processes that share a store, because the store owns the version. Call `invalidate` after the write has committed: inside a transaction, another request can put the old rows back in the cache before the commit. An error from the store propagates.
+
+A tag scheme is a store policy: `cacheAnnotation({ meta: { tags: ['users'] } })` on the read, a store that indexes `meta.tags` in `set`, and `cache.invalidate({ meta: { tags: ['users'] } })` after the write.
+
+## Scope
+
+The middleware is a read-through cache with a control surface: keys and `deriveKey`, `meta`, `bypass`, `invalidate`, and the `CacheStore` interface. It carries data between the annotations and the store and never interprets it. Lifetime and the meaning of `meta` are the store's; deciding what to invalidate and when, request coalescing and routing between several stores belong in extensions built on these primitives.
+
+Invalidating as part of a write is not supported yet: it must wait for the transaction to commit, including the transactions the ORM opens for its own `update()` and `delete()`, and the runtime has no post-commit hook. Until then, call `invalidate` after the write returns. Serve-stale strategies such as stale-while-revalidate need the hit-or-miss decision, which only the middleware makes.

package/dist/index.d.mts

@@ -1,219 +1,223 @@
-import { CrossFamilyMiddleware } from "@prisma/orm-framework/components/runtime";
+import { AnnotationHandle, AnnotationValue, CrossFamilyMiddleware, ExecutionPlan, RuntimeMiddlewareContext } from "@prisma/orm-framework/components/runtime";
 //#region ../../../3-extensions/middleware-cache/dist/index.d.mts
 //#region src/cache-annotation.d.ts
 /**
- * Payload accepted when calling the `cacheAnnotation` handle.
- *
- * - `ttl` — Time-to-live for the cached entry, in milliseconds. When
- *   omitted, the cache middleware passes the query through untouched —
- *   presence of the annotation alone is not sufficient to enable caching.
- *   This makes the cache strictly opt-in per query.
- * - `skip` — When `true`, the cache middleware passes the query through
- *   untouched even if a `ttl` is set. Useful for selectively bypassing
- *   the cache on a per-call basis without removing the annotation
- *   entirely (e.g. a "force refresh" knob in user code).
- * - `key` — Per-query override of the cache key. When supplied, replaces
- *   the default `RuntimeMiddlewareContext.contentHash(exec)` digest.
- *   The supplied string is stored as-is — the cache middleware does
- *   **not** rehash it, so the caller is responsible for ensuring the
- *   string is bounded in size and free of sensitive data they do not
- *   want flowing into logs / Redis `KEYS` / persistence dumps.
+ * Options for a read annotated with `cacheAnnotation`. A read with the annotation, in runtime scope
+ * and not bypassed, is cached; how long the entry lives is the store's policy.
+ *
+ * - `key` — the entry's key. When absent, the middleware's `deriveKey` computes it. The key is
+ *   stored and logged as given, so keep it bounded and free of secrets.
+ * - `meta` — any value, passed by reference to the store's `set` with the entry. The middleware
+ *   never reads it. Stores use it to group entries (for example by tag) or to set a lifetime.
+ * - `bypass` — when `true`, the read neither reads from nor writes to the cache.
+ *
+ * `TMeta` is the shape of `meta`; pass the store's `TMeta` so the two agree.
  */
-interface CachePayload {
-  readonly ttl?: number;
-  readonly skip?: boolean;
+interface CacheAnnotationOptions<TMeta = unknown> {
   readonly key?: string;
+  readonly meta?: TMeta;
+  readonly bypass?: boolean;
 }
 /**
- * Read-only annotation handle for the cache middleware.
- *
- * Declared with `applicableTo: ['read']`. Write terminals supply
- * `K = 'write'` to the type-level `ValidAnnotations<'write', As>` gate
- * (and the runtime `assertAnnotationsApplicable(annotations, 'write', ...)`
- * check); the join `K extends Kinds` fails for this annotation, making
- * "cache a mutation" structurally impossible without an `as any` cast
- * bypass at both type *and* runtime levels.
+ * The type of `cacheAnnotation`: a call generic in `TMeta`, plus the read-only `namespace`,
+ * `applicableTo` and `read` of the underlying annotation handle.
+ */
+type CacheAnnotationHandle = (<TMeta = unknown>(options: CacheAnnotationOptions<TMeta>) => AnnotationValue<CacheAnnotationOptions, 'read'>) & {
+  readonly namespace: string;
+  readonly applicableTo: ReadonlySet<'read'>;
+  readonly read: AnnotationHandle<CacheAnnotationOptions, 'read'>['read'];
+};
+/**
+ * Marks a read for the cache middleware. It applies to reads only: a write terminal refuses it at
+ * compile time and at run time. The middleware reads it from `plan.meta.annotations.cache`.
  *
- * Stored under namespace `'cache'` in `plan.meta.annotations`. The cache
- * middleware reads it via `cacheAnnotation.read(plan)`.
+ * `TMeta` types `meta` for this call only. Nothing ties it to the store's `TMeta`, so a store
+ * package should export a wrapper typed with its own meta, such as
+ * `(o: CacheAnnotationOptions<TagMeta>) => cacheAnnotation<TagMeta>(o)`.
  *
  * @example
  * ```typescript
  * import { cacheAnnotation } from '@internal/middleware-cache';
  *
  * // ORM read terminal — accepts the read-only annotation via the meta callback.
- * const user = await db.User.first(
+ * const user = await db.orm.public.User.first(
  *   { id },
- *   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),
+ *   (meta) => meta.annotate(cacheAnnotation({ key: `user-${id}` })),
  * );
  *
  * // SQL DSL select builder — chainable.
  * const plan = db.sql
  *   .from(tables.user)
- *   .annotate(cacheAnnotation({ ttl: 60_000 }))
+ *   .annotate(cacheAnnotation({}))
  *   .select({ id: tables.user.columns.id })
  *   .build();
  * ```
  */
-declare const cacheAnnotation: import("@prisma/orm-framework/components/runtime").AnnotationHandle<CachePayload, "read">;
+declare const cacheAnnotation: CacheAnnotationHandle;
 //#endregion
 //#region src/cache-store.d.ts
 /**
- * A cached set of rows produced by a single execution.
- *
- * - `rows` are stored raw (undecoded). The SQL runtime's `decodeRow` pass
- *   wraps the orchestrator output, so intercepted rows go through the
- *   same codec decoding as driver rows on the way to the consumer. The
- *   cache stores wire-format values; decoding happens once per consumer
- *   read regardless of where the rows came from.
- * - `storedAt` is the clock value at the moment the entry was committed
- *   to the store. It is informational metadata for callers (debugging,
- *   telemetry) and is **not** used by the in-memory store itself for
- *   expiry — TTL is driven by the store's own clock plus the `ttlMs`
- *   passed to `set`. Custom stores may use it differently.
+ * The rows one read produced, stored raw (undecoded): the value type the cache middleware stores.
+ * The SQL runtime decodes intercepted rows the same way as driver rows, so a hit and a miss yield
+ * the same values to the consumer.
  */
-interface CachedEntry {
-  readonly rows: readonly Record<string, unknown>[];
-  readonly storedAt: number;
+type CachedRows = readonly Record<string, unknown>[];
+/**
+ * One key of a `CacheStore`, as `get` saw it.
+ *
+ * - `key` and `meta` — what `get` was asked for. `meta` is the read annotation's `meta`, or
+ *   `undefined`.
+ * - `version` — the key's version when `get` ran. A store that matches `meta` folds the versions
+ *   of whatever `meta` names into it.
+ * - `data` — `{ empty: true }` when the store holds no live value for the key, otherwise that
+ *   value.
+ */
+interface CacheEntry<TMeta = unknown, TValue = CachedRows> {
+  readonly key: string;
+  readonly meta: TMeta | undefined;
+  readonly version: number;
+  readonly data: {
+    readonly empty: true;
+  } | {
+    readonly empty: false;
+    readonly value: TValue;
+  };
 }
 /**
- * Pluggable cache backend used by the cache middleware.
- *
- * The default implementation is an in-memory LRU with TTL produced by
- * `createInMemoryCacheStore`. Users can supply Redis, Memcached, or any
- * other backend by implementing this interface.
- *
- * The interface is intentionally minimal:
- *
- * - `get` returns the entry if it exists and has not expired, or
- *   `undefined` otherwise. Implementations that gate on TTL should
- *   treat an expired entry as absent (return `undefined`) and may
- *   evict it as a side effect.
- * - `set` writes the entry under the key with an associated TTL in
- *   milliseconds. Implementations may evict other entries to make
- *   room (LRU, LFU, etc.) and may treat the operation as fire-and-
- *   forget at scale; the cache middleware does not rely on `set`
- *   completing before subsequent `get`s.
- *
- * Both methods are async to leave the door open for I/O-backed stores
- * (Redis, S3, etc.). The default in-memory store completes
- * synchronously and wraps the result in `Promise.resolve` for type
- * conformance.
+ * A cache of values that the cache middleware reads from and writes to. The middleware stores
+ * `CachedRows`.
+ *
+ * The store keeps a version per key, an integer it keeps even for a key that holds no value. A key
+ * never seen, or forgotten, has version 0. Only `unset` changes a version.
+ *
+ * - `get` always returns an entry: the live value or `{ empty: true }`, and the current version.
+ *   A store that matches `meta` folds the versions of whatever `meta` names into that version, and
+ *   does the same when `set` compares, so an `unset` by `meta` refuses a read's `set` even for a
+ *   key it has never seen.
+ * - `set(entry, value)` stores `value` under `entry.key` with `entry.meta`, if and only if the
+ *   key's current version still equals `entry.version`, and returns whether it stored. `entry` is
+ *   the one `get` returned, empty or not. There is no unconditional write: to prefill, `get` then
+ *   `set`. The compare and the write must be atomic with respect to `unset`, for example one
+ *   synchronous step in memory or one script on a server.
+ * - `unset` removes every value named in `keys` and every value that matches `meta`, and
+ *   increments the version of every key it removes or would remove, including keys that hold no
+ *   value. `keys` is `undefined` or non-empty. A store that cannot act on a `meta` it is given
+ *   must throw rather than ignore it. An `unset` by key must also drop that key from any `meta`
+ *   index the store keeps.
+ *
+ * Lifetime and eviction are the store's policy. A version that `unset` moved must be kept at least
+ * as long as a read can take, so that a read that started before the `unset` cannot store. `unset`
+ * must not run queries through the runtime that uses the middleware.
+ *
+ * `TMeta` is the shape of `meta` the store understands. The middleware does not check that a read
+ * annotation's `meta` has this shape; see `cacheAnnotation`.
  */
-interface CacheStore {
-  get(key: string): Promise<CachedEntry | undefined>;
-  set(key: string, entry: CachedEntry, ttlMs: number): Promise<void>;
+interface CacheStore<TMeta = unknown, TValue = CachedRows> {
+  get(target: {
+    readonly key: string;
+    readonly meta: TMeta | undefined;
+  }): Promise<CacheEntry<TMeta, TValue>>;
+  set(entry: CacheEntry<TMeta, TValue>, value: TValue): Promise<boolean>;
+  unset(target: {
+    readonly keys: readonly string[] | undefined;
+    readonly meta: TMeta | undefined;
+  }): Promise<void>;
 }
 /**
- * Options accepted by `createInMemoryCacheStore`.
- *
- * - `maxEntries` — hard cap on the number of live entries. Once the cap
- *   is exceeded, the least recently used entry is evicted. Reads and
- *   writes both count as "uses" for ordering purposes.
- * - `clock` — injectable time source for TTL math. Defaults to
- *   `Date.now`. Tests inject a controlled clock to verify expiry without
- *   real-time waits.
+ * Options for `createInMemoryCacheStore`.
+ *
+ * - `maxEntries` — the most values kept, a positive integer; the least recently used is evicted
+ *   first. Default 1000.
+ * - `ttlMs` — how long a value lives after its `set`, and how long a key's version is kept after
+ *   the `unset` that moved it, a positive number of milliseconds. Default 60 000. Versions are not
+ *   bounded by `maxEntries`. A forgotten version reads as 0, so a read that takes longer than
+ *   `ttlMs` and overlaps an `invalidate` can store stale rows. `Infinity` never expires values or
+ *   versions: the versions of invalidated keys are never forgotten, and grow with the number of
+ *   distinct keys invalidated.
+ * - `clock` — the time source for expiry. Default `Date.now`.
  */
 interface InMemoryCacheStoreOptions {
-  readonly maxEntries: number;
+  readonly maxEntries?: number;
+  readonly ttlMs?: number;
   readonly clock?: () => number;
 }
 /**
- * Default cache backend. An LRU with per-entry TTL, backed by a `Map`.
- *
- * Eviction policy:
- *
- * - On `set` of a fresh key whose insertion would push the live count
- *   above `maxEntries`, the least recently used entry is evicted.
- *   Setting an existing key updates the entry in place and refreshes its
- *   recency without changing the live count.
- * - On `get` of an existing key, recency is bumped (so the entry is no
- *   longer the LRU candidate).
- * - On `get` of an expired entry, the entry is removed from the map and
- *   `undefined` is returned. The slot becomes available for new writes
- *   without counting against `maxEntries`.
- *
- * `Map` insertion order is the LRU order: the first key is the LRU
- * candidate; the last key is the most recently used. Bumping recency is
- * a delete-then-set on the underlying map.
- *
- * The default store is **not** coherent across processes or replicas —
- * each process holds its own Map. Users who need a shared cache supply
- * their own `CacheStore` (Redis, Memcached, etc.).
+ * The default cache store: a least-recently-used map with one lifetime for every value, local to
+ * the process. It holds `CachedRows` unless given another `TValue`. A key's version is kept for
+ * `ttlMs` after the `unset` that moved it (see `InMemoryCacheStoreOptions`). It ignores `meta` in
+ * `get` and `set`, and its `unset` rejects any `meta`, including `null`, before changing anything.
+ * It throws `RUNTIME.ARGUMENT_INVALID` for a `maxEntries` or `ttlMs` outside the ranges above.
  */
-declare function createInMemoryCacheStore(options: InMemoryCacheStoreOptions): CacheStore;
+declare function createInMemoryCacheStore<TMeta = unknown, TValue = CachedRows>(options?: InMemoryCacheStoreOptions): CacheStore<TMeta, TValue>;
 //#endregion
 //#region src/cache-middleware.d.ts
 /**
  * Options accepted by `createCacheMiddleware`.
  *
- * - `store` — pluggable cache backend. Defaults to an in-process LRU
- *   produced by `createInMemoryCacheStore`. Users supply Redis,
- *   Memcached, or any other backend by implementing the `CacheStore`
- *   interface.
- * - `maxEntries` — only consulted when `store` is omitted. Sets the
- *   `maxEntries` cap on the default in-memory store. Defaults to 1000.
- * - `clock` — injectable time source for `storedAt` stamping on
- *   committed entries. Defaults to `Date.now`. Tests inject a controlled
- *   clock to make commit-time observable. Note: TTL math lives inside
- *   the store, not the middleware — supplying a clock here only affects
- *   the `storedAt` field on committed `CachedEntry` values.
+ * - `store` — the cache backend. Defaults to `createInMemoryCacheStore()`: 1000 values, 60 s.
+ * - `deriveKey` — computes the key of a cached read whose annotation has no `key`. Defaults to
+ *   `deriveKeyFromContentHash`. It runs on every such read, hit or miss, and an error from it
+ *   fails the read. It must return different keys whenever the rows can differ; build on
+ *   `deriveKeyFromContentHash` to keep the statement, parameters and storage hash.
+ *
+ * `TMeta` is the store's meta type; `createCacheMiddleware` infers it from `store`. The store holds
+ * `CachedRows`.
  */
-interface CacheMiddlewareOptions {
-  readonly store?: CacheStore;
-  readonly maxEntries?: number;
-  readonly clock?: () => number;
+interface CacheMiddlewareOptions<TMeta = unknown> {
+  readonly store?: CacheStore<TMeta, CachedRows>;
+  readonly deriveKey?: (exec: ExecutionPlan, ctx: RuntimeMiddlewareContext) => string | Promise<string>;
 }
 /**
- * Creates a family-agnostic caching middleware.
- *
- * The middleware uses three hooks:
- *
- * - `interceptQuery` — on each execution, checks the cache. On a hit, returns
- *   the cached raw rows; the runtime skips `runDriver` and `onRow`
- *   (`beforeQuery` is not affected — it has already run for every
- *   middleware before any `interceptQuery` is consulted) and yields the
- *   cached rows to the consumer (which, in the SQL runtime, sees them
- *   after the standard `decodeRow` pass — i.e. the cache stores
- *   wire-format values). On a miss, records a pending buffer keyed on
- *   the `exec` object identity and returns `undefined` (passthrough).
- * - `onRow` — on the miss path, appends each row yielded by the driver
- *   to the pending buffer.
- * - `afterQuery` — on the miss path, commits the buffer to the store
- *   if and only if `result.completed === true && result.source === 'driver'`.
- *   Failed executions and middleware-served executions never populate
- *   the cache. The pending buffer is cleared in all branches so a stale
- *   `WeakMap` entry cannot leak between executions sharing an `exec`.
- *
- * The middleware bypasses the cache entirely when:
- * - the plan has no `cache` annotation, or
- * - the annotation has `skip: true`, or
- * - the annotation has no `ttl`, or
- * - `ctx.scope !== 'runtime'` (connection / transaction scopes opt out).
- *
- * Returns a cross-family `RuntimeMiddleware` (no `familyId` /
- * `targetId`). The package depends only on
- * `@internal/framework-components/runtime`; cache keys come from
- * `ctx.contentHash(exec)`, populated by the family runtime, so SQL and
- * Mongo runtimes both work out of the box.
+ * The cache middleware.
+ *
+ * `invalidate` removes entries through one `store.unset({ keys, meta })` call. It does nothing
+ * when `keys` is empty or absent and `meta` is absent. The store moves the version of every key it
+ * removes, so a read that missed before the call and finishes after it does not store its rows:
+ * its conditional `store.set` returns `false`. This holds across processes that share a store. An
+ * error from the store propagates.
+ *
+ * `TMeta` is the store's meta type, which `invalidate`'s `meta` must have.
+ */
+type CacheMiddleware<TMeta = unknown> = CrossFamilyMiddleware & {
+  readonly invalidate: (target: {
+    readonly keys?: readonly string[];
+    readonly meta?: TMeta;
+  }) => Promise<void>;
+};
+/**
+ * The default `deriveKey`: the family runtime's content hash of the plan, which covers the
+ * statement, its parameters and the storage hash.
+ */
+declare function deriveKeyFromContentHash(exec: ExecutionPlan, ctx: RuntimeMiddlewareContext): Promise<string>;
+/**
+ * Creates a read-through cache middleware that works with every family runtime.
+ *
+ * It caches a read when the plan carries `cacheAnnotation`, the annotation does not set
+ * `bypass`, and the read runs in runtime scope (not inside a connection or transaction). The key
+ * is the annotation's `key`, else `deriveKey(exec, ctx)`.
+ *
+ * - `interceptQuery` — on a hit, returns the stored rows and the driver does not run. On a miss,
+ *   starts collecting rows.
+ * - `onRow` — collects each row of a miss.
+ * - `afterQuery` — when the driver completed the read, calls `store.set(entry, rows)` with the
+ *   entry `store.get` returned, which stores only if the key's version has not moved. If an
+ *   `unset` moved it meanwhile, `set` returns `false` and the middleware logs
+ *   `middleware.cache.store-skipped`.
  *
  * @example
  * ```typescript
- * import { createCacheMiddleware, cacheAnnotation } from '@internal/middleware-cache';
+ * const cache = createCacheMiddleware();
+ * const db = postgres<Contract>({ contractJson, url, middleware: [cache] });
  *
- * const db = postgres({
- *   contractJson,
- *   url: process.env['DATABASE_URL']!,
- *   middleware: [createCacheMiddleware({ maxEntries: 1000 })],
- * });
- *
- * const user = await db.User.first(
- *   { id },
- *   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),
+ * const user = await db.orm.public.User.first(
+ *   { id: 1 },
+ *   (meta) => meta.annotate(cacheAnnotation({ key: 'user-1' })),
  * );
+ * await db.orm.public.User.where({ id: 1 }).update({ name: 'Alicia' });
+ * await cache.invalidate({ keys: ['user-1'] });
  * ```
  */
-declare function createCacheMiddleware(options?: CacheMiddlewareOptions): CrossFamilyMiddleware;
+declare function createCacheMiddleware<TMeta = unknown>(options?: CacheMiddlewareOptions<TMeta>): CacheMiddleware<TMeta>;
 //#endregion
-export { type CacheMiddlewareOptions, type CachePayload, type CacheStore, type CachedEntry, type InMemoryCacheStoreOptions, cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore };
+export { type CacheAnnotationHandle, type CacheAnnotationOptions, type CacheEntry, type CacheMiddleware, type CacheMiddlewareOptions, type CacheStore, type CachedRows, type InMemoryCacheStoreOptions, cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore, deriveKeyFromContentHash };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../3-extensions/middleware-cache/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;UAoBU;WACC;WACA;WACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAiCG,kEAAkE,iBAAiB;;;;;;;;;;;;;;;;;UAiBvF;WACC,eAAe;WACf;;;;;;;;;;;;;;;;;;;;;;;;;;UA0BD;EACR,IAAI,cAAc,QAAQ;EAC1B,IAAI,aAAa,OAAO,aAAa,gBAAgB;;;;;;;;;;;;UAY7C;WACC;WACA;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBM,yBAAyB,SAAS,4BAA4B;;;;;;;;;;;;;;;;;;UAkBrE;WACC,QAAQ;WACR;WACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDM,sBAAsB,UAAU,yBAAyB"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../../../3-extensions/middleware-cache/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;UAcU,uBAAuB;WACtB;WACA,OAAO;WACP;;;;;;KAMN,0BAA0B,iBAAiB,SAAS,uBAAuB,WAAW,gBAAgB;WAChG;WACA,cAAc;WACd,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BpB,iBAAiB;;;;;;;;KAQ1B,sBAAsB;;;;;;;;;;;UAWjB,WAAW,iBAAiB,SAAS;WACpC;WACA,MAAM;WACN;WACA;aACE;;aAEA;aACA,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAgCV,WAAW,iBAAiB,SAAS;EAC7C,IAAI;aACO;aACA,MAAM;MACb,QAAQ,WAAW,OAAO;EAC9B,IAAI,OAAO,WAAW,OAAO,SAAS,OAAO,SAAS;EACtD,MAAM;aACK;aACA,MAAM;MACb;;;;;;;;;;;;;;;UAeI;WACC;WACA;WACA;;;;;;;;;iBASM,yBAAyB,iBAAiB,SAAS,YAAY,UAAU,4BAA4B,WAAW,OAAO;;;;;;;;;;;;;;;UAe9H,uBAAuB;WACtB,QAAQ,WAAW,OAAO;WAC1B,aAAa,MAAM,eAAe,KAAK,sCAAsC;;;;;;;;;;;;;KAanF,gBAAgB,mBAAmB;WAC7B,aAAa;aACX;aACA,OAAO;QACZ;;;;;;iBAMS,yBAAyB,MAAM,eAAe,KAAK,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6B9E,sBAAsB,iBAAiB,UAAU,uBAAuB,SAAS,gBAAgB"}

package/dist/index.mjs

@@ -1,207 +1,194 @@
 import { defineAnnotation } from "@prisma/orm-framework/components/runtime";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 //#region ../../../3-extensions/middleware-cache/dist/index.mjs
 /**
-* Read-only annotation handle for the cache middleware.
+* Marks a read for the cache middleware. It applies to reads only: a write terminal refuses it at
+* compile time and at run time. The middleware reads it from `plan.meta.annotations.cache`.
 *
-* Declared with `applicableTo: ['read']`. Write terminals supply
-* `K = 'write'` to the type-level `ValidAnnotations<'write', As>` gate
-* (and the runtime `assertAnnotationsApplicable(annotations, 'write', ...)`
-* check); the join `K extends Kinds` fails for this annotation, making
-* "cache a mutation" structurally impossible without an `as any` cast
-* bypass at both type *and* runtime levels.
-*
-* Stored under namespace `'cache'` in `plan.meta.annotations`. The cache
-* middleware reads it via `cacheAnnotation.read(plan)`.
+* `TMeta` types `meta` for this call only. Nothing ties it to the store's `TMeta`, so a store
+* package should export a wrapper typed with its own meta, such as
+* `(o: CacheAnnotationOptions<TagMeta>) => cacheAnnotation<TagMeta>(o)`.
 *
 * @example
 * ```typescript
 * import { cacheAnnotation } from '@internal/middleware-cache';
 *
 * // ORM read terminal — accepts the read-only annotation via the meta callback.
-* const user = await db.User.first(
+* const user = await db.orm.public.User.first(
 *   { id },
-*   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),
+*   (meta) => meta.annotate(cacheAnnotation({ key: `user-${id}` })),
 * );
 *
 * // SQL DSL select builder — chainable.
 * const plan = db.sql
 *   .from(tables.user)
-*   .annotate(cacheAnnotation({ ttl: 60_000 }))
+*   .annotate(cacheAnnotation({}))
 *   .select({ id: tables.user.columns.id })
 *   .build();
 * ```
 */
-const cacheAnnotation = defineAnnotation()({
+const cacheAnnotation = withTypedMeta(defineAnnotation()({
 	namespace: "cache",
 	applicableTo: ["read"]
-});
+}));
+function withTypedMeta(handle) {
+	function cacheAnnotationWithMeta(options) {
+		return handle(options);
+	}
+	return Object.freeze(Object.assign(cacheAnnotationWithMeta, {
+		namespace: handle.namespace,
+		applicableTo: handle.applicableTo,
+		read: handle.read
+	}));
+}
+function metaUnsupported() {
+	return structuredError("RUNTIME.CACHE_STORE_META_UNSUPPORTED", "The in-memory cache store cannot remove entries by meta because it does not index meta", { fix: "Invalidate by keys, or supply a CacheStore that indexes meta in set and unset." });
+}
+function invalidOption(argument, received, expected) {
+	return structuredError("RUNTIME.ARGUMENT_INVALID", `createInMemoryCacheStore: ${argument} must be ${expected}`, {
+		fix: `Pass ${argument} as ${expected}, or leave it unset for the default.`,
+		meta: {
+			helper: "createInMemoryCacheStore",
+			argument,
+			received
+		}
+	});
+}
 /**
-* Default cache backend. An LRU with per-entry TTL, backed by a `Map`.
-*
-* Eviction policy:
-*
-* - On `set` of a fresh key whose insertion would push the live count
-*   above `maxEntries`, the least recently used entry is evicted.
-*   Setting an existing key updates the entry in place and refreshes its
-*   recency without changing the live count.
-* - On `get` of an existing key, recency is bumped (so the entry is no
-*   longer the LRU candidate).
-* - On `get` of an expired entry, the entry is removed from the map and
-*   `undefined` is returned. The slot becomes available for new writes
-*   without counting against `maxEntries`.
-*
-* `Map` insertion order is the LRU order: the first key is the LRU
-* candidate; the last key is the most recently used. Bumping recency is
-* a delete-then-set on the underlying map.
-*
-* The default store is **not** coherent across processes or replicas —
-* each process holds its own Map. Users who need a shared cache supply
-* their own `CacheStore` (Redis, Memcached, etc.).
+* The default cache store: a least-recently-used map with one lifetime for every value, local to
+* the process. It holds `CachedRows` unless given another `TValue`. A key's version is kept for
+* `ttlMs` after the `unset` that moved it (see `InMemoryCacheStoreOptions`). It ignores `meta` in
+* `get` and `set`, and its `unset` rejects any `meta`, including `null`, before changing anything.
+* It throws `RUNTIME.ARGUMENT_INVALID` for a `maxEntries` or `ttlMs` outside the ranges above.
 */
 function createInMemoryCacheStore(options) {
-	const maxEntries = options.maxEntries;
-	const clock = options.clock ?? Date.now;
-	const map = /* @__PURE__ */ new Map();
-	function get(key) {
-		const record = map.get(key);
-		if (record === void 0) return Promise.resolve(void 0);
-		if (clock() >= record.expiresAt) {
-			map.delete(key);
-			return Promise.resolve(void 0);
+	const maxEntries = options?.maxEntries ?? 1e3;
+	const ttlMs = options?.ttlMs ?? 6e4;
+	const clock = options?.clock ?? Date.now;
+	if (!Number.isInteger(maxEntries) || maxEntries <= 0) throw invalidOption("maxEntries", maxEntries, "a positive integer");
+	if (!(ttlMs > 0)) throw invalidOption("ttlMs", ttlMs, "a positive number of milliseconds, or Infinity");
+	const records = /* @__PURE__ */ new Map();
+	const versions = /* @__PURE__ */ new Map();
+	function forgetExpiredVersions() {
+		const now = clock();
+		for (const [key, record] of versions) {
+			if (now < record.expiresAt) return;
+			versions.delete(key);
 		}
-		map.delete(key);
-		map.set(key, record);
-		return Promise.resolve(record.entry);
 	}
-	function set(key, entry, ttlMs) {
-		const expiresAt = clock() + ttlMs;
-		if (map.has(key)) map.delete(key);
-		map.set(key, {
-			entry,
-			expiresAt
+	function versionOf(key) {
+		forgetExpiredVersions();
+		return versions.get(key)?.version ?? 0;
+	}
+	function liveRecord(key) {
+		const record = records.get(key);
+		if (record === void 0) return;
+		records.delete(key);
+		if (clock() >= record.expiresAt) return;
+		records.set(key, record);
+		return record;
+	}
+	async function get(target) {
+		const record = liveRecord(target.key);
+		return {
+			key: target.key,
+			meta: target.meta,
+			version: versionOf(target.key),
+			data: record === void 0 ? { empty: true } : {
+				empty: false,
+				value: record.value
+			}
+		};
+	}
+	async function set(entry, value) {
+		if (entry.version !== versionOf(entry.key)) return false;
+		records.delete(entry.key);
+		records.set(entry.key, {
+			value,
+			expiresAt: clock() + ttlMs
 		});
-		while (map.size > maxEntries) {
-			const oldest = map.keys().next();
-			if (oldest.done) break;
-			map.delete(oldest.value);
+		for (const leastRecentlyUsed of records.keys()) {
+			if (records.size <= maxEntries) break;
+			records.delete(leastRecentlyUsed);
+		}
+		return true;
+	}
+	async function unset(target) {
+		if (target.meta !== void 0) throw metaUnsupported();
+		for (const key of target.keys ?? []) {
+			records.delete(key);
+			const version = versionOf(key) + 1;
+			versions.delete(key);
+			versions.set(key, {
+				version,
+				expiresAt: clock() + ttlMs
+			});
 		}
-		return Promise.resolve();
 	}
 	return {
 		get,
-		set
+		set,
+		unset
 	};
 }
 /**
-* Default `maxEntries` for the built-in in-memory store. Bounded so a
-* runaway producer cannot exhaust process memory; users who need
-* different bounds supply a custom `CacheStore`.
-*/
-const DEFAULT_MAX_ENTRIES = 1e3;
-/**
-* Reads the cache payload from the plan, if present and branded.
-*
-* Returns `undefined` when:
-* - the plan has no `meta.annotations`, or
-* - the `cache` namespace key is absent, or
-* - the value under `cache` is not a branded `AnnotationValue` (the
-*   `cacheAnnotation.read` defensive check covers this).
-*/
-function readCachePayload(plan) {
-	return cacheAnnotation.read(plan);
-}
-/**
-* Computes the cache key for an execution.
-*
-* Two-tier resolution:
-*
-* 1. Per-query override: `cacheAnnotation({ key })` — the supplied
-*    string is used verbatim. Not rehashed; the user is responsible for
-*    keeping the string bounded and free of sensitive data.
-* 2. Default: `ctx.contentHash(exec)` — the family runtime owns this and
-*    returns an opaque, bounded digest (SHA-512 in the SQL and Mongo
-*    runtimes today).
-*
-* The returned string is consumed directly as the `Map<string, …>` key
-* by the underlying `CacheStore`; the cache middleware does not perform
-* any further transformation.
+* The default `deriveKey`: the family runtime's content hash of the plan, which covers the
+* statement, its parameters and the storage hash.
 */
-async function resolveCacheKey(payload, exec, ctx) {
-	if (payload.key !== void 0) return payload.key;
+function deriveKeyFromContentHash(exec, ctx) {
 	return ctx.contentHash(exec);
 }
 /**
-* Creates a family-agnostic caching middleware.
-*
-* The middleware uses three hooks:
-*
-* - `interceptQuery` — on each execution, checks the cache. On a hit, returns
-*   the cached raw rows; the runtime skips `runDriver` and `onRow`
-*   (`beforeQuery` is not affected — it has already run for every
-*   middleware before any `interceptQuery` is consulted) and yields the
-*   cached rows to the consumer (which, in the SQL runtime, sees them
-*   after the standard `decodeRow` pass — i.e. the cache stores
-*   wire-format values). On a miss, records a pending buffer keyed on
-*   the `exec` object identity and returns `undefined` (passthrough).
-* - `onRow` — on the miss path, appends each row yielded by the driver
-*   to the pending buffer.
-* - `afterQuery` — on the miss path, commits the buffer to the store
-*   if and only if `result.completed === true && result.source === 'driver'`.
-*   Failed executions and middleware-served executions never populate
-*   the cache. The pending buffer is cleared in all branches so a stale
-*   `WeakMap` entry cannot leak between executions sharing an `exec`.
+* Creates a read-through cache middleware that works with every family runtime.
 *
-* The middleware bypasses the cache entirely when:
-* - the plan has no `cache` annotation, or
-* - the annotation has `skip: true`, or
-* - the annotation has no `ttl`, or
-* - `ctx.scope !== 'runtime'` (connection / transaction scopes opt out).
+* It caches a read when the plan carries `cacheAnnotation`, the annotation does not set
+* `bypass`, and the read runs in runtime scope (not inside a connection or transaction). The key
+* is the annotation's `key`, else `deriveKey(exec, ctx)`.
 *
-* Returns a cross-family `RuntimeMiddleware` (no `familyId` /
-* `targetId`). The package depends only on
-* `@internal/framework-components/runtime`; cache keys come from
-* `ctx.contentHash(exec)`, populated by the family runtime, so SQL and
-* Mongo runtimes both work out of the box.
+* - `interceptQuery` — on a hit, returns the stored rows and the driver does not run. On a miss,
+*   starts collecting rows.
+* - `onRow` — collects each row of a miss.
+* - `afterQuery` — when the driver completed the read, calls `store.set(entry, rows)` with the
+*   entry `store.get` returned, which stores only if the key's version has not moved. If an
+*   `unset` moved it meanwhile, `set` returns `false` and the middleware logs
+*   `middleware.cache.store-skipped`.
 *
 * @example
 * ```typescript
-* import { createCacheMiddleware, cacheAnnotation } from '@internal/middleware-cache';
+* const cache = createCacheMiddleware();
+* const db = postgres<Contract>({ contractJson, url, middleware: [cache] });
 *
-* const db = postgres({
-*   contractJson,
-*   url: process.env['DATABASE_URL']!,
-*   middleware: [createCacheMiddleware({ maxEntries: 1000 })],
-* });
-*
-* const user = await db.User.first(
-*   { id },
-*   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),
+* const user = await db.orm.public.User.first(
+*   { id: 1 },
+*   (meta) => meta.annotate(cacheAnnotation({ key: 'user-1' })),
 * );
+* await db.orm.public.User.where({ id: 1 }).update({ name: 'Alicia' });
+* await cache.invalidate({ keys: ['user-1'] });
 * ```
 */
 function createCacheMiddleware(options) {
-	const store = options?.store ?? createInMemoryCacheStore({ maxEntries: options?.maxEntries ?? DEFAULT_MAX_ENTRIES });
-	const clock = options?.clock ?? Date.now;
+	const store = options?.store ?? createInMemoryCacheStore();
+	const deriveKey = options?.deriveKey ?? deriveKeyFromContentHash;
 	const pending = /* @__PURE__ */ new WeakMap();
 	async function interceptQuery(exec, ctx) {
 		if (ctx.scope !== "runtime") return;
-		const payload = readCachePayload(exec);
-		if (payload === void 0) return;
-		if (payload.skip === true) return;
-		if (payload.ttl === void 0) return;
-		const key = await resolveCacheKey(payload, exec, ctx);
-		const hit = await store.get(key);
-		if (hit !== void 0) {
+		const annotation = cacheAnnotation.read(exec);
+		if (annotation === void 0 || annotation.bypass === true) return;
+		const key = annotation.key ?? await deriveKey(exec, ctx);
+		const entry = await store.get({
+			key,
+			meta: annotation.meta
+		});
+		if (!entry.data.empty) {
 			ctx.log.debug?.({
 				event: "middleware.cache.hit",
 				middleware: "cache",
 				key
 			});
-			return { rows: hit.rows };
+			return { rows: entry.data.value };
 		}
 		pending.set(exec, {
-			key,
-			ttlMs: payload.ttl,
+			entry,
 			buffer: []
 		});
 		ctx.log.debug?.({
@@ -211,33 +198,37 @@ function createCacheMiddleware(options) {
 		});
 	}
 	async function onRow(row, exec, _ctx) {
-		const slot = pending.get(exec);
-		if (slot === void 0) return;
-		slot.buffer.push(row);
+		pending.get(exec)?.buffer.push(row);
 	}
 	async function afterQuery(exec, result, ctx) {
-		const slot = pending.get(exec);
-		if (slot === void 0) return;
+		const miss = pending.get(exec);
+		if (miss === void 0) return;
 		pending.delete(exec);
 		if (!result.completed || result.source !== "driver") return;
-		await store.set(slot.key, {
-			rows: slot.buffer,
-			storedAt: clock()
-		}, slot.ttlMs);
+		const stored = await store.set(miss.entry, miss.buffer);
 		ctx.log.debug?.({
-			event: "middleware.cache.store",
+			event: stored ? "middleware.cache.store" : "middleware.cache.store-skipped",
 			middleware: "cache",
-			key: slot.key
+			key: miss.entry.key
+		});
+	}
+	async function invalidate(target) {
+		const keys = target.keys !== void 0 && target.keys.length > 0 ? target.keys : void 0;
+		if (keys === void 0 && target.meta === void 0) return;
+		await store.unset({
+			keys,
+			meta: target.meta
 		});
 	}
 	return {
 		name: "cache",
 		interceptQuery,
 		onRow,
-		afterQuery
+		afterQuery,
+		invalidate
 	};
 }
 //#endregion
-export { cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore };
+export { cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore, deriveKeyFromContentHash };
 
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../../../3-extensions/middleware-cache/dist/index.mjs"],"sourcesContent":["import { defineAnnotation } from \"@internal/framework-components/runtime\";\n//#region src/cache-annotation.ts\n/**\n* Read-only annotation handle for the cache middleware.\n*\n* Declared with `applicableTo: ['read']`. Write terminals supply\n* `K = 'write'` to the type-level `ValidAnnotations<'write', As>` gate\n* (and the runtime `assertAnnotationsApplicable(annotations, 'write', ...)`\n* check); the join `K extends Kinds` fails for this annotation, making\n* \"cache a mutation\" structurally impossible without an `as any` cast\n* bypass at both type *and* runtime levels.\n*\n* Stored under namespace `'cache'` in `plan.meta.annotations`. The cache\n* middleware reads it via `cacheAnnotation.read(plan)`.\n*\n* @example\n* ```typescript\n* import { cacheAnnotation } from '@internal/middleware-cache';\n*\n* // ORM read terminal — accepts the read-only annotation via the meta callback.\n* const user = await db.User.first(\n*   { id },\n*   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),\n* );\n*\n* // SQL DSL select builder — chainable.\n* const plan = db.sql\n*   .from(tables.user)\n*   .annotate(cacheAnnotation({ ttl: 60_000 }))\n*   .select({ id: tables.user.columns.id })\n*   .build();\n* ```\n*/\nconst cacheAnnotation = defineAnnotation()({\n\tnamespace: \"cache\",\n\tapplicableTo: [\"read\"]\n});\n//#endregion\n//#region src/cache-store.ts\n/**\n* Default cache backend. An LRU with per-entry TTL, backed by a `Map`.\n*\n* Eviction policy:\n*\n* - On `set` of a fresh key whose insertion would push the live count\n*   above `maxEntries`, the least recently used entry is evicted.\n*   Setting an existing key updates the entry in place and refreshes its\n*   recency without changing the live count.\n* - On `get` of an existing key, recency is bumped (so the entry is no\n*   longer the LRU candidate).\n* - On `get` of an expired entry, the entry is removed from the map and\n*   `undefined` is returned. The slot becomes available for new writes\n*   without counting against `maxEntries`.\n*\n* `Map` insertion order is the LRU order: the first key is the LRU\n* candidate; the last key is the most recently used. Bumping recency is\n* a delete-then-set on the underlying map.\n*\n* The default store is **not** coherent across processes or replicas —\n* each process holds its own Map. Users who need a shared cache supply\n* their own `CacheStore` (Redis, Memcached, etc.).\n*/\nfunction createInMemoryCacheStore(options) {\n\tconst maxEntries = options.maxEntries;\n\tconst clock = options.clock ?? Date.now;\n\tconst map = /* @__PURE__ */ new Map();\n\tfunction get(key) {\n\t\tconst record = map.get(key);\n\t\tif (record === void 0) return Promise.resolve(void 0);\n\t\tif (clock() >= record.expiresAt) {\n\t\t\tmap.delete(key);\n\t\t\treturn Promise.resolve(void 0);\n\t\t}\n\t\tmap.delete(key);\n\t\tmap.set(key, record);\n\t\treturn Promise.resolve(record.entry);\n\t}\n\tfunction set(key, entry, ttlMs) {\n\t\tconst expiresAt = clock() + ttlMs;\n\t\tif (map.has(key)) map.delete(key);\n\t\tmap.set(key, {\n\t\t\tentry,\n\t\t\texpiresAt\n\t\t});\n\t\twhile (map.size > maxEntries) {\n\t\t\tconst oldest = map.keys().next();\n\t\t\tif (oldest.done) break;\n\t\t\tmap.delete(oldest.value);\n\t\t}\n\t\treturn Promise.resolve();\n\t}\n\treturn {\n\t\tget,\n\t\tset\n\t};\n}\n//#endregion\n//#region src/cache-middleware.ts\n/**\n* Default `maxEntries` for the built-in in-memory store. Bounded so a\n* runaway producer cannot exhaust process memory; users who need\n* different bounds supply a custom `CacheStore`.\n*/\nconst DEFAULT_MAX_ENTRIES = 1e3;\n/**\n* Reads the cache payload from the plan, if present and branded.\n*\n* Returns `undefined` when:\n* - the plan has no `meta.annotations`, or\n* - the `cache` namespace key is absent, or\n* - the value under `cache` is not a branded `AnnotationValue` (the\n*   `cacheAnnotation.read` defensive check covers this).\n*/\nfunction readCachePayload(plan) {\n\treturn cacheAnnotation.read(plan);\n}\n/**\n* Computes the cache key for an execution.\n*\n* Two-tier resolution:\n*\n* 1. Per-query override: `cacheAnnotation({ key })` — the supplied\n*    string is used verbatim. Not rehashed; the user is responsible for\n*    keeping the string bounded and free of sensitive data.\n* 2. Default: `ctx.contentHash(exec)` — the family runtime owns this and\n*    returns an opaque, bounded digest (SHA-512 in the SQL and Mongo\n*    runtimes today).\n*\n* The returned string is consumed directly as the `Map<string, …>` key\n* by the underlying `CacheStore`; the cache middleware does not perform\n* any further transformation.\n*/\nasync function resolveCacheKey(payload, exec, ctx) {\n\tif (payload.key !== void 0) return payload.key;\n\treturn ctx.contentHash(exec);\n}\n/**\n* Creates a family-agnostic caching middleware.\n*\n* The middleware uses three hooks:\n*\n* - `interceptQuery` — on each execution, checks the cache. On a hit, returns\n*   the cached raw rows; the runtime skips `runDriver` and `onRow`\n*   (`beforeQuery` is not affected — it has already run for every\n*   middleware before any `interceptQuery` is consulted) and yields the\n*   cached rows to the consumer (which, in the SQL runtime, sees them\n*   after the standard `decodeRow` pass — i.e. the cache stores\n*   wire-format values). On a miss, records a pending buffer keyed on\n*   the `exec` object identity and returns `undefined` (passthrough).\n* - `onRow` — on the miss path, appends each row yielded by the driver\n*   to the pending buffer.\n* - `afterQuery` — on the miss path, commits the buffer to the store\n*   if and only if `result.completed === true && result.source === 'driver'`.\n*   Failed executions and middleware-served executions never populate\n*   the cache. The pending buffer is cleared in all branches so a stale\n*   `WeakMap` entry cannot leak between executions sharing an `exec`.\n*\n* The middleware bypasses the cache entirely when:\n* - the plan has no `cache` annotation, or\n* - the annotation has `skip: true`, or\n* - the annotation has no `ttl`, or\n* - `ctx.scope !== 'runtime'` (connection / transaction scopes opt out).\n*\n* Returns a cross-family `RuntimeMiddleware` (no `familyId` /\n* `targetId`). The package depends only on\n* `@internal/framework-components/runtime`; cache keys come from\n* `ctx.contentHash(exec)`, populated by the family runtime, so SQL and\n* Mongo runtimes both work out of the box.\n*\n* @example\n* ```typescript\n* import { createCacheMiddleware, cacheAnnotation } from '@internal/middleware-cache';\n*\n* const db = postgres({\n*   contractJson,\n*   url: process.env['DATABASE_URL']!,\n*   middleware: [createCacheMiddleware({ maxEntries: 1000 })],\n* });\n*\n* const user = await db.User.first(\n*   { id },\n*   (meta) => meta.annotate(cacheAnnotation({ ttl: 60_000 })),\n* );\n* ```\n*/\nfunction createCacheMiddleware(options) {\n\tconst store = options?.store ?? createInMemoryCacheStore({ maxEntries: options?.maxEntries ?? DEFAULT_MAX_ENTRIES });\n\tconst clock = options?.clock ?? Date.now;\n\tconst pending = /* @__PURE__ */ new WeakMap();\n\tasync function interceptQuery(exec, ctx) {\n\t\tif (ctx.scope !== \"runtime\") return;\n\t\tconst payload = readCachePayload(exec);\n\t\tif (payload === void 0) return;\n\t\tif (payload.skip === true) return;\n\t\tif (payload.ttl === void 0) return;\n\t\tconst key = await resolveCacheKey(payload, exec, ctx);\n\t\tconst hit = await store.get(key);\n\t\tif (hit !== void 0) {\n\t\t\tctx.log.debug?.({\n\t\t\t\tevent: \"middleware.cache.hit\",\n\t\t\t\tmiddleware: \"cache\",\n\t\t\t\tkey\n\t\t\t});\n\t\t\treturn { rows: hit.rows };\n\t\t}\n\t\tpending.set(exec, {\n\t\t\tkey,\n\t\t\tttlMs: payload.ttl,\n\t\t\tbuffer: []\n\t\t});\n\t\tctx.log.debug?.({\n\t\t\tevent: \"middleware.cache.miss\",\n\t\t\tmiddleware: \"cache\",\n\t\t\tkey\n\t\t});\n\t}\n\tasync function onRow(row, exec, _ctx) {\n\t\tconst slot = pending.get(exec);\n\t\tif (slot === void 0) return;\n\t\tslot.buffer.push(row);\n\t}\n\tasync function afterQuery(exec, result, ctx) {\n\t\tconst slot = pending.get(exec);\n\t\tif (slot === void 0) return;\n\t\tpending.delete(exec);\n\t\tif (!result.completed || result.source !== \"driver\") return;\n\t\tawait store.set(slot.key, {\n\t\t\trows: slot.buffer,\n\t\t\tstoredAt: clock()\n\t\t}, slot.ttlMs);\n\t\tctx.log.debug?.({\n\t\t\tevent: \"middleware.cache.store\",\n\t\t\tmiddleware: \"cache\",\n\t\t\tkey: slot.key\n\t\t});\n\t}\n\treturn {\n\t\tname: \"cache\",\n\t\tinterceptQuery,\n\t\tonRow,\n\t\tafterQuery\n\t};\n}\n//#endregion\nexport { cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../../../3-extensions/middleware-cache/dist/index.mjs"],"sourcesContent":["import { defineAnnotation } from \"@internal/framework-components/runtime\";\nimport { structuredError } from \"@internal/utils/structured-error\";\n//#region src/cache-annotation.ts\n/**\n* Marks a read for the cache middleware. It applies to reads only: a write terminal refuses it at\n* compile time and at run time. The middleware reads it from `plan.meta.annotations.cache`.\n*\n* `TMeta` types `meta` for this call only. Nothing ties it to the store's `TMeta`, so a store\n* package should export a wrapper typed with its own meta, such as\n* `(o: CacheAnnotationOptions<TagMeta>) => cacheAnnotation<TagMeta>(o)`.\n*\n* @example\n* ```typescript\n* import { cacheAnnotation } from '@internal/middleware-cache';\n*\n* // ORM read terminal — accepts the read-only annotation via the meta callback.\n* const user = await db.orm.public.User.first(\n*   { id },\n*   (meta) => meta.annotate(cacheAnnotation({ key: `user-${id}` })),\n* );\n*\n* // SQL DSL select builder — chainable.\n* const plan = db.sql\n*   .from(tables.user)\n*   .annotate(cacheAnnotation({}))\n*   .select({ id: tables.user.columns.id })\n*   .build();\n* ```\n*/\nconst cacheAnnotation = withTypedMeta(defineAnnotation()({\n\tnamespace: \"cache\",\n\tapplicableTo: [\"read\"]\n}));\nfunction withTypedMeta(handle) {\n\tfunction cacheAnnotationWithMeta(options) {\n\t\treturn handle(options);\n\t}\n\treturn Object.freeze(Object.assign(cacheAnnotationWithMeta, {\n\t\tnamespace: handle.namespace,\n\t\tapplicableTo: handle.applicableTo,\n\t\tread: handle.read\n\t}));\n}\n//#endregion\n//#region src/cache-store.ts\nfunction metaUnsupported() {\n\treturn structuredError(\"RUNTIME.CACHE_STORE_META_UNSUPPORTED\", \"The in-memory cache store cannot remove entries by meta because it does not index meta\", { fix: \"Invalidate by keys, or supply a CacheStore that indexes meta in set and unset.\" });\n}\nfunction invalidOption(argument, received, expected) {\n\treturn structuredError(\"RUNTIME.ARGUMENT_INVALID\", `createInMemoryCacheStore: ${argument} must be ${expected}`, {\n\t\tfix: `Pass ${argument} as ${expected}, or leave it unset for the default.`,\n\t\tmeta: {\n\t\t\thelper: \"createInMemoryCacheStore\",\n\t\t\targument,\n\t\t\treceived\n\t\t}\n\t});\n}\n/**\n* The default cache store: a least-recently-used map with one lifetime for every value, local to\n* the process. It holds `CachedRows` unless given another `TValue`. A key's version is kept for\n* `ttlMs` after the `unset` that moved it (see `InMemoryCacheStoreOptions`). It ignores `meta` in\n* `get` and `set`, and its `unset` rejects any `meta`, including `null`, before changing anything.\n* It throws `RUNTIME.ARGUMENT_INVALID` for a `maxEntries` or `ttlMs` outside the ranges above.\n*/\nfunction createInMemoryCacheStore(options) {\n\tconst maxEntries = options?.maxEntries ?? 1e3;\n\tconst ttlMs = options?.ttlMs ?? 6e4;\n\tconst clock = options?.clock ?? Date.now;\n\tif (!Number.isInteger(maxEntries) || maxEntries <= 0) throw invalidOption(\"maxEntries\", maxEntries, \"a positive integer\");\n\tif (!(ttlMs > 0)) throw invalidOption(\"ttlMs\", ttlMs, \"a positive number of milliseconds, or Infinity\");\n\tconst records = /* @__PURE__ */ new Map();\n\tconst versions = /* @__PURE__ */ new Map();\n\tfunction forgetExpiredVersions() {\n\t\tconst now = clock();\n\t\tfor (const [key, record] of versions) {\n\t\t\tif (now < record.expiresAt) return;\n\t\t\tversions.delete(key);\n\t\t}\n\t}\n\tfunction versionOf(key) {\n\t\tforgetExpiredVersions();\n\t\treturn versions.get(key)?.version ?? 0;\n\t}\n\tfunction liveRecord(key) {\n\t\tconst record = records.get(key);\n\t\tif (record === void 0) return;\n\t\trecords.delete(key);\n\t\tif (clock() >= record.expiresAt) return;\n\t\trecords.set(key, record);\n\t\treturn record;\n\t}\n\tasync function get(target) {\n\t\tconst record = liveRecord(target.key);\n\t\treturn {\n\t\t\tkey: target.key,\n\t\t\tmeta: target.meta,\n\t\t\tversion: versionOf(target.key),\n\t\t\tdata: record === void 0 ? { empty: true } : {\n\t\t\t\tempty: false,\n\t\t\t\tvalue: record.value\n\t\t\t}\n\t\t};\n\t}\n\tasync function set(entry, value) {\n\t\tif (entry.version !== versionOf(entry.key)) return false;\n\t\trecords.delete(entry.key);\n\t\trecords.set(entry.key, {\n\t\t\tvalue,\n\t\t\texpiresAt: clock() + ttlMs\n\t\t});\n\t\tfor (const leastRecentlyUsed of records.keys()) {\n\t\t\tif (records.size <= maxEntries) break;\n\t\t\trecords.delete(leastRecentlyUsed);\n\t\t}\n\t\treturn true;\n\t}\n\tasync function unset(target) {\n\t\tif (target.meta !== void 0) throw metaUnsupported();\n\t\tfor (const key of target.keys ?? []) {\n\t\t\trecords.delete(key);\n\t\t\tconst version = versionOf(key) + 1;\n\t\t\tversions.delete(key);\n\t\t\tversions.set(key, {\n\t\t\t\tversion,\n\t\t\t\texpiresAt: clock() + ttlMs\n\t\t\t});\n\t\t}\n\t}\n\treturn {\n\t\tget,\n\t\tset,\n\t\tunset\n\t};\n}\n//#endregion\n//#region src/cache-middleware.ts\n/**\n* The default `deriveKey`: the family runtime's content hash of the plan, which covers the\n* statement, its parameters and the storage hash.\n*/\nfunction deriveKeyFromContentHash(exec, ctx) {\n\treturn ctx.contentHash(exec);\n}\n/**\n* Creates a read-through cache middleware that works with every family runtime.\n*\n* It caches a read when the plan carries `cacheAnnotation`, the annotation does not set\n* `bypass`, and the read runs in runtime scope (not inside a connection or transaction). The key\n* is the annotation's `key`, else `deriveKey(exec, ctx)`.\n*\n* - `interceptQuery` — on a hit, returns the stored rows and the driver does not run. On a miss,\n*   starts collecting rows.\n* - `onRow` — collects each row of a miss.\n* - `afterQuery` — when the driver completed the read, calls `store.set(entry, rows)` with the\n*   entry `store.get` returned, which stores only if the key's version has not moved. If an\n*   `unset` moved it meanwhile, `set` returns `false` and the middleware logs\n*   `middleware.cache.store-skipped`.\n*\n* @example\n* ```typescript\n* const cache = createCacheMiddleware();\n* const db = postgres<Contract>({ contractJson, url, middleware: [cache] });\n*\n* const user = await db.orm.public.User.first(\n*   { id: 1 },\n*   (meta) => meta.annotate(cacheAnnotation({ key: 'user-1' })),\n* );\n* await db.orm.public.User.where({ id: 1 }).update({ name: 'Alicia' });\n* await cache.invalidate({ keys: ['user-1'] });\n* ```\n*/\nfunction createCacheMiddleware(options) {\n\tconst store = options?.store ?? createInMemoryCacheStore();\n\tconst deriveKey = options?.deriveKey ?? deriveKeyFromContentHash;\n\tconst pending = /* @__PURE__ */ new WeakMap();\n\tasync function interceptQuery(exec, ctx) {\n\t\tif (ctx.scope !== \"runtime\") return;\n\t\tconst annotation = cacheAnnotation.read(exec);\n\t\tif (annotation === void 0 || annotation.bypass === true) return;\n\t\tconst key = annotation.key ?? await deriveKey(exec, ctx);\n\t\tconst entry = await store.get({\n\t\t\tkey,\n\t\t\tmeta: annotation.meta\n\t\t});\n\t\tif (!entry.data.empty) {\n\t\t\tctx.log.debug?.({\n\t\t\t\tevent: \"middleware.cache.hit\",\n\t\t\t\tmiddleware: \"cache\",\n\t\t\t\tkey\n\t\t\t});\n\t\t\treturn { rows: entry.data.value };\n\t\t}\n\t\tpending.set(exec, {\n\t\t\tentry,\n\t\t\tbuffer: []\n\t\t});\n\t\tctx.log.debug?.({\n\t\t\tevent: \"middleware.cache.miss\",\n\t\t\tmiddleware: \"cache\",\n\t\t\tkey\n\t\t});\n\t}\n\tasync function onRow(row, exec, _ctx) {\n\t\tpending.get(exec)?.buffer.push(row);\n\t}\n\tasync function afterQuery(exec, result, ctx) {\n\t\tconst miss = pending.get(exec);\n\t\tif (miss === void 0) return;\n\t\tpending.delete(exec);\n\t\tif (!result.completed || result.source !== \"driver\") return;\n\t\tconst stored = await store.set(miss.entry, miss.buffer);\n\t\tctx.log.debug?.({\n\t\t\tevent: stored ? \"middleware.cache.store\" : \"middleware.cache.store-skipped\",\n\t\t\tmiddleware: \"cache\",\n\t\t\tkey: miss.entry.key\n\t\t});\n\t}\n\tasync function invalidate(target) {\n\t\tconst keys = target.keys !== void 0 && target.keys.length > 0 ? target.keys : void 0;\n\t\tif (keys === void 0 && target.meta === void 0) return;\n\t\tawait store.unset({\n\t\t\tkeys,\n\t\t\tmeta: target.meta\n\t\t});\n\t}\n\treturn {\n\t\tname: \"cache\",\n\t\tinterceptQuery,\n\t\tonRow,\n\t\tafterQuery,\n\t\tinvalidate\n\t};\n}\n//#endregion\nexport { cacheAnnotation, createCacheMiddleware, createInMemoryCacheStore, deriveKeyFromContentHash };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/orm-extension-middleware-cache",
-  "version": "8.0.0-rc.14-dev.8",
+  "version": "8.0.0-rc.14-dev.9",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,12 +9,12 @@
     "dist"
   ],
   "dependencies": {
-    "@prisma/orm-framework": "8.0.0-rc.14-dev.8"
+    "@prisma/orm-framework": "8.0.0-rc.14-dev.9"
   },
   "devDependencies": {
-    "@internal/middleware-cache": "8.0.0-rc.14-dev.8",
-    "@repo/tsconfig": "8.0.0-rc.14-dev.8",
-    "@repo/tsdown": "8.0.0-rc.14-dev.8",
+    "@internal/middleware-cache": "8.0.0-rc.14-dev.9",
+    "@repo/tsconfig": "8.0.0-rc.14-dev.9",
+    "@repo/tsdown": "8.0.0-rc.14-dev.9",
     "tsdown": "0.22.14",
     "typescript": "5.9.3"
   },