@elysiumjs/mnemosyne 0.3.1 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,126 @@
 # @elysiumjs/mnemosyne
 
+## 0.5.0
+
+### Minor Changes
+
+- [#26](https://github.com/na2axl/elysiumjs/pull/26) [`4cd1ef2`](https://github.com/na2axl/elysiumjs/commit/4cd1ef217826164e69cd641ca99f74c6f5a7ebe7) Thanks [@na2axl](https://github.com/na2axl)! - Type the query string of the query DSL. `Query.define` keeps the names of the filters, their operators and the sortable fields, `Query.Params<typeof spec>` types the parameter that `@Http.query()` decorates (`filter[status]`, `filter[status][in]`, `sort`, `cursor`, `limit`, `fields`, each an optional string), and `Query.schema(spec)` returns a schema of that type. Because the generated routes read the parameter's type, clients get typed query keys. Core re-exports TypeBox's `TOptional` and `TString` types.
+
+### Patch Changes
+
+- Updated dependencies [[`4cd1ef2`](https://github.com/na2axl/elysiumjs/commit/4cd1ef217826164e69cd641ca99f74c6f5a7ebe7)]:
+  - @elysiumjs/core@0.11.1
+  - @elysiumjs/redis@0.1.0
+
+## 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

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>
@@ -131,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/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 QueryFilters, type QueryParamKeys, type QueryParams, type QuerySchemaProperties, 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=(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)}}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.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.#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),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){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.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.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,DATABASE_TRANSACTION_SERVICE,KeyvRedis,MEMORY_CACHE_SERVICE,MnemosyneModule,REDIS_CACHE_SERVICE,SimpleTenantMiddleware,StrictTenantMiddleware,TENANCY_CONFIG_SERVICE,TENANCY_STRATEGY_SERVICE,TENANT_ID_PATTERN,TenantMiddleware,createDatabaseCacheStorage,createSchemaFromModel,getCurrentTenant,getTenancyConfig,getTenancyStrategy,isValidTenantId,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)=>("operators"in spec)?spec:{operators: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.
  *

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';
@@ -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>
  */

package/dist/model.d.ts

@@ -8,7 +8,7 @@ import type { ColumnMetadata, ModelAdapter } from './interfaces';
  */
 export declare const createSchemaFromModel: (columns: ColumnMetadata[], { mode }?: {
     mode?: 'create' | 'update' | 'select';
-}) => import("@sinclair/typebox").TObject<{}>;
+}) => import("typebox").TObject<{}>;
 /**
  * Mixin used to create a new abstract model class.
  * @author Axel Nana <axel.nana@workbud.com>
@@ -49,15 +49,15 @@ export declare const AbstractModel: <TTable, TColumns extends Record<string, unk
     /**
      * The validation schema for creating records.
      */
-    readonly insertSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly insertSchema: import("typebox").TObject<{}>;
     /**
      * The validation schema for updating records.
      */
-    readonly updateSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly updateSchema: import("typebox").TObject<{}>;
     /**
      * The validation schema for selecting records.
      */
