@elysiumjs/mnemosyne 0.2.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,170 @@
 # @elysiumjs/mnemosyne
 
+## 0.4.0
+
+### Minor Changes
+
+- [#7](https://github.com/na2axl/elysiumjs/pull/7) [`e9c3d98`](https://github.com/na2axl/elysiumjs/commit/e9c3d98dd2714b69100215f7c8a80046da463148) Thanks [@na2axl](https://github.com/na2axl)! - Elysium runs on Elysia 2 (`elysia@^2.0.0-rc.1`), with TypeBox 1 (`typebox`), `@elysia/openapi` and `@elysia/opentelemetry`.
+
+  Breaking:
+
+  - `TSchema` and `Static` are re-exported from `typebox` instead of `@sinclair/typebox`; `Value` comes from `typebox/value` and `Value.Errors()` returns an array.
+  - `Application.onError()` receives a `ServerError` (exported from core). Elysia now names its errors in kebab case; the default error response keeps the upper snake case names (`VALIDATION`, `NOT_FOUND`, `UNKNOWN` for other errors).
+  - `AppHttpContext` is a plain interface with `decorator`, `store` and `derive` records (Elysia 2 renamed `resolve` to `derive`).
+  - Websocket controllers install Elysia's `websocket()` capability themselves.
+
+  A module or controller `onRequest` middleware that answers now stops the request: Elysia 2 ignores values returned from a transform hook, so the response is thrown as a status and sent as is, without going through `onError`.
+
+  `mnemosyne` builds date columns with `t.Codec` (TypeBox 1 dropped `Transform`). `argus` traces every route of the app it is installed on and ends each span once, keeping the error status when the request failed.
+
+- [#19](https://github.com/na2axl/elysiumjs/pull/19) [`6789879`](https://github.com/na2axl/elysiumjs/commit/678987976ecfd46b534b65276e0de3f448977562) Thanks [@na2axl](https://github.com/na2axl)! - Domain errors as classes with a code, returned as values.
+
+  - `DomainError` is an Elysia `HTTPError`. Each error is a class made with `DomainError.for(code, status)`, which keeps its code and status as literal types, with `errors`, `retryAfterSeconds` (served as `retryAfter` and the Retry-After header) and extensions.
+  - Ready-made errors: `BadRequestError`, `ValidationFailedError`, `UnauthenticatedError`, `ForbiddenError`, `NotFoundError` and `ConflictError`.
+  - `ProblemCatalogue`, extended through declaration merging, lists the codes of an application; once it has keys, `DomainError.for()` takes only those and `ELYSIUM_PROBLEM_CODES`.
+  - Every problem carries `code`, `requestId` (from `problems.requestId`, a valid `x-request-id` header, or a random UUID) and `instance`. Its `type` is the kebab-case slug of the code, under `problems.typeBase`.
+  - Errors as values: a handler, a flow step, `UnitOfWork.run()` or a `@Transactional()` method that returns a DomainError rolls back and sends or returns it like a thrown one. `Commands.execute()` and `Queries.ask()` return the DomainError that refused the call, and a returned error joins the route's response type for typed clients.
+
+- [#13](https://github.com/na2axl/elysiumjs/pull/13) [`1ea417e`](https://github.com/na2axl/elysiumjs/commit/1ea417e3583250bc2f975d795f398b7ff736115d) Thanks [@na2axl](https://github.com/na2axl)! - Hardening of the runtimes, the container and the CLI, checked by a conformance suite that runs on Bun, Node.js and workerd.
+
+  Breaking changes:
+
+  - `Runtime` gains the required `argv()`, `write(stream, text)` and `terminal()` members: core reaches the host's arguments, output streams and terminal only through the runtime. Custom runtimes must implement them.
+  - The third parameter of `InteractsWithConsole.write` is now `'stdout' | 'stderr'`.
+  - The WebSocket options are narrowed to `idleTimeout`, `maxPayloadLength` and `perMessageDeflate`, and the `bun` WebSocket types are replaced by `ElysiumWebSocket`.
+  - Redis connections are `RedisConnection`s, a port any Redis client can implement, instead of `Bun.RedisClient`.
+  - `styx create @scope/name` creates the project in `name/`, and refuses project and module names with upper-case letters.
+  - Queue handlers no longer reject the batch: after the handlers ran, each message is acked or retried on its own. `@Workers.queue(name, { each: true })` receives one message at a time, so a failure retries only that message.
+
+  Fixes:
+
+  - Request-scoped services are destroyed when the request ends, also on failure, and an async `onInit` is awaited. A second dispose of a request scope waits for the one in progress, so a Worker's `waitUntil` covers an async `onDestroy`.
+  - A failed module or service `onInit` no longer breaks later requests: the boot is retried, and the module's event listeners are unwired.
+  - `@elysiumjs/runtime-node` serves through `node:http`, keeping the Host header authoritative.
+  - `styx create` validates names before creating files, ships `.gitignore`, declares the dependencies of created projects and imports their default controllers.
+
+- [#14](https://github.com/na2axl/elysiumjs/pull/14) [`0956186`](https://github.com/na2axl/elysiumjs/commit/0956186db0ca5a83c0a6636aeb2a4c81a0033de4) Thanks [@na2axl](https://github.com/na2axl)! - The request pipeline: problem details, exception filters, interceptors, typed configuration, HTTP security options and an HTTP test client, checked on Bun, Node.js, workerd and AOT-compiled Workers.
+
+  Breaking changes:
+
+  - Error responses are RFC 9457 problem details (`application/problem+json`). Request validation errors answer 422 with an `errors` list of JSON pointers (`problems.validationStatus: 400` keeps 400). Server errors only show their message and stack in development. Thrown statuses (`c.status(...)`) are sent as they are.
+  - Client errors (4xx) are no longer reported to `onError`, the `elysium:error` event or the trace.
+  - `Runtime.serve` may return a handle with `close()`, which the application calls on shutdown.
+  - Request bodies are limited to 1 MiB by default (`http.bodyLimit`), also when chunked.
+  - The environment schema is validated when the app is built or run, with every error reported at once, instead of in the constructor.
+
+  Features:
+
+  - `DomainError`, with `status`, `type`, `title`, `detail` and extensions, and shortcuts such as `DomainError.notFound()`.
+  - Exception filters (`@Catch()`, `filters` on routes, controllers, modules and the app) and interceptors (`interceptors` on the same levels), with `TimingInterceptor`, `TransformInterceptor` and mnemosyne's `CacheInterceptor`.
+  - Typed configuration: `Secret` values, module `envSchema`s merged into the app's, `InvalidEnvironmentError`.
+  - `http` options: CORS, security headers, body limits and trusted proxies (`ctx.ip`). Runtimes report the client address through `clientAddress`.
+  - `createTestingHttpApp` and `createHttpClient` send requests to an app in memory, with `expectStatus()`.
+
+  Fixes:
+
+  - App-level `onRequest` middlewares run in the request scope.
+  - On Workers, the request scope of a streamed response is disposed when the body ends, not when `fetch` returns.
+  - `KeyvWorkersKV.clear()` stays within an operation budget (`maxOperations`).
+  - The Node.js bridge treats a destroyed socket as a client abort.
+  - Heracles performance metrics report through the Redis port (`connection` or `client`), not a Bun client.
+  - `styx routes:generate` names anonymous default controllers after their file; `styx create` pins `@elysiumjs/*` packages to the versions it was released with; invalid names are reported as Elysium errors.
+
+- [#15](https://github.com/na2axl/elysiumjs/pull/15) [`fbcc7da`](https://github.com/na2axl/elysiumjs/commit/fbcc7dad127db29da42e7a4a5c2124966731cd88) Thanks [@na2axl](https://github.com/na2axl)! - Resources, queries, units of work and rate limits.
+
+  Breaking:
+
+  - A route with a `response` schema serializes its handler result through it: fields the schema does not declare are dropped, a `Date` becomes an ISO string (`YYYY-MM-DD` for `format: 'date'`), and an object with `toJSON()` becomes what it returns. Set `serialize: false` on a route to send the result as it is.
+
+  Added:
+
+  - `Resource.hidden(schema)` marks a field that never reaches responses nor the OpenAPI document. `Resource.serialize()` and `Resource.project()` are exported for use outside routes.
+  - Sparse fieldsets: `?fields=id,title` keeps only those fields of an object, of each item of an array, or of each item of a `data` array. An unknown or hidden field answers a 400 problem.
+  - Rate limits with `@RateLimit({ window, max, key?, store?, name? })` on routes and controllers (`@RateLimit(false)` turns one off), and a default limit and store in the app's `rateLimit` option, with fixed windows. Responses carry `RateLimit-Limit`, `RateLimit-Remaining`, `RateLimit-Reset` and `RateLimit-Policy`; a client over the limit gets a 429 problem with `Retry-After`. Counts are kept by a `RateLimitStore`: `MemoryRateLimitStore` (core), `RedisRateLimitStore` (`@elysiumjs/redis`) or `WorkersRateLimitStore` over a Cloudflare rate limiting binding (`@elysiumjs/runtime-workers`), which only decides whether a hit is over the limit, so its responses carry no `RateLimit-Reset`.
+  - `ModelResource(model, { hidden, pick, omit, extend })` (`@elysiumjs/mnemosyne`) builds a response schema from a model.
+  - `Query.define(model, spec)` declares the filters (`filter[field][op]=value`), sorts, page size and cursor a list accepts; `Query.schema()` gives its query schema, `Query.parse()` turns a request query into a `ParsedQuery` and answers a 400 problem with a pointer per mistake, and `Query.page()` / `Query.pageSchema()` build cursor pages (`{ data, nextCursor }`).
+  - `DrizzleRepository.list(query)` and `count(query)` run a `ParsedQuery` with keyset pagination (`@elysiumjs/mnemosyne-drizzle`), and `compileQuery()` gives its `where` and `orderBy`.
+  - Units of work: `UnitOfWork.run()` and the `@Transactional()` method decorator run work in one transaction, and `UnitOfWork.afterCommit()` / `afterRollback()` defer work, such as sending a message, until the outermost transaction has ended. `transactional` routes open a unit of work too.
+
+- [#12](https://github.com/na2axl/elysiumjs/pull/12) [`98a16aa`](https://github.com/na2axl/elysiumjs/commit/98a16aae889d46f7a9fb5573188f4cbe3629dd3b) Thanks [@na2axl](https://github.com/na2axl)! - `createWorker(app)` from `@elysiumjs/runtime-workers` builds an application and returns the handlers a Cloudflare Worker exports: `fetch` serves the routes, `queue` hands each batch to the service methods marked `@Workers.queue(name)`, and `scheduled` calls the methods marked `@Workers.cron(expression)`. Each invocation runs with its own env and execution context: `Workers.env()`, `Workers.context()` and `Workers.binding(name)` read them, and `WorkersModule` provides them, and the bindings it lists, as request-scoped services injected with `@Workers.inject(name)`. `KeyvWorkersKV` stores mnemosyne caches in a KV namespace. `bun run check:wrangler` runs a sample Worker in `wrangler dev`.
+
+  `MnemosyneModule` takes other Keyv stores in `cache.stores`, read with `Cache.store(name)`.
+
+  `styx build --target workers` (Hephaestus `hephaestus:build --target workers`, `WorkersBuilder`) bundles a Worker with its routes compiled ahead of time and refuses a bundle that generates code at runtime.
+
+  In core, `Application.boot()` initialises the modules once, for hosts that handle more than requests; `Kernel.serviceClasses(node)` lists the service classes of a module; console output falls back to `console` where the host has no output streams; and a singleton depending on a request-scoped service throws `ScopeMismatchError` even when it is built outside a request.
+
+### Patch Changes
+
+- [#5](https://github.com/na2axl/elysiumjs/pull/5) [`557a3ca`](https://github.com/na2axl/elysiumjs/commit/557a3cab7af8053a8bab9944e492e5022d91aa82) Thanks [@na2axl](https://github.com/na2axl)! - Core runs outside Bun. Environment variables, timers, the HTTP server, process exit and shutdown signals now come from a `Runtime` set with the new `runtime` option of `@Application.register()` or with `Runtime.use()`. Runtimes ship as packages, each exporting `runtime`: `@elysiumjs/runtime-bun`, `@elysiumjs/runtime-node` and `@elysiumjs/runtime-workers` (which also exports `createRuntime({ env })`).
+
+  Breaking: an application needs a runtime (add `runtime` from `@elysiumjs/runtime-bun`), and `Redis` and `RedisModule` moved from core to the new `@elysiumjs/redis` package, which also accepts a `client` factory for runtimes without `Bun.RedisClient`.
+
+  Console colours are plain ANSI codes instead of `Bun.color`, `node:readline` is loaded only when a prompt runs, and core's dist is built for the `node` target so `node:` imports keep their prefix. `check:runtime` scripts in core and runtime-workers fail when their bundles touch the `Bun` global.
+
+  `create-elysium` gets a runtime step: it installs the chosen runtime package and sets it in the generated app. Bun is selectable today; Node.js and Cloudflare Workers are listed as coming later.
+
+- [#20](https://github.com/na2axl/elysiumjs/pull/20) [`87299fd`](https://github.com/na2axl/elysiumjs/commit/87299fd9da82d1a408ced1891c0c3d42991444e5) Thanks [@na2axl](https://github.com/na2axl)! - The framework event bus is `Lifecycle`: `Lifecycle.on`, `Lifecycle.once`, `Lifecycle.emit`, `Lifecycle.off`, `@Lifecycle.on()` and `@Lifecycle.once()`, with the `LifecycleEvent` and `LifecycleHandler` types. It carries the framework's own signals (`elysium:error`, app and server lifecycle, heracles queue events) and in-process listeners.
+- Updated dependencies [[`6bc48fe`](https://github.com/na2axl/elysiumjs/commit/6bc48febd51f7090c582e73f349eaeff7261241c), [`e9c3d98`](https://github.com/na2axl/elysiumjs/commit/e9c3d98dd2714b69100215f7c8a80046da463148), [`557a3ca`](https://github.com/na2axl/elysiumjs/commit/557a3cab7af8053a8bab9944e492e5022d91aa82), [`ccc3f5b`](https://github.com/na2axl/elysiumjs/commit/ccc3f5bb904d1bf52d8c72ebf7ea8d10f617a8c4), [`6789879`](https://github.com/na2axl/elysiumjs/commit/678987976ecfd46b534b65276e0de3f448977562), [`87299fd`](https://github.com/na2axl/elysiumjs/commit/87299fd9da82d1a408ced1891c0c3d42991444e5), [`bee66bd`](https://github.com/na2axl/elysiumjs/commit/bee66bdc874b8f23fea356f7d3adf7555a48ca64), [`0057b67`](https://github.com/na2axl/elysiumjs/commit/0057b67df0e3abecab8a9accff6b55a6a64c21df), [`632d77b`](https://github.com/na2axl/elysiumjs/commit/632d77b561fc43ade605fb69b06ac1b9b9a2ffc4), [`1ea417e`](https://github.com/na2axl/elysiumjs/commit/1ea417e3583250bc2f975d795f398b7ff736115d), [`0956186`](https://github.com/na2axl/elysiumjs/commit/0956186db0ca5a83c0a6636aeb2a4c81a0033de4), [`fbcc7da`](https://github.com/na2axl/elysiumjs/commit/fbcc7dad127db29da42e7a4a5c2124966731cd88), [`ac96e55`](https://github.com/na2axl/elysiumjs/commit/ac96e55874b0ffe350b287c4278cd85afecb7576), [`98a16aa`](https://github.com/na2axl/elysiumjs/commit/98a16aae889d46f7a9fb5573188f4cbe3629dd3b)]:
+  - @elysiumjs/core@0.11.0
+  - @elysiumjs/redis@0.1.0
+
+## 0.3.1
+
+### Patch Changes
+
+- Updated dependencies [[`68a0cdd`](https://github.com/na2axl/elysiumjs/commit/68a0cdd8b2e4a003d6e0af2d78985623cae40428), [`2c49acd`](https://github.com/na2axl/elysiumjs/commit/2c49acd3b552aa43765d70339fa216961499e1b5), [`76ba0ff`](https://github.com/na2axl/elysiumjs/commit/76ba0ff18f3c196cebc2189426328f67cb699f46), [`4ebf029`](https://github.com/na2axl/elysiumjs/commit/4ebf029611e6d753a4f1bfdbe247a75d954d9ded), [`bacce71`](https://github.com/na2axl/elysiumjs/commit/bacce7146f667a1a46bf474dc0344fb0111ae12a)]:
+  - @elysiumjs/core@0.10.0
+
+## 0.3.0
+
+### Minor Changes
+
+- [`5fef4a7`](https://github.com/na2axl/elysiumjs/commit/5fef4a7199f502fc4fe035299e7670739459a108) Thanks [@na2axl](https://github.com/na2axl)! - Fix tenant isolation, transactions and query caching in the database layer.
+
+  Breaking changes:
+
+  - `TenantMiddleware.validateTenant()` now rejects every tenant unless you override it, and tenant identifiers must match `TENANT_ID_PATTERN` (1 to 63 ASCII letters, digits, `_` or `-`, not starting with `pg_` and other than `information_schema`, in any case) before it is called. Requests that send any other tenant now fail with `Invalid tenant`. Requests without a tenant still resolve to `public` on `SimpleTenantMiddleware`. To migrate, check the tenant against your own data:
+
+    ```ts
+    class OrganizationMiddleware extends SimpleTenantMiddleware {
+    	protected async validateTenant(tenant: string): Promise<boolean> {
+    		return Organization.exists(tenant);
+    	}
+    }
+    ```
+
+  - `getTenantSchema()`, `registerTenantSchema()` and `wrapTenantSchema()` throw on tenant identifiers that do not match `TENANT_ID_PATTERN`.
+  - `setConnectionTenant()` is removed. It set the tenant on a pooled connection for the whole session, so the tenant leaked to other requests. Use `withRLS()`, or `Database.transaction()` in RLS mode, which scope the tenant to a transaction.
+  - `RepositoryInterface.update()` and `delete()`, and the `DrizzleRepository` implementations, return `null` when no row has the id. They returned `undefined` while typed as a row. `DrizzleRepository` also requires a model whose table has an `id` column.
+  - `@transactional` handlers run through the `db.transaction` service that `DrizzleModule` provides (its name is exported by `@elysiumjs/core` as `DATABASE_TRANSACTION_SERVICE`, and still re-exported by `@elysiumjs/mnemosyne`). A transactional handler without a database module now fails with an error naming the service.
+  - `@transactional` generator handlers commit only when the whole stream was sent. A stream closed early, or whose client disconnects (even while the handler is waiting), rolls back.
+  - In RLS mode, a transaction is bound to one tenant for its whole life: the tenant set (with a transaction-local `set_config`) when `Database.transaction()`, a `@transactional` handler, `withRLS()` or `withIsolation()` opens it, from the explicit tenant or the current one (`public` when there is none). Work that finds a transaction open on its connection (`withRLS()`, `withIsolation()`, `Database.transaction()`, repository calls) joins it only when its tenant is the transaction's tenant, and throws `TenantMismatchError` otherwise, without running anything: the tenant of an open transaction never changes. Inside a transaction, `Database.getConnection()` only returns it to work for its tenant (the current tenant, or `public`), and throws `TenantMismatchError` otherwise, so raw queries never run for another tenant; queries on the `tx` handle a callback received run as the transaction's tenant. Work for several tenants, such as an admin fan-out, must use one `withRLS()` per tenant outside any transaction, not nested in one.
+  - In RLS mode, each repository call made outside a transaction runs in its own transaction bound to the current tenant: `BEGIN`, `set_config` of the tenant, the query, `COMMIT`. These calls do not use the query cache, since the cache is bypassed inside transactions. Group calls in `Database.transaction()` or `withRLS()` to share one transaction.
+  - In RLS mode, code running without a tenant in context (background jobs, CLI commands, scripts) is scoped to the `public` tenant. Set the tenant with `withTenant(tenant, () => ...)` around the work (repository calls and `Database.transaction()` then use it), or with `withRLS(tenant, (tx) => ...)`.
+  - `migration:run` validates `--tenant` against `TENANT_ID_PATTERN`. Without a terminal it no longer creates a missing schema: pass `--create-schema` (which also skips the question in a terminal), or it fails.
+  - Query cache keys start with the connection name, and each connection has its own cache transaction scope. When several applications or environments share one cache store and use the same connection names for different databases, set `cache: { prefix }` on each connection: the prefix comes before the connection name in every key (empty by default).
+  - `DrizzleDatabaseCache` keys and values changed: entries written by earlier versions are ignored. The default TTL of cached queries (including with `cache: true`) is now 60 seconds instead of 1 second, and is set with `cache: { ttl }` in seconds.
+  - `Cache.memory` keeps a separate LRU per tag namespace, so `lruSize` applies to each namespace.
+
+  Fixes and additions:
+
+  - In RLS mode, repository operations outside a transaction run in one bound to the current tenant, through the strategy's `withIsolation()`. Transactions opened with `Database.transaction()` or by `@transactional` handlers set the tenant variable when they open. `withIsolation()` and `withRLS()` expose their transaction to repositories and `Database.getConnection()`. `TenantMismatchError` is exported.
+  - `Database.transaction(callback, connection?)` opens a transaction and registers it for the callback. When a transaction is already open on the same connection, the callback joins it (no savepoint: an error rolls back the whole transaction); in RLS mode only if the current tenant is the transaction's tenant (see above). Transactions are tracked by connection, so every name of a connection (`default` and the name it aliases) sees them, and named connections take part in transactions. `Database.getBaseConnection()`, `Database.inTransaction()` and `Database.runInTransaction()` are added. The `db:tx` context entry is still set for the default connection.
+  - `@transactional` generator handlers keep their transaction open until the stream ends, then commit (or roll back if the handler throws). They previously committed before running and failed with `generator.next is not a function`. Generator handlers also see the request context (`tenant`, `http:context`).
+  - The query cache is scoped to the connection and the current tenant, is shared correctly by several app instances (table versions stored in the cache), is not read or written inside transactions, and invalidates the tables a transaction changed once it commits. A result is only stored when no mutation happened since its query started, including when concurrent queries of the same key finish out of order. Cached queries honour Drizzle's `ex`, `px`, `exat`, `pxat` and `keepTtl` options.
+  - Cache namespaces (`Cache.redis.tags(...)`, `Cache.memory.tags(...)`) no longer overwrite each other: reads, deletes and `clear()` stay within their namespace.
+  - `getSessionTenant()` reads the Bun SQL result correctly, and `getCurrentTenant()` works without an application instance (for example under `Application.testing`).
+  - `migration:run` takes an advisory lock per tenant, adds a unique index on `elysium_migrations.name` (also to existing tables), finds the migrations from the project root (`.elysiumrc`), sets the `search_path` for the transaction only, asks before opening the transaction whether to create a missing schema, and always closes its client. Existing duplicate migration names must be removed before the unique index can be created.
+  - `migration:generate` only removes `"public".` qualifiers from the migration it generates, and leaves string literals, comments and dollar-quoted bodies (`DO` blocks, functions) untouched.
+  - `DatabaseDriver.createConnection()` receives the connection name as an optional second argument.
+  - `KeyvRedis` deletes with a single `UNLINK` (or `DEL`) per call or batch and reports failed deletes in `clear()` as `error` events.
+
+### Patch Changes
+
+- Updated dependencies [[`5fef4a7`](https://github.com/na2axl/elysiumjs/commit/5fef4a7199f502fc4fe035299e7670739459a108)]:
+  - @elysiumjs/core@0.9.0
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -29,6 +29,18 @@ import { MnemosyneModule } from '@elysiumjs/mnemosyne';
 export class App extends Application {}
 ```
 
+Any Keyv store can back a cache of its own with `stores`, read with `Cache.store(name)`. On Cloudflare Workers, `KeyvWorkersKV` from `@elysiumjs/runtime-workers` stores entries in a KV namespace:
+
+```ts
+import { KeyvWorkersKV } from '@elysiumjs/runtime-workers';
+
+MnemosyneModule.with({
+	cache: { redis: false, stores: { kv: () => new KeyvWorkersKV({ binding: 'CACHE' }) } }
+});
+
+await Cache.store('kv').set('greeting', 'hello', 120_000);
+```
+
 Models and repositories are built with a driver package. See [`@elysiumjs/mnemosyne-drizzle`](../mnemosyne-drizzle/README.md).
 
 ## License

package/dist/cache.d.ts

@@ -3,6 +3,11 @@ import type { KeyvStoreAdapter } from 'keyv';
 export declare const REDIS_CACHE_SERVICE = "mnemosyne.cache.redis";
 /** Name of the global service backing `Cache.memory`. */
 export declare const MEMORY_CACHE_SERVICE = "mnemosyne.cache.memory";
+/**
+ * Name of the global service backing `Cache.store(name)`.
+ * @param name The store name, as given in the `MnemosyneModule` config.
+ */
+export declare const cacheStoreService: (name: string) => string;
 /**
  * Interface for a cache storage.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -82,12 +87,16 @@ export interface CacheInterface {
     tags(...tags: string[]): Omit<CacheInterface, 'tags'>;
 }
 /**
- * Makes a cache interface wrapping the given store.
- * @author Axel Nana <axel.nana@workburd.com>
- * @param store The cache storage to use in the interface.
+ * Makes a cache interface over stores built by the given factory.
+ *
+ * Keyv writes its namespace on the store adapter it wraps, so adapters cannot be shared between
+ * namespaces: the last namespace would win for every Keyv using the adapter, and `clear()` would
+ * wipe the other namespaces. The base cache and each tagged cache therefore get their own adapter.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param createStore Creates a new store adapter, called once per namespace.
  * @returns A new `CacheInterface`.
  */
-export declare const makeCacheInterface: (store: KeyvStoreAdapter) => CacheInterface;
+export declare const makeCacheInterface: (createStore: () => KeyvStoreAdapter) => CacheInterface;
 /**
  * Static access to the caches provided by the `MnemosyneModule`.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -127,4 +136,12 @@ export declare abstract class Cache {
      * @throws {ServiceNotFoundError} If the `MnemosyneModule` is not loaded or has no memory cache.
      */
     static get memory(): CacheInterface;
+    /**
+     * A cache over a store given in `MnemosyneModule.with({ cache: { stores } })`, such as
+     * Workers KV.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param name The store name.
+     * @throws {ServiceNotFoundError} If the `MnemosyneModule` has no store with that name.
+     */
+    static store(name: string): CacheInterface;
 }

package/dist/cache.interceptor.d.ts

@@ -0,0 +1,36 @@
+import type { InterceptorClass, InterceptorContext } from '@elysiumjs/core';
+/**
+ * Options of {@link CacheInterceptor.with}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type CacheInterceptorOptions = {
+    /** How long a response stays cached, in milliseconds. */
+    ttl: number;
+    /**
+     * The cache: `memory` (the default), `redis`, or the name of a store given in
+     * `MnemosyneModule.with({ cache: { stores } })`.
+     */
+    store?: 'memory' | 'redis' | (string & {});
+    /**
+     * Builds the cache key of a request. Defaults to the tenant, the method, the path and the query
+     * string, so that tenants never share entries.
+     */
+    key?: (ctx: InterceptorContext) => string;
+};
+/**
+ * Builds interceptors that cache handler results.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare abstract class CacheInterceptor {
+    /**
+     * Creates an interceptor class that caches the results of `GET` and `HEAD` handlers. A cached
+     * result skips the handler. Responses (`Response` objects) are never cached. The response gets
+     * an `x-cache: hit` or `x-cache: miss` header.
+     * @param options The TTL, the cache and the key.
+     * @example
+     * ```ts
+     * @Http.get('/trending', { interceptors: [CacheInterceptor.with({ ttl: 30_000 })] })
+     * ```
+     */
+    static with(options: CacheInterceptorOptions): InterceptorClass;
+}

package/dist/database.d.ts

@@ -1,5 +1,10 @@
 import type { CacheInterface } from './cache';
 import type { DatabaseCacheConfig, DatabaseDriver } from './interfaces';
+/**
+ * Name of the global service running a callback in a database transaction, registered by driver
+ * modules. Used by `@transactional` HTTP handlers; defined by `@elysiumjs/core`.
+ */
+export { DATABASE_TRANSACTION_SERVICE } from '@elysiumjs/core';
 /**
  * Creates a cache storage instance tagged for database use.
  * Drivers can use this to build their cache backends.
@@ -34,15 +39,71 @@ export declare abstract class AbstractDatabase<TConnection, TConnectionConfig> {
     /**
      * Retrieves the connection with the given name.
      *
-     * For the default connection, checks the async context for a
-     * transaction handle (`db:tx`) before falling back to the service container.
+     * When a transaction is open on that connection in the current async context (see
+     * {@link transaction}), the transaction handle is returned instead. Transactions are tracked by
+     * the connection they run on, so every name of a connection (such as `default` and the name it
+     * aliases) sees them.
      * @throws {ServiceNotFoundError} If no connection with that name is registered.
      *
      * @author Axel Nana <axel.nana@workbud.com>
      * @param name The connection name.
-     * @returns The connection with the given name.
+     * @returns The connection with the given name, or its open transaction.
      */
     getConnection(name?: string): TConnection;
+    /**
+     * Retrieves the connection with the given name, ignoring any open transaction.
+     * @throws {ServiceNotFoundError} If no connection with that name is registered.
+     *
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param name The connection name.
+     * @returns The connection registered under the given name.
+     */
+    getBaseConnection(name?: string): TConnection;
+    /**
+     * Checks whether a transaction is open on the given connection in the current async context.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param name The connection name.
+     * @returns `true` if a transaction is open on the connection, `false` otherwise.
+     */
+    inTransaction(name?: string): boolean;
+    /**
+     * Runs a callback in a transaction on the given connection.
+     *
+     * The transaction is registered in the async context for the duration of the callback, so that
+     * {@link getConnection} (and the repositories using it) returns it for that connection. When a
+     * transaction is already open on the connection, the callback joins it.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @template T The return type of the callback.
+     * @param callback The function to run in the transaction. Receives the transaction handle.
+     * @param name The connection name.
+     * @returns The return value of the callback.
+     */
+    transaction<T>(callback: (tx: TConnection) => Promise<T>, name?: string): Promise<T>;
+    /**
+     * Runs a callback with a transaction registered in the async context for a connection.
+     *
+     * The current context store is copied, never modified. Drivers and tenancy strategies that open
+     * transactions themselves use it to make the transaction visible to {@link getConnection}.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @template T The return type of the callback.
+     * @param connection The connection the transaction runs on.
+     * @param tx The transaction handle.
+     * @param callback The function to run.
+     * @returns The return value of the callback.
+     */
+    runInTransaction<T>(connection: TConnection, tx: TConnection, callback: () => T): T;
+    /**
+     * Gets the transaction open on a connection in the current async context.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param connection The connection, as returned by {@link getBaseConnection}.
+     * @returns The transaction handle, or `undefined` if none is open.
+     */
+    getActiveTransaction(connection: TConnection): TConnection | undefined;
+    /**
+     * Checks whether a connection is the one the `default` name resolves to.
+     * @param connection The connection.
+     */
+    private isDefaultConnection;
     /**
      * Checks if a connection with the given name exists.
      * @author Axel Nana <axel.nana@workbud.com>

package/dist/index.d.ts

@@ -2,8 +2,12 @@ export type { ColumnMetadata, DatabaseCacheConfig, DatabaseCacheStrategy, Databa
 export * from './database';
 export * from './model';
 export * from './repository';
+export { ModelResource, type ModelResourceOptions } from './resource';
+export { type TransactionRunner, Transactional, UnitOfWork, withUnitOfWork } from './unit-of-work';
+export { type CursorPage, type FilterOperator, type ParsedFilter, type ParsedQuery, type ParsedSort, type QueryFieldType, type QueryFilterSpec, type QuerySpec, Query } from './query';
 export * from './tenancy';
 export type { TenancyConfig, TenancyMode, ModelTenancyConfig } from './tenancy';
-export { Cache, type CacheInterface, MEMORY_CACHE_SERVICE, REDIS_CACHE_SERVICE } from './cache';
+export { Cache, type CacheInterface, cacheStoreService, MEMORY_CACHE_SERVICE, REDIS_CACHE_SERVICE } from './cache';
 export * from './mnemosyne.module';
 export * from './keyv-redis';
+export { CacheInterceptor, type CacheInterceptorOptions } from './cache.interceptor';

package/dist/index.js

@@ -1,2 +1,2 @@
 // @bun
-var __legacyDecorateClassTS=function(decorators,target,key,desc){var c=arguments.length,r=c<3?target:desc===null?desc=Object.getOwnPropertyDescriptor(target,key):desc,d;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")r=Reflect.decorate(decorators,target,key,desc);else for(var i=decorators.length-1;i>=0;i--)if(d=decorators[i])r=(c<3?d(r):c>3?d(target,key,r):d(target,key))||r;return c>3&&r&&Object.defineProperty(target,key,r),r};import{Application,Service as Service2,ServiceNotFoundError as ServiceNotFoundError2}from"@elysiumjs/core";import{Service,ServiceNotFoundError}from"@elysiumjs/core";import{createCache}from"cache-manager";import{Keyv}from"keyv";import{alphabetical}from"radash";var REDIS_CACHE_SERVICE="mnemosyne.cache.redis",MEMORY_CACHE_SERVICE="mnemosyne.cache.memory",makeCacheInterface=(store)=>{let base=createCache({stores:[new Keyv({store,namespace:"cache"})]}),tagsCache=new Map;return{...base,tags(...tags){let namespace=`cache__${alphabetical(tags,(item)=>item).join("__")}`,cache=tagsCache.get(namespace);if(!cache)cache=createCache({stores:[new Keyv({store,namespace})]}),tagsCache.set(namespace,cache);return cache}}},getCache=(name)=>{let cache=Service.get(name);if(!cache)throw new ServiceNotFoundError(name);return cache};class Cache{static weak=Object.seal({map:new WeakMap,get(ctx){if(!this.map.has(ctx))this.map.set(ctx,{});return this.map.get(ctx)},del(ctx){this.map.delete(ctx)}});static get redis(){return getCache(REDIS_CACHE_SERVICE)}static get memory(){return getCache(MEMORY_CACHE_SERVICE)}}var createDatabaseCacheStorage=(config)=>Cache[config.storage??"redis"].tags("database");class AbstractDatabase{static getConnectionName(name){return`db.connection.${name}`}getConnection(name="default"){if(name==="default"){let tx=Application.context.getStore()?.get("db:tx");if(tx)return tx}let serviceName=AbstractDatabase.getConnectionName(name),connection=Service2.get(serviceName);if(connection===null)throw new ServiceNotFoundError2(serviceName);return connection}connectionExists(name){return Service2.exists(AbstractDatabase.getConnectionName(name))}getDefaultConnection(){return this.getConnection("default")}getRawClient(name="default"){return this.driver.getRawClient(this.getConnection(name))}}import{Application as Application3}from"@elysiumjs/core";import{t}from"elysia";import{Application as Application2,Middleware,Service as Service3}from"@elysiumjs/core";var TENANCY_CONFIG_SERVICE="mnemosyne.tenancy.config",TENANCY_STRATEGY_SERVICE="mnemosyne.tenancy.strategy",getTenancyConfig=()=>Service3.get(TENANCY_CONFIG_SERVICE)??{mode:"schema"},getTenancyStrategy=()=>Service3.get(TENANCY_STRATEGY_SERVICE),getCurrentTenant=()=>{if(!Application2.instance||!Application2.context.getStore)return null;return Application2.context.getStore()?.get("tenant")??null},withTenant=(tenant,callback)=>{let currentStore=Application2.context.getStore(),newStore=new Map(currentStore);return newStore.set("tenant",tenant),Application2.context.run(newStore,callback)};class TenantMiddleware extends Middleware{header="x-tenant-id";allowPublic=!0;connectionName="default";async validateTenant(_tenant){return!0}async onTenantResolved(_tenant,_ctx){}onTenantError(reason,_ctx){if(reason==="missing")throw Error("Tenant ID required");else throw Error("Invalid tenant")}async onRequest(ctx){let tenantId=ctx.request.headers.get(this.header);if(!tenantId||tenantId==="public"){if(this.allowPublic){ctx.tenant="public";return}return this.onTenantError("missing",ctx)}if(!await this.validateTenant(tenantId))return this.onTenantError("invalid",ctx);ctx.tenant=tenantId,await this.onTenantResolved(tenantId,ctx)}}class SimpleTenantMiddleware extends TenantMiddleware{}class StrictTenantMiddleware extends TenantMiddleware{allowPublic=!1}var createSchemaFromModel=(columns,{mode="select"}={})=>{if(columns===void 0||columns.length===0)return t.Object({});let properties={};for(let column of columns){if(["create","update"].includes(mode)&&column.isPrimaryKey)continue;if(properties[column.name]=parseColumnType(column),column.nullable)properties[column.name]=t.Nullable(properties[column.name]);if(mode==="update"||column.hasDefault||column.nullable)properties[column.name]=t.Optional(properties[column.name])}return t.Object(properties)},parseColumnType=(column)=>{switch(column.dataType){case"string":return t.String();case"uuid":return t.String({format:"uuid"});case"number":return t.Number();case"boolean":return t.Boolean();case"array":return t.Array(t.Any());case"json":return t.Object({});case"date":return t.Transform(t.String({format:"date"})).Decode((date)=>new Date(date)).Encode((date)=>date.toISOString());case"datetime":return t.Transform(t.String({format:"date-time"})).Decode((date)=>new Date(date)).Encode((date)=>date.toISOString());case"bigint":return t.BigInt();case"buffer":return t.File();default:return t.Never()}},AbstractModel=(tableName,columns,adapter,baseTable)=>{let columnMetadata=adapter.getColumns(baseTable);class M{static $inferSelect=void 0;static $inferInsert=void 0;static $inferUpdate=void 0;static get table(){if(!Application3.instance||!Application3.context.getStore)return baseTable;if(this.supportTenancy){let tenant=getCurrentTenant()??"public";if(tenant!=="public"){let strategy=getTenancyStrategy();if(strategy)return strategy.resolveTable(baseTable,tenant);return adapter.createTenantTable(baseTable,tenant)}}return baseTable}static tableName=tableName;static columns=columns;static insertSchema=createSchemaFromModel(columnMetadata,{mode:"create"});static updateSchema=createSchemaFromModel(columnMetadata,{mode:"update"});static selectSchema=createSchemaFromModel(columnMetadata,{mode:"select"});static supportTenancy=!1}return M};var AbstractRepository=(model,database)=>{class R{static Model=model;static connection="default";get db(){return database.getConnection(this.constructor.connection)}}return R};import{Module}from"@elysiumjs/core";import{KeyvCacheableMemory}from"cacheable";import{EventEmitter}from"events";import{Event,Redis,Service as Service4}from"@elysiumjs/core";class KeyvRedis extends EventEmitter{#client;#namespace;#keyPrefixSeparator="::";#clearBatchSize=1000;#useUnlink=!0;#noNamespaceAffectsAll=!1;#connection;constructor(props){super();this.#connection=props.connection,this.#namespace=props.namespace,this.#keyPrefixSeparator=props.keyPrefixSeparator??"::",this.#clearBatchSize=props.clearBatchSize??1000,this.#useUnlink=props.useUnlink??!0,this.#noNamespaceAffectsAll=props.noNamespaceAffectsAll??!1,this.on("error",(error)=>{Event.emit("elysium:error",error)})}async getClient(){return this.#client??=await Service4.resolve(Redis.getConnectionName(this.#connection)),this.#client}get opts(){return{namespace:this.#namespace,keyPrefixSeparator:this.#keyPrefixSeparator,clearBatchSize:this.#clearBatchSize,noNamespaceAffectsAll:this.#noNamespaceAffectsAll,dialect:"redis",url:this.#connection}}get namespace(){return this.#namespace}set namespace(value){this.#namespace=value}async get(key){let client=await this.getClient();key=this.createKeyPrefix(key,this.#namespace);let value=await client.get(key);return value===null?void 0:value}async set(key,value,ttl){let client=await this.getClient();if(key=this.createKeyPrefix(key,this.#namespace),ttl)await client.set(key,value,"PX",ttl);else await client.set(key,value)}async setMany(values){let client=await this.getClient(),multi=[];for(let{key,value,ttl}of values){let prefixedKey=this.createKeyPrefix(key,this.#namespace);if(ttl)multi.push(client.set(prefixedKey,value,"PX",ttl));else multi.push(client.set(prefixedKey,value))}await Promise.all(multi)}async delete(key){let client=await this.getClient();return key=this.createKeyPrefix(key,this.#namespace),await(this.#useUnlink?client.send("UNLINK",[key]):client.del(key))>0}async clear(){try{let client=await this.getClient();if(!this.#namespace&&this.#noNamespaceAffectsAll){await client.send("FLUSHDB",[]);return}let cursor="0",batchSize=this.#clearBatchSize,match=this.#namespace?`${this.#namespace}${this.#keyPrefixSeparator}*`:"*",deletePromises=[];do{let result=await client.send("SCAN",[cursor,"MATCH",match,"COUNT",batchSize.toString(),"TYPE","string"]),[newCursor,keys]=result;if(cursor=newCursor.toString(),keys.length===0)continue;if(!this.#namespace)keys=keys.filter((key)=>!key.includes(this.#keyPrefixSeparator));deletePromises.push(keys.map((key)=>client.del(key)))}while(cursor!=="0");await Promise.all(deletePromises)}catch(error){this.emit("error",error)}}async has(key){let client=await this.getClient();return key=this.createKeyPrefix(key,this.#namespace),client.exists(key)}async hasMany(keys){let client=await this.getClient(),multi=[];for(let key of keys){let prefixedKey=this.createKeyPrefix(key,this.#namespace);multi.push(client.exists(prefixedKey))}return Promise.all(multi)}async getMany(keys){let client=await this.getClient();if(keys.length===0)return[];return keys=keys.map((key)=>this.createKeyPrefix(key,this.#namespace)),await client.mget(...keys)}async disconnect(){this.#client=void 0}async deleteMany(keys){let client=await this.getClient(),result=!1,multi=[];for(let key of keys){let prefixedKey=this.createKeyPrefix(key,this.#namespace);if(this.#useUnlink)multi.push(client.send("UNLINK",[prefixedKey]));else multi.push(client.del(prefixedKey))}let results=await Promise.all(multi);for(let deleted of results)if(typeof deleted==="number"&&deleted>0)result=!0;return result}async*iterator(namespace){let client=await this.getClient(),match=namespace?`${namespace}${this.#keyPrefixSeparator}*`:"*",cursor="0";do{let result=await client.send("SCAN",[cursor,"MATCH",match,"TYPE","string"]),[newCursor,keys]=result;if(cursor=newCursor.toString(),!namespace&&!this.#noNamespaceAffectsAll)keys=keys.filter((key)=>!key.includes(this.#keyPrefixSeparator));if(keys.length>0){let values=await client.mget(...keys);for(let i of keys.keys()){let key=this.getKeyWithoutPrefix(keys[i],namespace),value=values[i];yield[key,value]}}}while(cursor!=="0")}createKeyPrefix(key,namespace){return namespace?`${namespace}${this.#keyPrefixSeparator}${key}`:key}getKeyWithoutPrefix(key,namespace){return namespace?key.replace(`${namespace}${this.#keyPrefixSeparator}`,""):key}}class MnemosyneModule extends Module.configurable({defaults:{cache:{redis:{connection:"cache"},memory:{ttl:60000,lruSize:5000}}}}){}MnemosyneModule=__legacyDecorateClassTS([Module.register({services:(config)=>{let services=[],{redis,memory}=config.cache;if(redis)services.push({name:REDIS_CACHE_SERVICE,global:!0,factory:()=>makeCacheInterface(new KeyvRedis({connection:redis.connection}))});if(memory)services.push({name:MEMORY_CACHE_SERVICE,global:!0,factory:()=>makeCacheInterface(new KeyvCacheableMemory({ttl:memory.ttl,lruSize:memory.lruSize}))});return services}})],MnemosyneModule);export{AbstractDatabase,AbstractModel,AbstractRepository,Cache,KeyvRedis,MEMORY_CACHE_SERVICE,MnemosyneModule,REDIS_CACHE_SERVICE,SimpleTenantMiddleware,StrictTenantMiddleware,TENANCY_CONFIG_SERVICE,TENANCY_STRATEGY_SERVICE,TenantMiddleware,createDatabaseCacheStorage,createSchemaFromModel,getCurrentTenant,getTenancyConfig,getTenancyStrategy,withTenant};
+var __legacyDecorateClassTS=function(decorators,target,key,desc){var c=arguments.length,r=c<3?target:desc===null?desc=Object.getOwnPropertyDescriptor(target,key):desc,d;if(typeof Reflect==="object"&&typeof Reflect.decorate==="function")r=Reflect.decorate(decorators,target,key,desc);else for(var i=decorators.length-1;i>=0;i--)if(d=decorators[i])r=(c<3?d(r):c>3?d(target,key,r):d(target,key))||r;return c>3&&r&&Object.defineProperty(target,key,r),r};import{Application,Service as Service2,ServiceNotFoundError as ServiceNotFoundError2}from"@elysiumjs/core";import{Service,ServiceNotFoundError}from"@elysiumjs/core";import{createCache}from"cache-manager";import{Keyv}from"keyv";import{alphabetical}from"radash";var REDIS_CACHE_SERVICE="mnemosyne.cache.redis",MEMORY_CACHE_SERVICE="mnemosyne.cache.memory",cacheStoreService=(name)=>`mnemosyne.cache.store.${name}`,makeCacheInterface=(createStore)=>{let makeNamespace=(namespace)=>createCache({stores:[new Keyv({store:createStore(),namespace})]}),base=makeNamespace("cache"),tagsCache=new Map;return{...base,tags(...tags){let namespace=`cache__${alphabetical(tags,(item)=>item).join("__")}`,cache=tagsCache.get(namespace);if(!cache)cache=makeNamespace(namespace),tagsCache.set(namespace,cache);return cache}}},getCache=(name)=>{let cache=Service.get(name);if(!cache)throw new ServiceNotFoundError(name);return cache};class Cache{static weak=Object.seal({map:new WeakMap,get(ctx){if(!this.map.has(ctx))this.map.set(ctx,{});return this.map.get(ctx)},del(ctx){this.map.delete(ctx)}});static get redis(){return getCache(REDIS_CACHE_SERVICE)}static get memory(){return getCache(MEMORY_CACHE_SERVICE)}static store(name){return getCache(cacheStoreService(name))}}import{DATABASE_TRANSACTION_SERVICE}from"@elysiumjs/core";var createDatabaseCacheStorage=(config)=>Cache[config.storage??"redis"].tags("database");class AbstractDatabase{static getConnectionName(name){return`db.connection.${name}`}getConnection(name="default"){if(name==="default"){let legacy=Application.context.getStore()?.get("db:tx");if(legacy)return legacy}let connection=this.getBaseConnection(name);return this.getActiveTransaction(connection)??connection}getBaseConnection(name="default"){let serviceName=AbstractDatabase.getConnectionName(name),connection=Service2.get(serviceName);if(connection===null)throw new ServiceNotFoundError2(serviceName);return connection}inTransaction(name="default"){return this.getActiveTransaction(this.getBaseConnection(name))!==void 0}async transaction(callback,name="default"){let connection=this.getBaseConnection(name),active=this.getActiveTransaction(connection);if(active!==void 0)return callback(active);return this.driver.withTransaction(connection,(tx)=>this.runInTransaction(connection,tx,()=>callback(tx)))}runInTransaction(connection,tx,callback){let store=Application.context.getStore(),transactions=new Map(store?.get("db:transactions"));transactions.set(connection,tx);let next=new Map(store);if(next.set("db:transactions",transactions),this.isDefaultConnection(connection))next.set("db:tx",tx);return Application.context.run(next,callback)}getActiveTransaction(connection){return Application.context.getStore()?.get("db:transactions")?.get(connection)}isDefaultConnection(connection){return Service2.get(AbstractDatabase.getConnectionName("default"))===connection}connectionExists(name){return Service2.exists(AbstractDatabase.getConnectionName(name))}getDefaultConnection(){return this.getConnection("default")}getRawClient(name="default"){return this.driver.getRawClient(this.getConnection(name))}}import{Application as Application3}from"@elysiumjs/core";import{t}from"elysia";import{Application as Application2,Middleware,Service as Service3}from"@elysiumjs/core";var TENANCY_CONFIG_SERVICE="mnemosyne.tenancy.config",TENANCY_STRATEGY_SERVICE="mnemosyne.tenancy.strategy",getTenancyConfig=()=>Service3.get(TENANCY_CONFIG_SERVICE)??{mode:"schema"},getTenancyStrategy=()=>Service3.get(TENANCY_STRATEGY_SERVICE),getCurrentTenant=()=>Application2.context.getStore()?.get("tenant")??null,withTenant=(tenant,callback)=>{let currentStore=Application2.context.getStore(),newStore=new Map(currentStore);return newStore.set("tenant",tenant),Application2.context.run(newStore,callback)},TENANT_ID_PATTERN=/^(?!pg_)(?!information_schema$)[a-z0-9_-]{1,63}$/i,isValidTenantId=(tenant)=>TENANT_ID_PATTERN.test(tenant);class TenantMiddleware extends Middleware{header="x-tenant-id";allowPublic=!0;connectionName="default";async validateTenant(_tenant){return!1}async onTenantResolved(_tenant,_ctx){}onTenantError(reason,_ctx){if(reason==="missing")throw Error("Tenant ID required");else throw Error("Invalid tenant")}async onRequest(ctx){let tenantId=ctx.request.headers.get(this.header);if(!tenantId||tenantId==="public"){if(this.allowPublic){ctx.tenant="public";return}return this.onTenantError("missing",ctx)}if(!(isValidTenantId(tenantId)&&await this.validateTenant(tenantId)))return this.onTenantError("invalid",ctx);ctx.tenant=tenantId,await this.onTenantResolved(tenantId,ctx)}}class SimpleTenantMiddleware extends TenantMiddleware{}class StrictTenantMiddleware extends TenantMiddleware{allowPublic=!1}var createSchemaFromModel=(columns,{mode="select"}={})=>{if(columns===void 0||columns.length===0)return t.Object({});let properties={};for(let column of columns){if(["create","update"].includes(mode)&&column.isPrimaryKey)continue;if(properties[column.name]=parseColumnType(column),column.nullable)properties[column.name]=t.Nullable(properties[column.name]);if(mode==="update"||column.hasDefault||column.nullable)properties[column.name]=t.Optional(properties[column.name])}return t.Object(properties)},parseColumnType=(column)=>{switch(column.dataType){case"string":return t.String();case"uuid":return t.String({format:"uuid"});case"number":return t.Number();case"boolean":return t.Boolean();case"array":return t.Array(t.Any());case"json":return t.Object({});case"date":return t.Codec(t.String({format:"date"})).Decode((date)=>new Date(date)).Encode((date)=>date.toISOString());case"datetime":return t.Codec(t.String({format:"date-time"})).Decode((date)=>new Date(date)).Encode((date)=>date.toISOString());case"bigint":return t.BigInt();case"buffer":return t.File();default:return t.Never()}},AbstractModel=(tableName,columns,adapter,baseTable)=>{let columnMetadata=adapter.getColumns(baseTable);class M{static $inferSelect=void 0;static $inferInsert=void 0;static $inferUpdate=void 0;static get table(){if(!Application3.instance||!Application3.context.getStore)return baseTable;if(this.supportTenancy){let tenant=getCurrentTenant()??"public";if(tenant!=="public"){let strategy=getTenancyStrategy();if(strategy)return strategy.resolveTable(baseTable,tenant);return adapter.createTenantTable(baseTable,tenant)}}return baseTable}static tableName=tableName;static columns=columns;static insertSchema=createSchemaFromModel(columnMetadata,{mode:"create"});static updateSchema=createSchemaFromModel(columnMetadata,{mode:"update"});static selectSchema=createSchemaFromModel(columnMetadata,{mode:"select"});static supportTenancy=!1}return M};var AbstractRepository=(model,database)=>{class R{static Model=model;static connection="default";get db(){return database.getConnection(this.constructor.connection)}}return R};import{Resource}from"@elysiumjs/core";import{t as t2}from"elysia";var ModelResource=(model,options={})=>{let select=model.selectSchema,hidden=new Set(options.hidden??[]),omit=new Set(options.omit??[]),pick=options.pick?new Set(options.pick):void 0,properties={};for(let[name,schema]of Object.entries(select.properties)){if(omit.has(name)||pick&&!pick.has(name)&&!hidden.has(name))continue;properties[name]=hidden.has(name)?Resource.hidden(schema):schema}return t2.Object({...properties,...options.extend})};import{Application as Application4,DATABASE_TRANSACTION_SERVICE as DATABASE_TRANSACTION_SERVICE2,DomainError,getLogger,Service as Service4}from"@elysiumjs/core";var FRAME="uow:frame";class Refusal{error;constructor(error){this.error=error}}var currentFrame=()=>Application4.context.getStore()?.get(FRAME),runHooks=async(hooks,phase)=>{for(let hook of hooks)try{await hook()}catch(error){getLogger().error(`A unit of work ${phase} hook failed`,{error})}},withUnitOfWork=(transaction)=>async(callback,connection)=>{if(currentFrame())return transaction(callback,connection);let frame={afterCommit:[],afterRollback:[]},store=new Map(Application4.context.getStore());store.set(FRAME,frame);let result;try{result=await Application4.context.run(store,()=>transaction(async()=>{let value=await callback();if(value instanceof DomainError)throw new Refusal(value);return value},connection))}catch(error){if(await runHooks(frame.afterRollback,"afterRollback"),error instanceof Refusal)return error.error;throw error}return await runHooks(frame.afterCommit,"afterCommit"),result},UnitOfWork;((UnitOfWork)=>(UnitOfWork.run=(callback,options={})=>{let runner=Service4.get(DATABASE_TRANSACTION_SERVICE2);if(!runner)throw Error(`Units of work need the "${DATABASE_TRANSACTION_SERVICE2}" service. Import a database module (such as DrizzleModule) in the application.`);return runner(callback,options.connection)},UnitOfWork.active=()=>currentFrame()!==void 0,UnitOfWork.afterCommit=async(hook)=>{let frame=currentFrame();if(frame)frame.afterCommit.push(hook);else await runHooks([hook],"afterCommit")},UnitOfWork.afterRollback=(hook)=>{currentFrame()?.afterRollback.push(hook)}))(UnitOfWork||={});var Transactional=(options={})=>(_target,_key,descriptor)=>{let method=descriptor.value;return descriptor.value=function(...args){return UnitOfWork.run(()=>method.apply(this,args),options)},descriptor};import{BadRequestError}from"@elysiumjs/core";import{t as t3}from"elysia";var DEFAULT_LIMIT=20,DEFAULT_MAX_LIMIT=100,FILTER_KEY=/^filter\[([^\]]+)\](?:\[([^\]]+)\])?$/,toBase64Url=(text)=>btoa(String.fromCharCode(...new TextEncoder().encode(text))).replaceAll("+","-").replaceAll("/","_").replace(/=+$/,""),fromBase64Url=(text)=>{let base64=text.replaceAll("-","+").replaceAll("_","/"),binary=atob(base64+"=".repeat((4-base64.length%4)%4));return new TextDecoder().decode(Uint8Array.from(binary,(char)=>char.charCodeAt(0)))},UUID=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,readValue=(type,raw)=>{switch(type){case"number":{let value=Number(raw);return raw.trim()!==""&&Number.isFinite(value)?{value}:{error:"must be a number"}}case"boolean":return raw==="true"||raw==="false"?{value:raw==="true"}:{error:"must be true or false"};case"date":{let value=new Date(raw);return Number.isNaN(value.getTime())?{error:"must be a date"}:{value}}case"uuid":return UUID.test(raw)?{value:raw}:{error:"must be a UUID"};default:return{value:raw}}},typeOfSchema=(schema)=>{let node=schema.anyOf?.find((branch)=>branch.type!=="null")??schema,{type,format}=node;if(type==="number"||type==="integer"||type==="bigint")return"number";if(type==="boolean")return"boolean";if(format==="date"||format==="date-time")return"date";if(format==="uuid")return"uuid";return"string"},normalizeFilter=(spec)=>Array.isArray(spec)?{operators:spec}:spec,Query;((Query)=>{Query.define=(model,spec)=>{let properties=model.selectSchema.properties??{},types={};for(let[name,schema]of Object.entries(properties))types[name]=typeOfSchema(schema);return{...spec,types}};let typeOf=(spec,field,column)=>{let filter=spec.filters?.[field];return(filter&&normalizeFilter(filter).type)??spec.types?.[column]??spec.types?.[field]??"string"},columnOf=(spec,field)=>{let filter=spec.filters?.[field];return(filter&&normalizeFilter(filter).column)??spec.columns?.[field]??field};Query.schema=(spec)=>{let properties={};for(let[field,raw]of Object.entries(spec.filters??{})){let filter=normalizeFilter(raw);properties[`filter[${field}]`]=t3.Optional(t3.String({description:`Filters ${field} (${filter.operators[0]}).`}));for(let operator of filter.operators)properties[`filter[${field}][${operator}]`]=t3.Optional(t3.String({description:`Filters ${field} with ${operator}.`}))}if(spec.sort?.length)properties.sort=t3.Optional(t3.String({description:`Comma-separated sort fields, "-" for descending: ${spec.sort.join(", ")}.`}));return properties.cursor=t3.Optional(t3.String({description:"The cursor of the next page."})),properties.limit=t3.Optional(t3.String({description:`Rows per page, up to ${spec.limit?.max??DEFAULT_MAX_LIMIT}.`})),properties.fields=t3.Optional(t3.String({description:"Comma-separated fields to return."})),t3.Object(properties,{additionalProperties:!0})},Query.parse=(spec,query={})=>{let errors=[],fail=(parameter,message,code)=>errors.push({pointer:`/query/${parameter.replaceAll("/","~1")}`,message,code}),filters=[];for(let[key,raw]of Object.entries(query)){let match=FILTER_KEY.exec(key);if(!match)continue;let[,field,named]=match,filterSpec=spec.filters?.[field];if(!filterSpec){fail(key,`cannot filter by "${field}"`,"filter");continue}let{operators}=normalizeFilter(filterSpec),operator=named??operators[0];if(!operators.includes(operator)){fail(key,`"${operator}" is not allowed on "${field}"`,"operator");continue}let column=columnOf(spec,field),type=typeOf(spec,field,column),text=String(Array.isArray(raw)?raw.at(-1):raw);if(operator==="isNull"){let read=readValue("boolean",text);if("error"in read)fail(key,read.error,"type");else filters.push({field,column,operator,value:read.value});continue}if(operator==="in"){let values=[];for(let part of text.split(",")){let read=readValue(type,part.trim());if("error"in read)fail(key,`each value ${read.error}`,"type");else values.push(read.value)}if(values.length>0&&values.length===text.split(",").length)filters.push({field,column,operator,value:values});continue}let read=readValue(operator==="contains"||operator==="startsWith"?"string":type,text);if("error"in read)fail(key,read.error,"type");else filters.push({field,column,operator,value:read.value})}let key=spec.key??"id",sort=[],rawSort=typeof query.sort==="string"&&query.sort!==""?query.sort:spec.defaultSort;for(let part of(rawSort??"").split(",").map((item)=>item.trim()).filter(Boolean)){let direction=part.startsWith("-")?"desc":"asc",field=part.replace(/^[-+]/,"");if(!spec.sort?.includes(field)){fail("sort",`cannot sort by "${field}"`,"sort");continue}sort.push({field,column:columnOf(spec,field),direction})}if(!sort.some((item)=>item.column===key))sort.push({field:key,column:key,direction:sort.at(-1)?.direction??"asc"});let max=spec.limit?.max??DEFAULT_MAX_LIMIT,limit=spec.limit?.default??DEFAULT_LIMIT;if(query.limit!==void 0&&query.limit!==""){let value=Number(query.limit);if(!Number.isInteger(value)||value<1||value>max)fail("limit",`must be a whole number from 1 to ${max}`,"limit");else limit=value}let after;if(typeof query.cursor==="string"&&query.cursor!==""){let values=decodeCursor(query.cursor,sort.length)?.map((value,index)=>{if(value===null)return{value:null};if(!["string","number","boolean"].includes(typeof value))return{error:"bad"};let{field,column}=sort[index];return readValue(typeOf(spec,field,column),String(value))});if(!values||values.some((read)=>("error"in read)))fail("cursor","is not a cursor of this listing","cursor");else after=values.map((read)=>read.value)}if(errors.length>0)throw new BadRequestError("The query is invalid.",{errors});return{filters,sort,after,limit}},Query.cursorAfter=(query,row)=>toBase64Url(JSON.stringify(query.sort.map(({column})=>{let value=row[column];return value instanceof Date?value.toISOString():value})));let decodeCursor=(cursor,length)=>{try{let values=JSON.parse(fromBase64Url(cursor));return Array.isArray(values)&&values.length===length?values:void 0}catch{return}};Query.page=(query,rows)=>{let data=rows.slice(0,query.limit),more=rows.length>query.limit;return{data,nextCursor:more?Query.cursorAfter(query,data.at(-1)):null}},Query.pageSchema=(item)=>t3.Object({data:t3.Array(item),nextCursor:t3.Nullable(t3.String())})})(Query||={});import{Module}from"@elysiumjs/core";import{KeyvCacheableMemory}from"cacheable";import{EventEmitter}from"events";import{Lifecycle,Service as Service5}from"@elysiumjs/core";import{Redis}from"@elysiumjs/redis";class KeyvRedis extends EventEmitter{#client;#namespace;#keyPrefixSeparator="::";#clearBatchSize=1000;#useUnlink=!0;#noNamespaceAffectsAll=!1;#connection;constructor(props){super();this.#connection=props.connection,this.#namespace=props.namespace,this.#keyPrefixSeparator=props.keyPrefixSeparator??"::",this.#clearBatchSize=props.clearBatchSize??1000,this.#useUnlink=props.useUnlink??!0,this.#noNamespaceAffectsAll=props.noNamespaceAffectsAll??!1,this.on("error",(error)=>{Lifecycle.emit("elysium:error",error)})}async getClient(){return this.#client??=await Service5.resolve(Redis.getConnectionName(this.#connection)),this.#client}get opts(){return{namespace:this.#namespace,keyPrefixSeparator:this.#keyPrefixSeparator,clearBatchSize:this.#clearBatchSize,noNamespaceAffectsAll:this.#noNamespaceAffectsAll,dialect:"redis",url:this.#connection}}get namespace(){return this.#namespace}set namespace(value){this.#namespace=value}async get(key){let client=await this.getClient();key=this.createKeyPrefix(key,this.#namespace);let value=await client.get(key);return value===null?void 0:value}async set(key,value,ttl){let client=await this.getClient();if(key=this.createKeyPrefix(key,this.#namespace),ttl)await client.send("SET",[key,value,"PX",String(ttl)]);else await client.set(key,value)}async setMany(values){let client=await this.getClient(),multi=[];for(let{key,value,ttl}of values){let prefixedKey=this.createKeyPrefix(key,this.#namespace);if(ttl)multi.push(client.send("SET",[prefixedKey,value,"PX",String(ttl)]));else multi.push(client.set(prefixedKey,value))}await Promise.all(multi)}async delete(key){let client=await this.getClient();return key=this.createKeyPrefix(key,this.#namespace),await this.#remove(client,[key])>0}async clear(){try{let client=await this.getClient();if(!this.#namespace&&this.#noNamespaceAffectsAll){await client.send("FLUSHDB",[]);return}let cursor="0",batchSize=this.#clearBatchSize,match=this.#namespace?`${this.#namespace}${this.#keyPrefixSeparator}*`:"*";do{let result=await client.send("SCAN",[cursor,"MATCH",match,"COUNT",batchSize.toString(),"TYPE","string"]),[newCursor,keys]=result;if(cursor=newCursor.toString(),keys.length===0)continue;if(!this.#namespace)keys=keys.filter((key)=>!key.includes(this.#keyPrefixSeparator));if(keys.length>0)await this.#remove(client,keys)}while(cursor!=="0")}catch(error){this.emit("error",error)}}async has(key){let client=await this.getClient();return key=this.createKeyPrefix(key,this.#namespace),Number(await client.send("EXISTS",[key]))>0}async hasMany(keys){let client=await this.getClient(),multi=[];for(let key of keys){let prefixedKey=this.createKeyPrefix(key,this.#namespace);multi.push(client.send("EXISTS",[prefixedKey]).then((count)=>Number(count)>0))}return Promise.all(multi)}async getMany(keys){let client=await this.getClient();if(keys.length===0)return[];return keys=keys.map((key)=>this.createKeyPrefix(key,this.#namespace)),await client.send("MGET",keys)}async disconnect(){this.#client=void 0}async deleteMany(keys){if(keys.length===0)return!1;let client=await this.getClient(),prefixedKeys=keys.map((key)=>this.createKeyPrefix(key,this.#namespace));return await this.#remove(client,prefixedKeys)>0}#remove(client,keys){return this.#useUnlink?client.send("UNLINK",keys):client.del(...keys)}async*iterator(namespace){let client=await this.getClient(),match=namespace?`${namespace}${this.#keyPrefixSeparator}*`:"*",cursor="0";do{let result=await client.send("SCAN",[cursor,"MATCH",match,"TYPE","string"]),[newCursor,keys]=result;if(cursor=newCursor.toString(),!namespace&&!this.#noNamespaceAffectsAll)keys=keys.filter((key)=>!key.includes(this.#keyPrefixSeparator));if(keys.length>0){let values=await client.send("MGET",keys);for(let i of keys.keys()){let key=this.getKeyWithoutPrefix(keys[i],namespace),value=values[i];yield[key,value]}}}while(cursor!=="0")}createKeyPrefix(key,namespace){return namespace?`${namespace}${this.#keyPrefixSeparator}${key}`:key}getKeyWithoutPrefix(key,namespace){return namespace?key.replace(`${namespace}${this.#keyPrefixSeparator}`,""):key}}class MnemosyneModule extends Module.configurable({defaults:{cache:{redis:{connection:"cache"},memory:{ttl:60000,lruSize:5000}}}}){}MnemosyneModule=__legacyDecorateClassTS([Module.register({services:(config)=>{let services=[],{redis,memory,stores}=config.cache;if(redis)services.push({name:REDIS_CACHE_SERVICE,global:!0,factory:()=>makeCacheInterface(()=>new KeyvRedis({connection:redis.connection}))});if(memory)services.push({name:MEMORY_CACHE_SERVICE,global:!0,factory:()=>makeCacheInterface(()=>new KeyvCacheableMemory({ttl:memory.ttl,lruSize:memory.lruSize}))});for(let[name,createStore]of Object.entries(stores??{}))services.push({name:cacheStoreService(name),global:!0,factory:()=>makeCacheInterface(createStore)});return services}})],MnemosyneModule);var resolveStore=(store)=>store==="memory"?Cache.memory:store==="redis"?Cache.redis:Cache.store(store),defaultKey=(ctx)=>{let url=new URL(ctx.request.url);return`http:${typeof ctx.tenant==="string"?ctx.tenant:"public"}:${ctx.request.method}:${url.pathname}${url.search}`};class CacheInterceptor{static with(options){let{ttl,store="memory",key=defaultKey}=options;return class{async intercept(ctx,next){let method=ctx.request.method;if(method!=="GET"&&method!=="HEAD")return next();let cache=resolveStore(store),cacheKey=key(ctx),cached=await cache.get(cacheKey);if(cached!==void 0)return ctx.set.headers["x-cache"]="hit",cached.value;let value=await next();if(ctx.set.headers["x-cache"]="miss",!(value instanceof Response))await cache.set(cacheKey,{value},ttl);return value}}}}export{AbstractDatabase,AbstractModel,AbstractRepository,Cache,CacheInterceptor,DATABASE_TRANSACTION_SERVICE,KeyvRedis,MEMORY_CACHE_SERVICE,MnemosyneModule,ModelResource,Query,REDIS_CACHE_SERVICE,SimpleTenantMiddleware,StrictTenantMiddleware,TENANCY_CONFIG_SERVICE,TENANCY_STRATEGY_SERVICE,TENANT_ID_PATTERN,TenantMiddleware,Transactional,UnitOfWork,cacheStoreService,createDatabaseCacheStorage,createSchemaFromModel,getCurrentTenant,getTenancyConfig,getTenancyStrategy,isValidTenantId,withTenant,withUnitOfWork};

package/dist/interfaces.d.ts

@@ -1,4 +1,4 @@
-import type { TSchema } from 'elysia';
+import type { TSchema } from '@elysiumjs/core';
 /**
  * Contract for ORM drivers.
  *
@@ -13,9 +13,10 @@ export interface DatabaseDriver<TConnection = unknown, TConnectionConfig = unkno
     /**
      * Creates a new database connection from the given configuration.
      * @param config The connection configuration.
+     * @param name The name of the connection, when the driver scopes resources by connection.
      * @returns A new database connection.
      */
-    createConnection(config: TConnectionConfig): TConnection;
+    createConnection(config: TConnectionConfig, name?: string): TConnection;
     /**
      * Executes a callback within a database transaction.
      * @param connection The connection to use for the transaction.
@@ -165,7 +166,9 @@ export interface DatabaseCacheConfig {
      */
     enabled?: boolean;
     /**
-     * The default TTL for cached data, in seconds.
+     * The default TTL for cached data, in seconds. Drivers apply it to every cached result that
+     * does not set its own expiry.
+     * @default 60
      */
     ttl?: number;
     /**
@@ -178,6 +181,13 @@ export interface DatabaseCacheConfig {
      * The storage engine to use for the cache.
      */
     storage?: 'redis' | 'memory';
+    /**
+     * A prefix for every cache key, before the connection name. Set it when several applications
+     * or environments share one cache store, so that connections with the same name but different
+     * databases do not share results.
+     * @default ''
+     */
+    prefix?: string;
 }
 /**
  * Database primary column type.
@@ -236,9 +246,9 @@ export interface RepositoryInterface<TSelect, TInsert, TUpdate, TId extends IdTy
      * Updates a record in the database.
      * @param id The id of the record to update.
      * @param data The data to update.
-     * @returns The updated record.
+     * @returns The updated record, or `null` if no record has that id.
      */
-    update(id: TId, data: TUpdate): Promise<TSelect>;
+    update(id: TId, data: TUpdate): Promise<TSelect | null>;
     /**
      * Updates all the records in the database.
      * @param data The data to update.
@@ -248,9 +258,9 @@ export interface RepositoryInterface<TSelect, TInsert, TUpdate, TId extends IdTy
     /**
      * Deletes a record from the database.
      * @param id The ID of the record to delete.
-     * @returns The deleted record.
+     * @returns The deleted record, or `null` if no record has that id.
      */
-    delete(id: TId): Promise<TSelect>;
+    delete(id: TId): Promise<TSelect | null>;
     /**
      * Deletes all the records from the database.
      * @returns All the deleted records.

package/dist/keyv-redis.d.ts

@@ -1,3 +1,4 @@
+import type { RedisConnection } from '@elysiumjs/redis';
 import type { KeyvStoreAdapter } from 'cacheable';
 import type { KeyvEntry, StoredData } from 'keyv';
 import { EventEmitter } from 'node:events';
@@ -25,7 +26,7 @@ export declare class KeyvRedis extends EventEmitter implements KeyvStoreAdapter
          */
         clearBatchSize?: number;
         /**
-         * Enable Unlink instead of using Del for clearing keys. This is more performant but may not be supported by all Redis versions.
+         * Use UNLINK instead of DEL to delete keys. UNLINK frees memory in the background (Redis 4+).
          */
         useUnlink?: boolean;
         /**
@@ -39,7 +40,7 @@ export declare class KeyvRedis extends EventEmitter implements KeyvStoreAdapter
      * Resolves the Redis client on first use. The async path is always safe, even when the
      * Redis module has not been initialised yet (lazy boot).
      */
-    protected getClient(): Promise<Bun.RedisClient>;
+    protected getClient(): Promise<RedisConnection>;
     /**
      * Get the options for the adapter.
      */

package/dist/mnemosyne.module.d.ts

@@ -1,3 +1,4 @@
+import type { KeyvStoreAdapter } from 'keyv';
 /**
  * Configuration of the {@link MnemosyneModule}.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -16,13 +17,18 @@ export type MnemosyneModuleConfig = {
             /** The maximum number of entries kept. */
             lruSize: number;
         } | false;
+        /**
+         * Other caches, each over the Keyv stores its function creates, read with
+         * `Cache.store(name)`. The function is called once per cache namespace.
+         */
+        stores?: Record<string, () => KeyvStoreAdapter>;
     };
 };
 declare const MnemosyneModule_base: (abstract new () => {
     readonly config: MnemosyneModuleConfig;
     onInit(): Promise<void> | void;
     onDestroy(): Promise<void> | void;
-    onServe(_app: import("elysia").default<any>): Promise<void> | void;
+    onServe(_app: import("elysia").Elysia<any>): Promise<void> | void;
 }) & {
     readonly config: string;
     with(config: Partial<MnemosyneModuleConfig> | (() => Partial<MnemosyneModuleConfig> | Promise<Partial<MnemosyneModuleConfig>>)): import("@elysiumjs/core").ConfiguredModule<MnemosyneModuleConfig>;
@@ -34,8 +40,8 @@ declare const MnemosyneModule_base: (abstract new () => {
     }): any;
 };
 /**
- * Provides the caches as the global services `mnemosyne.cache.redis` and
- * `mnemosyne.cache.memory`. Tenancy config and strategy, and database connections, are
+ * Provides the caches as the global services `mnemosyne.cache.redis`,
+ * `mnemosyne.cache.memory` and `mnemosyne.cache.store.<name>`. Tenancy config and strategy, and database connections, are
  * registered by the database driver modules.
  * @author Axel Nana <axel.nana@workbud.com>
  */