@owlmeans/redis-resource 0.1.18-rc.2 → 0.1.18-rc.20

package/README.md

@@ -1,17 +1,19 @@
 # @owlmeans/redis-resource
 
-Redis-backed resource with pub/sub and streaming support for real-time features.
+Redis-backed resource with pub/sub, keyspace watching and streams for real-time features.
 
 ## Overview
 
-- `makeRedisResource(alias, dbAlias?)` — creates a Redis resource
-- `RedisResource<T>` — extends `Resource<T>` with `subscribe`, `publish`, `stream`, and `consume`
+- `makeRedisResource(alias, dbAlias?, serviceAlias?)` — creates a Redis resource
+- `RedisResource<T>` — `Resource<T>` composed with `PubSubResource`, `WatchableResource` and
+  `StreamResource`
+- One JSON document per namespaced key: `resource.key(id)` → `<schema>-<alias>:<id>`
 - Used for authentication caches, pub/sub channels, and async event streams
 
 ## Installation
 
 ```bash
-bun add @owlmeans/redis-resource
+bun add @owlmeans/redis-resource@^0.1.18-rc.11
 ```
 
 ## Usage
@@ -27,65 +29,110 @@ context.registerResource(makeRedisResource(AGENT_THINKING_STREAM))
 context.registerResource(makeRedisResource(AGENT_WATCHER_PUBSUB))
 ```
 
-Define typed resource interfaces:
+Type the resource once, at the point it is taken out of the context:
 
 ```typescript
 import type { RedisResource } from '@owlmeans/redis-resource'
 
-interface AgentThinkingStream extends RedisResource<AgentThinkingEvent> {}
-interface AgentWatcherPubsub extends RedisResource<AgentWatcherEvent> {}
+const cache = context.resource<RedisResource<SessionData>>(AUTH_CACHE)
+
+await cache.create({ id, token }, { ttl: 3600 })   // seconds, or a Date
+const session = await cache.load({ token })        // criteria, not just an id
+await cache.take(id)                               // delete-and-return
 ```
 
 Publish and subscribe:
 
 ```typescript
-const pubsub = context.resource<AgentWatcherPubsub>(AGENT_WATCHER_PUBSUB)
+const pubsub = context.resource<RedisResource<AgentWatcherEvent>>(AGENT_WATCHER_PUBSUB)
 
-// Publisher side
-await pubsub.publish({ type: 'update', payload: data })
+await pubsub.publish({ type: 'update', payload: data }, channel)
 
-// Subscriber side
-const unsubscribe = await pubsub.subscribe(async (event) => {
-  handleEvent(event)
-})
+const unsubscribe = await pubsub.subscribe(
+  event => handleEvent(event), { channel, once: true }
+)
+```
+
+Watch one record for changes (keyspace notifications):
+
+```typescript
+const unwatch = await cache.watch(id, record => {
+  // `null` once the key is gone — deleted or expired
+  render(record)
+}, { once: true })
 ```
 
 Stream events (Redis Streams):
 
 ```typescript
-const stream = context.resource<AgentThinkingStream>(AGENT_THINKING_STREAM)
+const stream = context.resource<RedisResource<AgentThinkingEvent>>(AGENT_THINKING_STREAM)
 
-// Producer
 await stream.stream('thinking-key', { step: 'reasoning', content: text })
 