-    readonly selectSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly selectSchema: import("typebox").TObject<{}>;
     /**
      * Whether the model supports tenancy.
      *

package/dist/query.d.ts

@@ -0,0 +1,199 @@
+import type { TObject, TOptional, TSchema, TString } from '@elysiumjs/core';
+import type { ModelClass } from './interfaces';
+/**
+ * A filter operator of the query DSL.
+ *
+ * - `eq`, `ne`, `gt`, `gte`, `lt`, `lte`: comparisons.
+ * - `in`: one of a comma-separated list.
+ * - `contains`, `startsWith`: case-insensitive text matches.
+ * - `isNull`: `true` or `false`.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type FilterOperator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains' | 'startsWith' | 'isNull';
+/**
+ * The type of a filtered or sorted field, which decides how its query values are read.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryFieldType = 'string' | 'number' | 'boolean' | 'date' | 'uuid';
+/**
+ * A filterable field.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryFilterSpec<TOperator extends FilterOperator = FilterOperator> = {
+    /** The operators the field accepts. The first one is used by `filter[field]=value`. */
+    operators: readonly TOperator[];
+    /** The type of the values. Read from the model by {@link Query.define}; `string` otherwise. */
+    type?: QueryFieldType;
+    /** The model property behind the field, when it has another name. */
+    column?: string;
+};
+/**
+ * The filterable fields of a spec, each with its operators or its {@link QueryFilterSpec}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryFilters = Record<string, QueryFilterSpec | readonly FilterOperator[]>;
+/**
+ * What clients may filter and sort by, and how many rows a page holds.
+ *
+ * The type parameters keep the names of the filters and the sortable fields, so that
+ * {@link Query.Params} and {@link Query.schema} can type the query string.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QuerySpec<TFilters extends QueryFilters = QueryFilters, TSort extends string = string> = {
+    /** The filterable fields, with their operators. */
+    filters?: TFilters;
+    /** The sortable fields. Sortable columns should not be nullable, for cursor pagination. */
+    sort?: readonly TSort[];
+    /** The sort used when the query sets none, such as `-createdAt`. */
+    defaultSort?: string;
+    /** The page size: the default, and the largest a client may ask for. */
+    limit?: {
+        default?: number;
+        max?: number;
+    };
+    /** The model property that identifies rows, the tiebreaker of every sort. Defaults to `id`. */
+    key?: string;
+    /** The types of the model's properties, set by {@link Query.define}. */
+    types?: Record<string, QueryFieldType>;
+    /** The property names of the model, for sortable fields that map to another column. */
+    columns?: Record<string, string>;
+};
+/**
+ * One filter of a parsed query.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedFilter = {
+    field: string;
+    column: string;
+    operator: FilterOperator;
+    value: unknown;
+};
+/**
+ * One sort key of a parsed query.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedSort = {
+    field: string;
+    column: string;
+    direction: 'asc' | 'desc';
+};
+/**
+ * A query string, validated against a {@link QuerySpec}, that repositories run.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type ParsedQuery = {
+    filters: ParsedFilter[];
+    /** The sort keys, ending with the row key as the tiebreaker. */
+    sort: ParsedSort[];
+    /** The values of the sort keys of the last row of the previous page. */
+    after?: unknown[];
+    limit: number;
+};
+/**
+ * A page of rows from cursor pagination.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type CursorPage<T> = {
+    data: T[];
+    /** The cursor of the next page, or `null` on the last page. */
+    nextCursor: string | null;
+};
+/** The operators of one filter of a spec. */
+type OperatorsOf<TFilter> = TFilter extends readonly (infer TOperator)[] ? TOperator : TFilter extends {
+    operators: readonly (infer TOperator)[];
+} ? TOperator : never;
+/** The filter keys of a spec: `filter[field]` and `filter[field][operator]`. */
+type FilterKeysOf<TFilters> = {
+    [K in keyof TFilters & string]: `filter[${K}]` | `filter[${K}][${OperatorsOf<TFilters[K]> & string}]`;
+}[keyof TFilters & string];
+/**
+ * The parameter names of the query string of a spec.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryParamKeys<TSpec> = TSpec extends QuerySpec<infer TFilters, infer TSort> ? FilterKeysOf<TFilters> | ([TSort] extends [never] ? never : 'sort') | 'cursor' | 'limit' | 'fields' : never;
+/**
+ * The query string of a spec, as Elysia parses it: every parameter is an optional string.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QueryParams<TSpec> = {
+    [K in QueryParamKeys<TSpec>]?: string;
+};
+/**
+ * The properties of the query schema of a spec.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type QuerySchemaProperties<TSpec> = {
+    [K in QueryParamKeys<TSpec>]: TOptional<TString>;
+};
+export declare namespace Query {
+    /**
+     * Builds a query spec for a model: the types of the filtered and sorted fields are read from
+     * the model's select schema.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param model The model class.
+     * @param spec The filters, sorts and page size.
+     * @example
+     * ```ts
+     * const PostQuery = Query.define(Post, {
+     *   filters: { status: ['eq', 'in'], createdAt: ['gte', 'lte'], title: ['contains'] },
+     *   sort: ['createdAt', 'title'],
+     *   defaultSort: '-createdAt'
+     * });
+     * ```
+     */
+    const define: <TModel extends ModelClass, const TFilters extends QueryFilters = {}, const TSort extends string = never>(model: TModel, spec: Omit<QuerySpec<TFilters, TSort>, 'types'>) => QuerySpec<TFilters, TSort>;
+    /**
+     * The query string of a spec, for the parameter that `@Http.query()` decorates.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @example
+     * ```ts
+     * @Http.get('/posts')
+     * list(@Http.query(Query.schema(PostQuery)) query: Query.Params<typeof PostQuery>) {
+     *   return this.posts.list(Query.parse(PostQuery, query));
+     * }
+     * ```
+     */
+    type Params<TSpec> = QueryParams<TSpec>;
+    /**
+     * The query schema of a spec, for `@Http.query()`: it documents the filters, `sort`, `cursor`,
+     * `limit` and `fields` parameters in OpenAPI. Its static type is {@link Query.Params}, and other
+     * parameters are let through.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param spec The query spec.
+     */
+    const schema: <TSpec extends QuerySpec>(spec: TSpec) => TObject<QuerySchemaProperties<TSpec>>;
+    /**
+     * Validates a query string against a spec.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param spec The query spec.
+     * @param query The query, as Elysia parses it (`filter[status]` keys stay flat).
+     * @returns The parsed query, for a repository's `list()`.
+     * @throws {BadRequestError} A 400 problem whose `errors` name every invalid parameter.
+     */
+    const parse: (spec: QuerySpec, query?: Record<string, unknown>) => ParsedQuery;
+    /**
+     * Builds the cursor that points after a row.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param query The parsed query, for its sort keys.
+     * @param row The last row of a page.
+     */
+    const cursorAfter: (query: ParsedQuery, row: Record<string, unknown>) => string;
+    /**
+     * Builds a page from rows fetched with one more row than the limit: the extra row only tells
+     * that a next page exists.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param query The parsed query.
+     * @param rows Up to `limit + 1` rows.
+     */
+    const page: <T extends Record<string, unknown>>(query: ParsedQuery, rows: T[]) => CursorPage<T>;
+    /**
+     * The response schema of a page of resources.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param item The schema of one row.
+     */
+    const pageSchema: <S extends TSchema>(item: S) => TObject<{
+        data: import("typebox").TArray<S>;
+        nextCursor: import("typebox").TUnion<[TString, import("typebox").TNull]>;
+    }>;
+}
+export {};