-// Consumer (async generator)
-for await (const event of stream.consume('thinking-key', 'workers', 'worker-1')) {
+for await (const event of stream.consume('thinking-key', { group: 'workers', consumer: 'worker-1' })) {
   process(event)
 }
 ```
 
+## Reads
+
+`load(id)` / `get(id)` / `delete(id)` / `take(id)` are O(1) commands on one key. `load({ ... })`,
+`get({ ... })`, `list`, `count` and `purge` walk this resource's **own namespace** with `SCAN`
+(never `KEYS`, which blocks the server for the whole sweep), read the values with `MGET`, and
+evaluate the criteria in memory. That is O(N) over the namespace: right for a small namespaced set
+— a session cache, an adapter store — and wrong for anything unbounded or on a hot path. A
+resource that needs real queries belongs in `@owlmeans/mongo-resource` or
+`@owlmeans/postgres-resource`.
+
+Redis is **unpaged**: `list(where)` with no `size` returns every match, and `list(where, { page })`
+without a `size` throws `UnsupportedArgumentError('page-without-size')`. `ListResult.total` always
+counts every match.
+
+The namespace walk reaches one server, so `list` / `count` / `purge` are not cluster-safe — in a
+clustered deployment use the by-id operations only.
+
+## TTL
+
+| `opts.ttl` | Meaning | Command |
+|---|---|---|
+| `number` | seconds from now | `EXPIRE` |
+| `Date` | the absolute instant to expire at | `PEXPIREAT` (milliseconds — what `Date.getTime()` gives) |
+| omitted | persistent (`PTTL` reports `-1`) | — |
+
+A `Date` already in the past drops the record immediately. `update` and `save` rewrite the key, so
+a renewal has to pass its TTL again — otherwise the record becomes persistent.
+
 ## API
 
-### `makeRedisResource(alias, dbAlias?): RedisResource<T>`
+### `makeRedisResource<R>(alias, dbAlias?, serviceAlias?): RedisResource<R>`
 
-Creates a Redis resource. `dbAlias` defaults to `DEFAULT_DB_ALIAS` (`'redis'`).
+Creates a Redis resource. Both alias arguments default to `DEFAULT_DB_ALIAS` (`'redis'`).
 
 ### `RedisResource<T>`
 
-Extends `Resource<T>` with:
-- `subscribe<T>(handler, key?): Promise<() => Promise<void>>` — subscribe to pub/sub channel
-- `publish<T>(value, key?): Promise<void>` — publish to pub/sub channel
-- `stream<T>(key, data): Promise<void>` — append to a Redis Stream
-- `consume<T>(key, group?, consumer?): AsyncGenerator<T>` — consume from a Redis Stream
+`Resource<T>` plus:
+- `publish(value, channel?): Promise<void>` — publish to a namespaced pub/sub channel
+- `subscribe(handler, { channel?, once?, ttl? }): Promise<Unsubscribe>` — channel pub/sub
+- `watch(id, handler, { once?, ttl? }): Promise<Unsubscribe>` — keyspace notifications for ONE
+  record; the handler is given `null` once the key is gone. Bound to **db 0**, so deployments
+  sharing an instance isolate on the key prefix, and the server needs `notify-keyspace-events`
+- `stream(key, value): Promise<void>` — append to a Redis Stream
+- `consume(key, { group?, consumer?, block? }): AsyncGenerator<T>` — consume from a Redis Stream
+- `key(key?): string` — the namespaced key, or the namespace's glob
 
 ### Constants
 
 - `DEFAULT_DB_ALIAS` — `'redis'`
+- `DEFAULT_PAGE_SIZE` — `0`, meaning unpaged
+
+## Requirements
+
+Redis 6.2 or newer: `delete` and `take` use `GETDEL`.
 
 ## Related Packages
 
 - [`@owlmeans/redis`](../redis) — Redis connection service
-- [`@owlmeans/resource`](../resource) — `Resource<T>` base interface
+- [`@owlmeans/resource`](../resource) — `Resource<T>` base interface and the criteria engine
 - [`@owlmeans/server-socket`](../server-socket) — WebSocket handlers often use Redis resources for streaming
 
 <!-- owlmeans:agent-guidance:start -->
@@ -96,7 +143,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills
+npx @owlmeans/agent-skills@^0.1.18-rc.20
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/redis-resource",
-  "version": "0.1.18-rc.0",
-  "generatedAt": "2026-08-16T22:20:50.508Z",
+  "version": "0.1.18-rc.20",
+  "generatedAt": "2026-09-12T14:21:25.465Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/redis-resource/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: redis-resource
-description: How to use @owlmeans/redis-resource — Redis-backed Resource implementation for caching/state with TTL support. Auto-invoked when defining a resource backed by Redis.
+description: How to use @owlmeans/redis-resource — Redis-backed Resource implementation for caching/state with TTL, pub/sub, keyspace watching and streams. Auto-invoked when defining a resource backed by Redis.
 user-invocable: false
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
@@ -8,17 +8,23 @@ user-invocable: false
 # @owlmeans/redis-resource
 
 **Layer:** Infra
-**Install:** `"@owlmeans/redis-resource": "^0.1.18-rc.0"` in `dependencies`
+**Install:** `"@owlmeans/redis-resource": "^0.1.18-rc.20"` in `dependencies`
 
 ## Key Exports
 
 | Export | Description |
 |--------|-------------|
-| `makeRedisResource<R>(alias, dbAlias?, serviceAlias?, makeCustomResource?)` | Factory for a Redis-backed `Resource<R>`. Both alias defaults are `DEFAULT_DB_ALIAS` (`'redis'`) |
-| `RedisResource<R>`, `RedisDb`, `RedisClient`, `RedisDbService` | Types |
-| `DEFAULT_DB_ALIAS`, `DEFAULT_PAGE_SIZE` | Constants |
-
-Keys are namespaced by the db config's `schema`: `resource.key(id)` → `<prefix>:<id>`.
+| `makeRedisResource<R>(alias, dbAlias?, serviceAlias?)` | Factory for a Redis-backed `Resource<R>`. Both alias defaults are `DEFAULT_DB_ALIAS` (`'redis'`) |
+| `RedisResource<R>` | `Resource<R>` plus the `PubSubResource`, `WatchableResource` and `StreamResource` capabilities, `db`, `name` and `key(id?)` |
+| `RedisDb`, `RedisClient`, `RedisDbService`, `RedisConnection` | The db and connection contracts — `@owlmeans/redis` implements them |
+| `DEFAULT_DB_ALIAS`, `DEFAULT_PAGE_SIZE`, `SCAN_BATCH`, `READ_BATCH` | Constants for the record half |
+| `STREAM_MAX_LENGTH`, `DEFAULT_STREAM_BLOCK`, `RECLAIM_IDLE`, `RECLAIM_COUNT`, `CONSUMER_ID_LENGTH` | Constants for the stream half |
+
+Keys are namespaced by the db config's key prefix plus the resource's name:
+`resource.key(id)` → `<prefix>-<name>:<id>`, and `key()` with no argument yields the namespace's
+glob. The name is `resource.name` when set and the registration alias otherwise, so two resources
+can share one namespace deliberately — and a `name` given by accident quietly merges two id spaces.
+Every non-word character in either half is collapsed to `_`.
 
 ## Usage
 
@@ -27,47 +33,106 @@ import { makeRedisResource } from '@owlmeans/redis-resource'
 
 context.registerResource(makeRedisResource<SessionData>('sessions'))
 
+// Type the RESOURCE once — never a method
 const sessions = context.resource<RedisResource<SessionData>>('sessions')
 await sessions.create({ id, token }, { ttl: 3600 })   // seconds, or a Date
+const live = await sessions.load({ token })           // criteria, not just an id
 ```
 
-TTL is a **per-call option** on `create`/`update`, not a property of the factory. The prefix
-comes from the `dbs[]` config entry (`schema`), not from the resource.
+TTL is a **per-call option** on `create` / `update` / `save`, not a property of the factory. The
+prefix comes from the `dbs[]` config entry (`schema`), not from the resource.
+
+## Reads: one key is cheap, everything else is a walk
+
+`load(id)`, `get(id)`, `delete(id)`, `take(id)` are single-key commands.
+
+`load(where)`, `get(where)`, `list`, `count` and `purge` walk the resource's **own namespace** with
+`SCAN` + `MGET` and evaluate the criteria in memory with `firstMatch` / `filterRecords` /
+`applyQuery` from `@owlmeans/resource` — the same engine every other store without a query planner
+uses, so a criteria object means here exactly what it means in SQL. That is O(N) over the
+namespace, and `{ sort }` orders the records after the walk, not in redis.
+
+- Use it for a small namespaced set — a session cache, an OTP store, an adapter store.
+- Never for an unbounded keyspace or a hot path. A resource that needs real queries belongs in
+  mongo or postgres.
+- `SCAN`, never `KEYS`: `KEYS` blocks the server for the whole sweep.
+- The walk reaches one server, so `list` / `count` / `purge` are **not cluster-safe**. In a
+  clustered deployment stay on the by-id operations.
+- `load({ id })` is recognised and answered by key — the walk only starts for a real criteria.
+- A key in the namespace holding something other than a string — this resource's own streams
+  included — reads back as `null` from `MGET` and is skipped, so a stream never shows up as a
+  record.
+
+## Paging
+
+Redis is **UNPAGED**: `DEFAULT_PAGE_SIZE` is `0`, `list(where)` with no `size` returns every match,
+and `ListResult.total` always counts every match. `list(where, { page })` without a `size` throws
+`UnsupportedArgumentError('page-without-size')` — there is no implied default to take a window of.
 
 ## TTL
 
 | `opts.ttl` | Meaning | Command |
 |---|---|---|
-| `number` / numeric `string` | seconds from now | `EXPIRE` |
+| `number` | seconds from now | `EXPIRE` |
 | `Date` | the absolute instant to expire at | `PEXPIREAT` (milliseconds — what `Date.getTime()` gives) |
 | omitted | persistent (`PTTL` reports `-1`) | — |
 
-A `Date` already in the past drops the record immediately. `update` re-applies the TTL, so a
-renewal must pass one again — otherwise the key keeps whatever expiry it had.
+A `Date` already in the past drops the record immediately. `update` and `save` rewrite the key, so
+a renewal must pass a TTL again — otherwise the record becomes persistent.
 
 ## Rules
 
-- `delete(id)` — the plain by-id form — is the normal call and must remove the key. It returns the
-  removed record, or `null` when the id was not there. `pick(id)` is delete-and-return that
-  *throws* `UnknownRecordError` when the key is gone; choose by whether absence is an error.
-- `create` throws `RecordExists` when the id is present. For an upsert, use `save` (load → update
-  or create) rather than delete-then-create; the latter turns any lost delete into a hard failure
-  on the next write.
-- `load` rejects an `opts` argument (`UnsupportedArgumentError`) — pass only `id` and an optional
-  field name.
-- `list` walks `KEYS <prefix>:*`. Fine for small, namespaced sets; never for a hot path or an
-  unbounded keyspace.
-- `subscribe` relies on keyspace notifications, which are bound to **db 0** — deployments sharing
-  one instance must isolate on the key prefix, not on the db index.
-- Assert an expiry by reading `PTTL` back from redis, never by trusting that a command was issued —
-  the unit bug this contract had still "set an expiry", just one ~50 millennia away.
+- `delete(id)` returns the removed record or `null`; `take(id)` is the same read but **throws**
+  `UnknownRecordError` when the key is gone. Both use `GETDEL`, so two callers can never be handed
+  the same record. Choose by whether absence is an error.
+- `create` generates an id when the record carries none, and refuses an id that is already there
+  (`RecordExists`) using `SET NX` — no read-then-write race. The id is written into the stored
+  record, so what comes back always carries one.
+- `update` **replaces** the whole record and throws `UnknownRecordError` for an unknown id (and
+  `MisshapedRecord` when the record carries no id at all). It does not merge over what was stored;
+  pass every field that must survive.
+- `save` creates when the record carries no id and replaces otherwise — that is the upsert.
+- `purge(where)` refuses an empty criteria object. Use it instead of a page loop that deletes each
+  item.
+- `publish(value, channel?)` / `subscribe(handler, { channel?, once?, ttl? })` are channel pub/sub;
+  the channel name is namespaced like a key, and an omitted channel listens to the resource's whole
+  namespace. `watch(id, handler, { once?, ttl? })` is the keyspace-notification form for ONE
+  record — the handler receives the current value on every write, and `null` once the key is gone.
+  They are separate methods; a channel is never passed as a bare string.
+- `watch` subscribes to `__keyspace@0__:`, while redis publishes keyspace events per database as
+  `__keyspace@<db>__:`. So a resource on a connection whose `meta.dbIndex` is anything but 0 gets
+  no notifications at all and its `watch` handler silently never fires — deployments sharing one
+  instance isolate on the key prefix, not on the db index. The server also needs
+  `notify-keyspace-events` enabled; it emits nothing otherwise.
+- `stream(key, value)` appends to a namespaced redis stream, trimmed approximately to
+  `STREAM_MAX_LENGTH` so trimming stays cheap. `consume(key, { group?, consumer?, block? })` is the
+  async generator that reads it — with no `group` it tails from now with `XREAD`, with one it joins
+  the consumer group and reclaims stale entries under the **passed** consumer name. Claiming them
+  for a fixed name leaves them owned by a consumer that never reads.
+- Requires redis 6.2 or newer (`GETDEL`).
+- Assert an expiry by reading `PTTL` back from redis, never by trusting that a command was issued.
+  An expiry set in the wrong unit is still an expiry — just one tens of millennia out — so only the
+  value redis reports back proves anything.
+
+## Tests
+
+Integration specs live in the `@owlmeans/redis` package's own `tests/` — the db package that backs
+this contract; putting them here would need a devDependency on this package's own dependent.
+Gated on `REDIS_URL` (see `/.env.example`); each suite namespaces its keys and flushes them, and a
+spec that walks the namespace boots under its own resource alias so it never sees another test's
+records.
 
 ## Depends On
 
-- `@owlmeans/redis`, `@owlmeans/resource`, `@owlmeans/server-context`
+- `@owlmeans/resource` · `@owlmeans/context` · `@owlmeans/server-context` · `@owlmeans/basic-ids`
+- peer `ioredis` (the client types every method is written against), `ajv`
 
-## Tests
+`@owlmeans/redis` is NOT a dependency — it depends on this package, and that is the direction the
+connection contracts flow in.
 
-Integration specs live in `@owlmeans/redis` (`packages/redis/tests/`) — the db package that backs
-this contract; putting them here would need a devDependency on this package's own dependent.
-Gated on `REDIS_URL` (see `/.env.example`); each suite namespaces its keys and flushes them.
+## Related
+
+- `redis` — the connection service implementing `RedisDbService`, and the `cfg.dbs` entry a
+  resource takes its prefix and db index from
+- `redis-queue` — BullMQ queues on the same connections
+- `resource` — the criteria language, paging and the error classes raised here

package/build/consts.d.ts

@@ -1,3 +1,22 @@
 export declare const DEFAULT_DB_ALIAS = "redis";
-export declare const DEFAULT_PAGE_SIZE = 10;
+/**
+ * Redis is UNPAGED: `list()` without a `size` returns every match, and `0` says exactly that.
+ * There is no server side LIMIT to fall back on — answering a criteria already walked the whole
+ * namespace — so an implied default would only hide records without saving any work.
+ */
+export declare const DEFAULT_PAGE_SIZE = 0;
+/** Keys per SCAN round trip. Bounded so one sweep never blocks the server the way KEYS does. */
+export declare const SCAN_BATCH = 200;
+/** Keys per MGET / DEL round trip once SCAN has collected them. */
+export declare const READ_BATCH = 200;
+/** Entries kept in a stream, trimmed approximately (`MAXLEN ~`) so trimming stays O(1)-ish. */
+export declare const STREAM_MAX_LENGTH = 10000;
+/** How long a stream read blocks before the consumer loops and looks for pending entries. */
+export declare const DEFAULT_STREAM_BLOCK = 1000;
+/** How long an unacknowledged entry may sit with its consumer before another may reclaim it. */
+export declare const RECLAIM_IDLE = 60000;
+/** Entries reclaimed per XAUTOCLAIM pass. */
+export declare const RECLAIM_COUNT = 10;
+/** Length of the generated consumer name when `consume` is not given one. */
+export declare const CONSUMER_ID_LENGTH = 15;
 //# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,gBAAgB,UAAU,CAAA;AAEvC,eAAO,MAAM,iBAAiB,KAAK,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,UAAU,CAAA;AAEvC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAElC,gGAAgG;AAChG,eAAO,MAAM,UAAU,MAAM,CAAA;AAE7B,mEAAmE;AACnE,eAAO,MAAM,UAAU,MAAM,CAAA;AAE7B,+FAA+F;AAC/F,eAAO,MAAM,iBAAiB,QAAQ,CAAA;AAEtC,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,OAAO,CAAA;AAExC,gGAAgG;AAChG,eAAO,MAAM,YAAY,QAAQ,CAAA;AAEjC,6CAA6C;AAC7C,eAAO,MAAM,aAAa,KAAK,CAAA;AAE/B,6EAA6E;AAC7E,eAAO,MAAM,kBAAkB,KAAK,CAAA"}

package/build/consts.js

@@ -1,3 +1,22 @@
 export const DEFAULT_DB_ALIAS = 'redis';
-export const DEFAULT_PAGE_SIZE = 10;
+/**
+ * Redis is UNPAGED: `list()` without a `size` returns every match, and `0` says exactly that.
+ * There is no server side LIMIT to fall back on — answering a criteria already walked the whole
+ * namespace — so an implied default would only hide records without saving any work.
+ */
+export const DEFAULT_PAGE_SIZE = 0;
+/** Keys per SCAN round trip. Bounded so one sweep never blocks the server the way KEYS does. */
+export const SCAN_BATCH = 200;
+/** Keys per MGET / DEL round trip once SCAN has collected them. */
+export const READ_BATCH = 200;
+/** Entries kept in a stream, trimmed approximately (`MAXLEN ~`) so trimming stays O(1)-ish. */
+export const STREAM_MAX_LENGTH = 10000;
+/** How long a stream read blocks before the consumer loops and looks for pending entries. */
+export const DEFAULT_STREAM_BLOCK = 1000;
+/** How long an unacknowledged entry may sit with its consumer before another may reclaim it. */
+export const RECLAIM_IDLE = 60000;
+/** Entries reclaimed per XAUTOCLAIM pass. */
+export const RECLAIM_COUNT = 10;
+/** Length of the generated consumer name when `consume` is not given one. */
+export const CONSUMER_ID_LENGTH = 15;
 //# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAA;AAEvC,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAA"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAA;AAEvC;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAA;AAElC,gGAAgG;AAChG,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAA;AAE7B,mEAAmE;AACnE,MAAM,CAAC,MAAM,UAAU,GAAG,GAAG,CAAA;AAE7B,+FAA+F;AAC/F,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,CAAA;AAEtC,6FAA6F;AAC7F,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAA;AAExC,gGAAgG;AAChG,MAAM,CAAC,MAAM,YAAY,GAAG,KAAK,CAAA;AAEjC,6CAA6C;AAC7C,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAA;AAE/B,6EAA6E;AAC7E,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,CAAA"}

package/build/resource.d.ts

@@ -1,4 +1,13 @@
-import type { ResourceMaker, ResourceRecord } from '@owlmeans/resource';
+import type { ResourceRecord } from '@owlmeans/resource';
 import type { RedisResource } from './types.js';
-export declare const makeRedisResource: <R extends ResourceRecord, T extends RedisResource<R> = RedisResource<R>>(alias: string, dbAlias?: string, serviceAlias?: string, makeCustomResource?: ResourceMaker<R, T>) => T;
+/**
+ * A `Resource` over plain redis strings: one JSON document per namespaced key.
+ *
+ * Reads by id are O(1) GETs. Everything else — a criteria read, a listing, a count, a purge —
+ * walks this resource's OWN namespace with SCAN and evaluates the criteria in memory, because
+ * redis has no index to ask. That is affordable for a small namespaced set (a session cache, an
+ * adapter store) and wrong for anything unbounded or hot; a resource that needs real queries
+ * belongs in mongo or postgres.
+ */
+export declare const makeRedisResource: <R extends ResourceRecord, T extends RedisResource<R> = RedisResource<R>>(alias: string, dbAlias?: string, serviceAlias?: string) => T;
 //# sourceMappingURL=resource.d.ts.map

package/build/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAEvE,OAAO,KAAK,EAA+B,aAAa,EAAE,MAAM,YAAY,CAAA;AAW5E,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,4BAE7C,MAAM,gEACQ,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,KACvC,CA0WF,CAAA"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACuC,cAAc,EAEhE,MAAM,oBAAoB,CAAA;AAK3B,OAAO,KAAK,EAA+B,aAAa,EAAE,MAAM,YAAY,CAAA;AAY5E;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,cAAc,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,4BAE7C,MAAM,8CACZ,CAmZF,CAAA"}