package/dist/resource.d.ts

@@ -0,0 +1,35 @@
+import type { TObject, TSchema } from '@elysiumjs/core';
+import type { ModelClass } from './interfaces';
+/**
+ * Options of {@link ModelResource}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @template TKey The column names of the model.
+ */
+export type ModelResourceOptions<TKey extends string = string> = {
+    /** Columns kept out of responses and of the OpenAPI document, such as `passwordHash`. */
+    hidden?: TKey[];
+    /** Only these columns are exposed. */
+    pick?: TKey[];
+    /** These columns are left out of the schema entirely. */
+    omit?: TKey[];
+    /** Extra fields the resource exposes, such as computed or related values. */
+    extend?: Record<string, TSchema>;
+};
+/**
+ * The response schema of a model: its select schema, with hidden, picked and omitted columns
+ * applied. Use it as a route's `response`: the handler can return model rows as they are, and
+ * the response holds only the exposed fields, with dates as ISO strings.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param model The model class.
+ * @param options The columns to hide, pick or omit, and extra fields.
+ * @example
+ * ```ts
+ * const UserResource = ModelResource(User, { hidden: ['passwordHash'] });
+ *
+ * @Http.get('/:id', { response: UserResource })
+ * public show(@Http.param('id') id: string) {
+ *   return this.users.find(id);
+ * }
+ * ```
+ */
+export declare const ModelResource: <TModel extends ModelClass>(model: TModel, options?: ModelResourceOptions<Extract<keyof TModel['$inferSelect'], string>>) => TObject;

package/dist/unit-of-work.d.ts

@@ -0,0 +1,68 @@
+/** A callback run once the unit of work has committed or rolled back. */
+type Hook = () => unknown | Promise<unknown>;
+/** Runs a callback in a database transaction, joining the one open on the connection. */
+export type TransactionRunner = <T>(callback: () => Promise<T>, connection?: string) => Promise<T>;
+/**
+ * Wraps a driver's transaction function into the runner of units of work: the outermost run
+ * collects the `afterCommit` and `afterRollback` hooks of everything it calls, and runs them once
+ * it has committed or rolled back. Inner runs join it. Driver modules register the result as the
+ * `db.transaction` service, which `transactional` routes and {@link UnitOfWork.run} use.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param transaction Runs a callback in a transaction, joining an open one.
+ */
+export declare const withUnitOfWork: (transaction: TransactionRunner) => TransactionRunner;
+export declare namespace UnitOfWork {
+    /**
+     * Runs a callback in a unit of work: one transaction on the connection that every repository
+     * call made from the callback uses. When a unit of work is already open, the callback joins
+     * it, so services compose without knowing which of them opened it.
+     *
+     * A callback that returns a `DomainError` rolls the work back, like one that throws, and the
+     * error is returned. A joined callback hands it to the one that opened the unit of work, which
+     * rolls back when it returns it too.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param callback The work to run.
+     * @param options The connection of the transaction. Defaults to `default`.
+     * @throws {Error} When no database module provides the `db.transaction` service.
+     */
+    const run: <T>(callback: () => Promise<T>, options?: {
+        connection?: string;
+    }) => Promise<T>;
+    /** Whether a unit of work is open in the current async context. */
+    const active: () => boolean;
+    /**
+     * Runs a callback once the current unit of work has committed, such as publishing the events
+     * of an outbox. Outside a unit of work, it runs right away. A failing hook is logged.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param hook The callback.
+     */
+    const afterCommit: (hook: Hook) => Promise<void>;
+    /**
+     * Runs a callback if the current unit of work rolls back, such as deleting an uploaded file.
+     * Outside a unit of work, it never runs.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param hook The callback.
+     */
+    const afterRollback: (hook: Hook) => void;
+}
+/**
+ * Runs a method in a unit of work (see {@link UnitOfWork.run}): a new transaction, or the one
+ * already open. A method that returns a `DomainError` rolls back.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param options The connection of the transaction. Defaults to `default`.
+ * @example
+ * ```ts
+ * @Service.register()
+ * class TransferService {
+ *   @Transactional()
+ *   public async transfer(from: string, to: string, amount: number) {
+ *     await this.accounts.debit(from, amount);
+ *     await this.accounts.credit(to, amount);
+ *   }
+ * }
+ * ```
+ */
+export declare const Transactional: (options?: {
+    connection?: string;
+}) => MethodDecorator;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@elysiumjs/mnemosyne",
-	"version": "0.3.1",
+	"version": "0.5.0",
 	"license": "Apache-2.0",
 	"description": "Database and caching for Elysium.js applications",
 	"private": false,
@@ -40,10 +40,12 @@
 	],
 	"sideEffects": false,
 	"peerDependencies": {
-		"@elysiumjs/core": "^0.10.0"
+		"@elysiumjs/core": "^0.11.1",
+		"@elysiumjs/redis": "^0.1.0"
 	},
 	"devDependencies": {
-		"@elysiumjs/core": "0.10.0"
+		"@elysiumjs/core": "0.11.1",
+		"@elysiumjs/redis": "0.1.0"
 	},
 	"dependencies": {
 		"cache-manager": "^7.2.9",