@elysiumjs/mnemosyne-drizzle 0.1.4 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,100 @@
+# @elysiumjs/mnemosyne-drizzle
+
+## 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
+  - @elysiumjs/mnemosyne@0.3.1
+
+## 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
+
+- [`ea419db`](https://github.com/na2axl/elysiumjs/commit/ea419db) Thanks [@na2axl](https://github.com/na2axl)! - `DrizzleModel()` accepts tables made with `pgTable()` again. Under TypeScript 7 it rejected every concrete table, so models and repositories over them did not typecheck.
+- [`3987671`](https://github.com/na2axl/elysiumjs/commit/3987671) Thanks [@na2axl](https://github.com/na2axl)! - The package only contains its build output, README and changelog. It no longer ships sources, tests or local tool state.
+- Updated dependencies [[`5fef4a7`](https://github.com/na2axl/elysiumjs/commit/5fef4a7199f502fc4fe035299e7670739459a108)]:
+  - @elysiumjs/core@0.9.0
+  - @elysiumjs/mnemosyne@0.3.0
+
+## 0.2.0
+
+### Minor Changes
+
+- [`8ac91ab`](https://github.com/na2axl/elysiumjs/commit/8ac91ab676b1119b4eecf0ddb3fd0a3e84017cac) Thanks [@na2axl](https://github.com/na2axl)! - Upgrade dependencies to their latest major versions: wampy 8, zod 4, commander 15, @casl/ability 7, OpenTelemetry SDK 2 (sdk-node 0.300, resources 3), @sentry/bun 11. Generated projects now use TypeScript 7.
+
+  Breaking in `@elysiumjs/mnemosyne-drizzle`: it now requires drizzle-orm 1.0 (release candidate) and generated projects use drizzle-kit 1.0. `ColumnsWithTable` is no longer re-exported. `migration:generate` writes 1.0 migration folders (`<timestamp>_<name>/migration.sql`), and `migration:run` tracks those by folder name while still running flat `*.sql` files. Existing projects can upgrade their migrations folder with `drizzle-kit up`: `migration:run` recognises the moved migrations as already applied and renames their records. The `make:model` stub now generates a `pgTable` and a `DrizzleModel` built from it.
+
+  Breaking in `@elysiumjs/core`: the deprecated `@elysiajs/swagger` plugin is replaced by `@elysiajs/openapi`, and the app option `swagger` is renamed `openapi` (typed `ElysiaOpenAPIConfig | false`). Without a `path`, the docs now live at `/openapi` instead of `/swagger`. The UI options `scalarConfig` and `swaggerOptions` are now `scalar` and `swagger`. Elysia stays on 1.4 (now `^1.4.30`) until Elysia 2 and its OpenAPI plugin are stable.
+
+  Also in `@elysiumjs/core`: the WAMP `onChallenge` callback must return a string (or a promise of one); `null` is no longer accepted. `onError` now receives the error and `onReconnectSuccess` receives wampy's details object. `WampClient` is now wampy's own `Wampy` type. `onOpen` is called by Elysium once the connection is established, since wampy 8 no longer has that callback.
+
+- [`07236b3`](https://github.com/na2axl/elysiumjs/commit/07236b386c2506590d74e8753ce847c1e184b3ee) Thanks [@na2axl](https://github.com/na2axl)! - Introduce the module system. Modules are now the only way to register anything in an Elysium.js app. This is a breaking change with no compatibility layer.
+
+  Breaking changes:
+
+  - `@Module.register()` takes `imports`, `services`, `exports`, `controllers`, `commands`, `jobs`, `prefix` and `env`. Services are private to their module unless exported (or global). The `beforeRegister` and `afterRegister` hooks are replaced by `onInit`, `onServe` and `onDestroy`.
+  - Configurable modules are bound with `with()`, for example `HermesModule.with({ level: 'debug' })`. `with()` accepts an object or a function.
+  - Decorators only record metadata. Importing a file no longer registers commands, services or event wiring, and the side-effect imports of the packages are removed. List commands, jobs and services in the module that owns them.
+  - `@Application.register()` no longer takes `database`, `redis`, `wamp` or `'elysium:hermes'`/`'elysium:cerberus'` keys. Use `DrizzleModule`, `RedisModule`, `WampModule`, `HermesModule` and `CerberusModule`. Package plugins are replaced by modules: add `SentryModule` instead of the `plugin()` function. `plugins` still accepts plain Elysia plugin factories.
+  - Constructing an `Application` no longer runs it. Use `await App.start()`; `Application.testing()` boots a module graph for tests. The `styx` binary loads `src/app.ts` (or `index.ts`) and starts the exported application, so a project entry no longer needs to import commands.
+  - The job system of core (`Job`, `Worker`, `WorkerPool`, `commandWork`) is removed. `@elysiumjs/heracles` is the only job system: extend its `Job`, list jobs in a module's `jobs`, declare queues with `HeraclesModule.with({ queues })`, and dispatch with `Heracles.dispatch()`.
+  - `@elysiumjs/styx` ships `StyxModule`, active in development only. The `migration:generate` and `migration:run` commands move to `DrizzleModule` and are available in production.
+  - `@elysiumjs/mnemosyne` ships `MnemosyneModule` for its caches (`redis: false` or `memory: false` opts out). `DrizzleModule` imports it.
+  - New modules: `HephaestusModule`, `ArgusModule` (`serviceName` is required), `SentryModule` (needs a `dsn` or `SENTRY_DSN`) and `CerberusModule` (`getSubject` is required).
+  - Module and service code throws typed errors (for example `InvalidModuleConfigError`) instead of exiting the process. `Application.run()` prints them and exits; command `run()` methods may still exit, and package plugin factories are unchanged.
+  - `Application.register` merges subclass props over the parent's (own props, then own metadata, then parent, then defaults), and concatenates `modules` parent first. Previously defaults and parent values won, so `openapi` could not be enabled.
+  - `Heracles.dispatch` starts a stopped queue on first use, so producers no longer start queues. `Queue.start()` is idempotent.
+  - `create-elysium` generates apps that use modules, and adds Sentry and Hephaestus to the `modules` list.
+  - `@Event.on`/`@Event.once` method listeners on classes in a loaded module's `services` or `controllers` are wired by the kernel and run in their module's context. Jobs, commands and middlewares are not wired, and an instance listener on a class that is not a service throws `EventListenerNotSupportedError`. Listeners on classes not listed in a loaded module no longer fire.
+  - New typed errors: `CircularDependencyError` (services that depend on each other, in sync and async resolution), `DuplicateModuleNameError` (two different module classes sharing a name; module scopes and config tokens are name based) and `EventListenerNotSupportedError`.
+  - Lazy boot contract: a CLI command initialises only its own module and that module's imports. Sync helpers such as `Database.getConnection()` work when the owning module's `onInit` is synchronous; otherwise they throw `ServiceNotReadyError` naming the module. Use `await Service.resolve()` or set `static boot = true` on the command.
+
+### Patch Changes
+
+- Updated dependencies [[`8ac91ab`](https://github.com/na2axl/elysiumjs/commit/8ac91ab676b1119b4eecf0ddb3fd0a3e84017cac), [`3625883`](https://github.com/na2axl/elysiumjs/commit/3625883dba92f1596e7444ee52f9399d8e9b049f), [`07236b3`](https://github.com/na2axl/elysiumjs/commit/07236b386c2506590d74e8753ce847c1e184b3ee)]:
+  - @elysiumjs/core@0.8.0
+  - @elysiumjs/mnemosyne@0.2.0

package/README.md

@@ -0,0 +1,51 @@
+# @elysiumjs/mnemosyne-drizzle
+
+Drizzle ORM driver for `@elysiumjs/mnemosyne`.
+
+## Installation
+
+```bash
+bun add @elysiumjs/mnemosyne-drizzle
+```
+
+## Usage
+
+Add `DrizzleModule` to your application. It declares the connections as global services, registers the tenancy strategy and provides the `migration:generate` and `migration:run` commands.
+
+```ts
+import { Application } from '@elysiumjs/core';
+import { DrizzleModule } from '@elysiumjs/mnemosyne-drizzle';
+
+@Application.register({
+	modules: [
+		DrizzleModule.with({
+			default: 'main',
+			connections: {
+				main: { connection: process.env.DATABASE_URL! }
+			}
+		})
+	]
+})
+export class App extends Application {}
+```
+
+`with()` also accepts a function, which is called when the module is booted: `DrizzleModule.with(() => ({ ... }))`. Set `tenancy` to switch between schema (default) and RLS tenancy.
+
+Define models with the enhanced `pgTable`:
+
+```ts
+import { DrizzleModel, DrizzleRepository, pgTable } from '@elysiumjs/mnemosyne-drizzle';
+import { uuid, varchar } from 'drizzle-orm/pg-core';
+
+const users = pgTable('users', {
+	id: uuid().primaryKey().defaultRandom(),
+	name: varchar({ length: 255 }).notNull()
+});
+
+export class UserModel extends DrizzleModel(users, { supportTenancy: true }) {}
+export class UserRepository extends DrizzleRepository(UserModel) {}
+```
+
+## License
+
+This project is licensed under the Apache License, Version 2.0. See the [LICENSE](../../LICENSE) file for more info.

package/dist/cache.d.ts

@@ -0,0 +1,60 @@
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { Table } from 'drizzle-orm';
+import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
+/**
+ * Default time to live of cached query results, in seconds.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const DEFAULT_CACHE_TTL = 60;
+/**
+ * Drizzle query cache backed by the framework's cache storage.
+ *
+ * - Results are cached per connection and tenant: every key starts with the configured prefix
+ *   (if any) and the connection name, result keys include the current tenant (or `public`), and
+ *   tags are invalidated for the current tenant. Each connection has its own transaction scope.
+ * - Invalidation works across application instances sharing the cache store: each table has a
+ *   version token in the store, every result records the versions it was read at, and a mutation
+ *   replaces the versions of the tables it touches. Table versions are shared by all tenants, as
+ *   a mutation made for one tenant can change rows other tenants read (shared tables, RLS
+ *   bypass). Every key is written with a TTL.
+ * - A result is only stored when the table versions are still the ones its query started at, and
+ *   every concurrent miss of the key read the same versions: Drizzle does not pair a `put` with its
+ *   `get`, so a result that may predate a mutation is never stored.
+ * - Inside a transaction, the cache is neither read nor written, since the transaction may read
+ *   its own uncommitted changes. Tables mutated in a transaction are invalidated once it commits,
+ *   and not at all when it rolls back.
+ *
+ * Remaining race: a mutation run outside a transaction is invalidated while its statement runs
+ * (Drizzle starts both together), so a read on another connection that completes between the
+ * invalidation and the commit can cache the previous rows until their TTL expires. Mutations run
+ * in a transaction (including RLS-scoped repository calls) are invalidated after the commit and
+ * are not affected.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class DrizzleDatabaseCache extends DrizzleCache {
+    #private;
+    /**
+     * @param cacheStrategy Whether queries are cached only when they opt in (`explicit`), or always.
+     * @param globalTtl The default time to live of cached results, in seconds.
+     * @param storageEngine The cache storage to use.
+     * @param connectionName The name of the connection, which prefixes every key.
+     * @param prefix A prefix for every key, before the connection name (empty for none).
+     */
+    constructor(cacheStrategy?: 'explicit' | 'all', globalTtl?: number, storageEngine?: 'redis' | 'memory', connectionName?: string, prefix?: string);
+    strategy(): 'explicit' | 'all';
+    /**
+     * Runs a transaction so that the cache is bypassed inside it, and the tables it mutates are
+     * invalidated once it commits.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param run Opens and runs the transaction.
+     * @returns The return value of `run`.
+     */
+    trackTransaction<T>(run: () => Promise<T>): Promise<T>;
+    get(key: string, tables?: string[], isTag?: boolean, autoInvalidate?: boolean): Promise<any[] | undefined>;
+    put(key: string, response: any, _tables: string[], isTag: boolean, config?: CacheConfig): Promise<void>;
+    onMutate(params: {
+        tags?: string | string[];
+        tables?: string | string[] | Table<any> | Table<any>[];
+    }): Promise<void>;
+}

package/dist/cache.js

@@ -0,0 +1 @@
+import{AsyncLocalStorage}from"node:async_hooks";import{Service,ServiceNotReadyError}from"@elysiumjs/core";import{createDatabaseCacheStorage,getCurrentTenant}from"@elysiumjs/mnemosyne";import{getTableName,is,Table}from"drizzle-orm";import{Cache as DrizzleCache}from"drizzle-orm/cache/core";export const DEFAULT_CACHE_TTL=60;const VERSION_TTL=24*60*60*1000;const MAX_PENDING_PER_KEY=16;const MAX_PENDING_KEYS=1000;const TABLE_SCHEMA=Symbol.for("drizzle:Schema");const tableKey=(table)=>{if(!is(table,Table))return table;const schema=table[TABLE_SCHEMA];return schema?`${schema}.${getTableName(table)}`:getTableName(table)};const toArray=(value)=>value===undefined?[]:Array.isArray(value)?value:[value];export class DrizzleDatabaseCache extends DrizzleCache{#storageEngine;#cache;#cacheStrategy;#globalTtl;#keyPrefix;#transactionScope=new AsyncLocalStorage;#pending=new Map;constructor(cacheStrategy="explicit",globalTtl=DEFAULT_CACHE_TTL,storageEngine="redis",connectionName="default",prefix=""){super();this.#cacheStrategy=cacheStrategy;this.#globalTtl=globalTtl;this.#storageEngine=storageEngine;this.#keyPrefix=prefix?`${prefix}:${connectionName}`:connectionName}async#storage(){if(this.#cache)return this.#cache;try{this.#cache=createDatabaseCacheStorage({storage:this.#storageEngine})}catch(error){if(!(error instanceof ServiceNotReadyError))throw error;await Service.resolve(error.service);this.#cache=createDatabaseCacheStorage({storage:this.#storageEngine})}return this.#cache}strategy(){return this.#cacheStrategy}async trackTransaction(run){const scope={tables:new Set,tags:new Set};const result=await this.#transactionScope.run(scope,run);await this.#invalidate([...scope.tables],[...scope.tags]);return result}async get(key,tables=[],isTag=false,autoInvalidate){if(this.#transactionScope.getStore())return;const storage=await this.#storage();const entryKey=this.#entryKey(key,isTag);const versionKeys=autoInvalidate===false?[]:tables.map((table)=>this.#versionKey(table));const[entry,...versions]=await storage.mget([entryKey,...versionKeys]);const missing=versionKeys.flatMap((versionKey,index)=>versions[index]===undefined?[{index,versionKey}]:[]);if(missing.length>0){const created=missing.map(({versionKey})=>({key:versionKey,value:crypto.randomUUID(),ttl:VERSION_TTL}));await storage.mset(created);for(const[i,{index}]of missing.entries())versions[index]=created[i].value}const signature=versions.join("|");const cached=entry;if(cached!==undefined&&cached.v===signature)return cached.r;this.#remember(entryKey,{signature,versionKeys,at:Date.now()});return}async put(key,response,_tables,isTag,config){if(this.#transactionScope.getStore())return;const entryKey=this.#entryKey(key,isTag);const pending=this.#live(entryKey);if(pending.length===0||new Set(pending.map((miss)=>miss.signature)).size>1){this.#pending.delete(entryKey);return}const[miss,...rest]=pending;if(rest.length>0)this.#pending.set(entryKey,rest);else this.#pending.delete(entryKey);const storage=await this.#storage();const current=await storage.mget(miss.versionKeys);if(current.join("|")!==miss.signature)return;const signature=miss.signature;const ttl=await this.#ttl(storage,entryKey,config);if(ttl<=0)return;await storage.set(entryKey,{v:signature,r:response},ttl)}async onMutate(params){const tables=toArray(params.tables).map(tableKey);const tags=toArray(params.tags);const scope=this.#transactionScope.getStore();if(scope){for(const table of tables)scope.tables.add(table);for(const tag of tags)scope.tags.add(tag);return}await this.#invalidate(tables,tags)}#remember(entryKey,miss){const pending=[...this.#live(entryKey),miss].slice(-MAX_PENDING_PER_KEY);this.#pending.delete(entryKey);this.#pending.set(entryKey,pending);while(this.#pending.size>MAX_PENDING_KEYS){this.#pending.delete(this.#pending.keys().next().value)}}#live(entryKey){const since=Date.now()-this.#globalTtl*1000;return(this.#pending.get(entryKey)??[]).filter((miss)=>miss.at>=since)}async#invalidate(tables,tags){if(tables.length===0&&tags.length===0)return;const storage=await this.#storage();if(tables.length>0){await storage.mset(tables.map((table)=>({key:this.#versionKey(table),value:crypto.randomUUID(),ttl:VERSION_TTL})))}if(tags.length>0){await storage.mdel(tags.map((tag)=>this.#entryKey(tag,true)))}}async#ttl(storage,entryKey,config){if(config?.px!==undefined)return config.px;if(config?.ex!==undefined)return config.ex*1000;if(config?.pxat!==undefined)return config.pxat-Date.now();if(config?.exat!==undefined)return config.exat*1000-Date.now();if(config?.keepTtl){const expiresAt=await storage.ttl(entryKey);if(expiresAt!==undefined&&expiresAt>Date.now())return expiresAt-Date.now()}return this.#globalTtl*1000}#entryKey(key,isTag){const kind=isTag?"tag":"query";return`${this.#keyPrefix}:${kind}:${getCurrentTenant()??"public"}:${key}`}#versionKey(table){return`${this.#keyPrefix}:version:${table}`}}

package/dist/commands/migration_generate.command.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@elysiumjs/core';
+/**
+ * Generates migration files.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class MigrationGenerateCommand extends Command {
+    static readonly command: string;
+    static readonly description: string;
+    private name?;
+    run(): Promise<void>;
+}

package/dist/commands/migration_generate.command.js

@@ -0,0 +1 @@
+var __decorate=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};var __metadata=function(k,v){if(typeof Reflect==="object"&&typeof Reflect.metadata==="function")return Reflect.metadata(k,v)};import{exists}from"node:fs/promises";import{Command,CommandArgumentType}from"@elysiumjs/core";import prompts from"prompts";import{stripPublicSchema}from"../migrations";import{getMigrationsPath,getProjectPath}from"./project";const listSqlFiles=async(migrationsPath)=>{if(!await exists(migrationsPath))return[];return Array.fromAsync(new Bun.Glob("**/*.sql").scan({cwd:migrationsPath,absolute:true,onlyFiles:true}))};let MigrationGenerateCommand=class MigrationGenerateCommand extends Command{static command="migration:generate";static description="Generates migration files.";name;async run(){if(!this.name){const answers=await prompts([{type:"text",name:"name",message:"Migration Name:",initial:"create_users_table",validate(value){if(value.length<1){return"Migration name cannot be empty"}return true}}],{onCancel:()=>{this.error("Operation cancelled.");process.exit(0)}});this.name=answers.name}const projectRoot=getProjectPath();const migrationsPath=getMigrationsPath();let schemaPath=`${projectRoot}/src/database/schemas`;if(await exists(`${projectRoot}/src/database/schema.ts`)){schemaPath=`${projectRoot}/src/database/schema.ts`}const existing=new Set(await listSqlFiles(migrationsPath));await Bun.$`bunx --bun drizzle-kit generate --dialect postgresql --schema ${schemaPath} --out ${migrationsPath} --name ${this.name}`;for(const path of await listSqlFiles(migrationsPath)){if(existing.has(path))continue;const file=Bun.file(path);await file.write(stripPublicSchema(await file.text()))}}};__decorate([Command.arg({description:"The name of the migration to create",type:CommandArgumentType.STRING}),__metadata("design:type",String)],MigrationGenerateCommand.prototype,"name",undefined);MigrationGenerateCommand=__decorate([Command.register()],MigrationGenerateCommand);export{MigrationGenerateCommand};

package/dist/commands/migration_run.command.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@elysiumjs/core';
+/**
+ * Execute migration files.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class MigrationRunCommand extends Command {
+    static readonly command: string;
+    static readonly description: string;
+    private tenant;
+    private connection;
+    private fresh;
+    private createSchema;
+    run(): Promise<void>;
+    /**
+     * Runs the pending migrations in one transaction.
+     * @param sql The client.
+     */
+    private migrate;
+    /**
+     * Checks that the tenant schema exists, or that it may be created: with `--create-schema`, or
+     * when the user agrees. Without a terminal to ask, a missing schema is an error.
+     * @param sql The client.
+     * @returns `false` if the schema must not be created.
+     */
+    private ensureSchemaChoice;
+}

package/dist/commands/migration_run.command.js

@@ -0,0 +1,10 @@
+var __decorate=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};var __metadata=function(k,v){if(typeof Reflect==="object"&&typeof Reflect.metadata==="function")return Reflect.metadata(k,v)};import{Command,CommandArgumentType}from"@elysiumjs/core";import{isValidTenantId}from"@elysiumjs/mnemosyne";import prompts from"prompts";import{Database}from"../database";import{getMigrationName,planMigrations}from"../migrations";import{getMigrationsPath}from"./project";let MigrationRunCommand=class MigrationRunCommand extends Command{static command="migration:run";static description="Runs pending migrations.";tenant="";connection="default";fresh=false;createSchema=false;async run(){if(!isValidTenantId(this.tenant)){this.error(`Invalid tenant ${this.bold(this.tenant)}: use 1 to 63 letters, digits, underscores or `+"dashes, not starting with pg_ and other than information_schema.");return process.exit(1)}if(!Database.connectionExists(this.connection)){this.error(`Connection ${this.bold(this.connection)} does not exist.`);return process.exit(1)}const sql=Database.getConnection(this.connection).$client;await sql.connect();try{if(!this.fresh&&!await this.ensureSchemaChoice(sql))return process.exit(1);await this.migrate(sql)}finally{await sql.close()}}async migrate(sql){await sql.begin(async(sql)=>{await sql`SELECT pg_advisory_xact_lock(hashtext(${`elysium_migrations:${this.tenant}`}))`;if(this.fresh){await sql`DROP SCHEMA IF EXISTS ${sql(this.tenant)} CASCADE;`}await sql`CREATE SCHEMA IF NOT EXISTS ${sql(this.tenant)};`;await sql`SET LOCAL search_path TO ${sql(this.tenant)}`;await sql`CREATE TABLE IF NOT EXISTS elysium_migrations (
+				id SERIAL PRIMARY KEY,
+				name TEXT NOT NULL,
+				batch INTEGER NOT NULL,
+				applied_at TIMESTAMP NOT NULL
+			);`;await sql`CREATE UNIQUE INDEX IF NOT EXISTS elysium_migrations_name_unique ON elysium_migrations (name);`;const rows=await sql`SELECT name, applied_at FROM elysium_migrations;`;const completedMigrations=rows.map((row)=>({name:row.name,appliedAt:row.applied_at}));const filesIt=new Bun.Glob("**/*.sql").scan({cwd:getMigrationsPath(),absolute:true,onlyFiles:true});const files=await Array.fromAsync(filesIt);const{pending:sqlFiles,renames}=planMigrations(files,completedMigrations);for(const{from,to}of renames){await sql`UPDATE elysium_migrations SET name = ${to} WHERE name = ${from};`;this.info(`Migration ${this.bold(from)} is now tracked as ${this.bold(to)}.`)}if(sqlFiles.length===0){this.success("No new migrations to apply.");return}const s=this.spinner(`Running migrations for tenant ${this.bold(this.tenant)}...`);const[{max}]=await sql`SELECT MAX(batch) + 1 AS max FROM elysium_migrations;`;const batch=max??0;for(const path of sqlFiles){await sql.file(path);const[{name}]=await sql`INSERT INTO elysium_migrations (name, batch, applied_at) VALUES (${getMigrationName(path)}, ${batch}, ${new Date}) RETURNING name;`;s.pause(`Migration ${this.bold(name)} applied successfully.`)}s.complete(`Migrations for tenant ${this.bold(this.tenant)} applied successfully.`)})}async ensureSchemaChoice(sql){const[{schema_exists}]=await sql`SELECT EXISTS (
+			SELECT schema_name
+			  FROM information_schema.schemata
+			 WHERE schema_name = ${this.tenant}
+		) AS schema_exists;`;if(schema_exists||this.createSchema)return true;if(!process.stdin.isTTY){this.error(`Schema ${this.bold(this.tenant)} does not exist. Run again with --create-schema to `+"create it.");return false}const answers=await prompts([{type:"confirm",name:"create",message:`Schema ${this.tenant} does not exist. Do you want to create it?`,initial:true}],{onCancel:()=>{this.error("Operation cancelled.");process.exit(0)}});if(!answers.create){this.error(`Schema ${this.bold(this.tenant)} creation cancelled.`);return false}return true}};__decorate([Command.arg({description:"The name of the tenant in which the migrations will be executed.",type:CommandArgumentType.STRING,required:true}),__metadata("design:type",String)],MigrationRunCommand.prototype,"tenant",undefined);__decorate([Command.arg({description:"The name of the connection to use.",type:CommandArgumentType.STRING,default:"default"}),__metadata("design:type",String)],MigrationRunCommand.prototype,"connection",undefined);__decorate([Command.arg({description:"Drop the entire schema before running the migrations.",type:CommandArgumentType.BOOLEAN,default:false}),__metadata("design:type",Boolean)],MigrationRunCommand.prototype,"fresh",undefined);__decorate([Command.arg({name:"create-schema",description:"Create the tenant schema without asking when it does not exist.",type:CommandArgumentType.BOOLEAN,default:false}),__metadata("design:type",Boolean)],MigrationRunCommand.prototype,"createSchema",undefined);MigrationRunCommand=__decorate([Command.register()],MigrationRunCommand);export{MigrationRunCommand};

package/dist/commands/project.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gets the root path of the Elysium.js project: the closest parent holding an `.elysiumrc`, or
+ * the current directory when there is none.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const getProjectPath: () => string;
+/**
+ * Gets the directory holding the migrations of the Elysium.js project.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const getMigrationsPath: () => string;

package/dist/commands/project.js

@@ -0,0 +1 @@
+import{existsSync}from"node:fs";import{dirname,join}from"node:path";export const getProjectPath=()=>{const startPath=process.cwd();let dir=startPath;while(true){if(existsSync(join(dir,".elysiumrc")))return dir;const parentDir=dirname(dir);if(dir===parentDir)break;dir=parentDir}return startPath};export const getMigrationsPath=()=>join(getProjectPath(),"src/database/migrations");

package/dist/database.d.ts

@@ -1,10 +1,9 @@
 import type { DatabaseCacheConfig, DatabaseDriver } from '@elysiumjs/mnemosyne';
 import type { DrizzleConfig } from 'drizzle-orm';
-import type { BunSQLDatabase } from 'drizzle-orm/bun-sql';
-import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql/postgres';
+import { ElysiumError } from '@elysiumjs/core';
 import { AbstractDatabase } from '@elysiumjs/mnemosyne';
-import { Table } from 'drizzle-orm';
-import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
+export { DEFAULT_CACHE_TTL, DrizzleDatabaseCache } from './cache';
 /**
  * Connection configuration for Drizzle ORM.
  *
@@ -30,28 +29,38 @@ export type DrizzleConnection = BunSQLDatabase<Record<string, never>> & {
     $client: Bun.SQL;
 };
 /**
- * Drizzle query cache backed by the framework's cache storage.
- *
- * Extends the Drizzle `Cache` base class and implements the
- * framework's `DatabaseCacheStrategy` interface so that query
- * results can be transparently cached and invalidated.
+ * Thrown in RLS mode when work for one tenant would join a transaction bound to another.
  *
+ * A transaction is bound to the tenant set when it is opened, for its whole life. Work for another
+ * tenant must run outside the transaction, or in its own `withRLS()` before the transaction opens.
  * @author Axel Nana <axel.nana@workbud.com>
  */
-export declare class DrizzleDatabaseCache extends DrizzleCache {
-    #private;
-    private readonly cacheStrategy;
-    private readonly globalTtl;
-    private usedTablesPerKey;
-    constructor(cacheStrategy?: 'explicit' | 'all', globalTtl?: number, storageEngine?: 'redis' | 'memory');
-    strategy(): 'explicit' | 'all';
-    get(key: string): Promise<any[] | undefined>;
-    put(key: string, response: any, tables: string[], _isTag: boolean, config?: CacheConfig): Promise<void>;
-    onMutate(params: {
-        tags?: string | string[];
-        tables?: string | string[] | Table<any> | Table<any>[];
-    }): Promise<void>;
+export declare class TenantMismatchError extends ElysiumError {
+    readonly transactionTenant: string | null;
+    readonly tenant: string;
+    /**
+     * @param transactionTenant The tenant the open transaction is bound to, or `null` if none.
+     * @param tenant The tenant of the work that tried to join it.
+     */
+    constructor(transactionTenant: string | null, tenant: string);
 }
+/**
+ * Binds a transaction to a tenant: sets the RLS tenant variable for the rest of the transaction.
+ * @internal
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param tx The transaction, just opened.
+ * @param tenant The tenant identifier.
+ */
+export declare const bindTransactionTenant: (tx: DrizzleConnection, tenant: string) => Promise<void>;
+/**
+ * Checks that work for a tenant may join an open transaction: it must be bound to that tenant.
+ * @internal
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param tx The open transaction.
+ * @param tenant The tenant of the work.
+ * @throws {TenantMismatchError} If the transaction is bound to another tenant, or to none.
+ */
+export declare const assertTransactionTenant: (tx: DrizzleConnection, tenant: string) => void;
 /**
  * Drizzle-specific database manager.
  *
@@ -61,6 +70,38 @@ export declare class DrizzleDatabaseCache extends DrizzleCache {
  * @author Axel Nana <axel.nana@workbud.com>
  */
 declare class DrizzleDatabase extends AbstractDatabase<DrizzleConnection, DrizzleConnectionProps> {
+    /**
+     * Retrieves the connection with the given name, or the transaction open on it.
+     *
+     * In RLS mode, an open transaction bound to a tenant is only returned to work for that tenant,
+     * the current one (or `public`).
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param name The connection name.
+     * @returns The connection, or its open transaction.
+     * @throws {TenantMismatchError} If the open transaction is bound to another tenant.
+     */
+    getConnection(name?: string): DrizzleConnection;
+    /**
+     * Runs a callback in a transaction, joining the one open on the connection if any.
+     *
+     * In RLS mode, a new transaction is bound to the current tenant (or `public`), and an open one
+     * is only joined when it is bound to the current tenant.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param callback The function to run with the transaction.
+     * @param name The connection name.
+     * @returns The return value of the callback.
+     * @throws {TenantMismatchError} If the open transaction is bound to another tenant.
+     */
+    transaction<T>(callback: (tx: DrizzleConnection) => Promise<T>, name?: string): Promise<T>;
+    /**
+     * Creates a Drizzle connection from its properties. Used by the `DrizzleModule` to build
+     * the `db.connection.{name}` services.
+     * @author Axel Nana <axel.nana@workbud.com>
+     * @param props The connection properties.
+     * @param name The name of the connection, which scopes its query cache.
+     * @returns A new connection.
+     */
+    createConnection(props: DrizzleConnectionProps, name?: string): DrizzleConnection;
     protected driver: DatabaseDriver<DrizzleConnection, DrizzleConnectionProps>;
 }
 /**
@@ -68,4 +109,3 @@ declare class DrizzleDatabase extends AbstractDatabase<DrizzleConnection, Drizzl
  * @author Axel Nana <axel.nana@workbud.com>
  */
 export declare const Database: DrizzleDatabase;
-export {};

package/dist/database.js

@@ -0,0 +1 @@
+import{ElysiumError}from"@elysiumjs/core";import{AbstractDatabase,getCurrentTenant,getTenancyConfig}from"@elysiumjs/mnemosyne";import{sql}from"drizzle-orm";import{drizzle}from"drizzle-orm/bun-sql";import{DrizzleDatabaseCache}from"./cache";export{DEFAULT_CACHE_TTL,DrizzleDatabaseCache}from"./cache";export class TenantMismatchError extends ElysiumError{transactionTenant;tenant;constructor(transactionTenant,tenant){super(`Cannot run work for tenant "${tenant}" in a transaction bound to `+(transactionTenant===null?"no tenant":`tenant "${transactionTenant}"`)+". Run it outside the transaction, or in its own withRLS() before opening the transaction.");this.transactionTenant=transactionTenant;this.tenant=tenant}}const transactionTenants=new WeakMap;export const bindTransactionTenant=async(tx,tenant)=>{const varName=getTenancyConfig().rls?.sessionVariable??"app.current_tenant";await tx.execute(sql`SELECT set_config(${varName}, ${tenant}, true)`);transactionTenants.set(tx,tenant)};export const assertTransactionTenant=(tx,tenant)=>{const bound=transactionTenants.get(tx);if(bound!==tenant)throw new TenantMismatchError(bound??null,tenant)};class DrizzleDatabase extends AbstractDatabase{getConnection(name="default"){const connection=super.getConnection(name);if(transactionTenants.has(connection)&&getTenancyConfig().mode==="rls"){assertTransactionTenant(connection,getCurrentTenant()??"public")}return connection}async transaction(callback,name="default"){if(getTenancyConfig().mode==="rls"){const active=this.getActiveTransaction(this.getBaseConnection(name));if(active!==undefined)assertTransactionTenant(active,getCurrentTenant()??"public")}return super.transaction(callback,name)}createConnection(props,name="default"){return this.driver.createConnection(props,name)}driver={createConnection(config,name="default"){const cache=config.cache===undefined?undefined:config.cache===true?new DrizzleDatabaseCache(undefined,undefined,undefined,name):config.cache.enabled!==false?new DrizzleDatabaseCache(config.cache.strategy,config.cache.ttl,config.cache.storage,name,config.cache.prefix):undefined;const connection=drizzle({...config,cache});if(cache===undefined)return connection;const transaction=connection.transaction.bind(connection);return Object.assign(connection,{transaction:(callback,txConfig)=>cache.trackTransaction(()=>transaction(callback,txConfig))})},withTransaction(connection,callback){return connection.transaction(async(tx)=>{if(getTenancyConfig().mode==="rls"){await bindTransactionTenant(tx,getCurrentTenant()??"public")}return callback(tx)})},getRawClient(connection){return connection.$client}}}export const Database=new DrizzleDatabase;

package/dist/drizzle.module.d.ts

@@ -0,0 +1,40 @@
+import type { TenancyConfig } from '@elysiumjs/mnemosyne';
+import type { DrizzleConnectionProps } from './database';
+/**
+ * Configuration of the {@link DrizzleModule}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type DrizzleModuleConfig = {
+    /** The name of the connection that `default` resolves to. */
+    default: string;
+    /** The connections to declare, by name. */
+    connections: Record<string, DrizzleConnectionProps>;
+    /** The tenancy configuration. Defaults to schema-based tenancy. */
+    tenancy?: TenancyConfig;
+};
+declare const DrizzleModule_base: (abstract new () => {
+    readonly config: DrizzleModuleConfig;
+    onInit(): Promise<void> | void;
+    onDestroy(): Promise<void> | void;
+    onServe(_app: import("elysia").default<any>): Promise<void> | void;
+}) & {
+    readonly config: string;
+    with(config: Partial<DrizzleModuleConfig> | (() => Partial<DrizzleModuleConfig> | Promise<Partial<DrizzleModuleConfig>>)): import("@elysiumjs/core").ConfiguredModule<DrizzleModuleConfig>;
+    resolveConfig(input?: Partial<DrizzleModuleConfig> | undefined): DrizzleModuleConfig;
+    register<TConfig_1 = any>(props?: import("@elysiumjs/core").ModuleProps<TConfig_1>): (target: import("@elysiumjs/core").ModuleClass) => void;
+    configurable<TConfig extends object>(options?: {
+        defaults?: Partial<TConfig>;
+        required?: (keyof TConfig)[];
+    }): any;
+};
+/**
+ * Declares Drizzle connections as global services named `db.connection.{name}`, plus
+ * `db.connection.default` aliasing the configured default, `db.transaction` (used by
+ * `@transactional` handlers), and registers the tenancy config and strategy. Connections are created on first use. Also provides the migration commands.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare class DrizzleModule extends DrizzleModule_base {
+    /** Closes the clients of the connections that were created. */
+    onDestroy(): Promise<void>;
+}
+export {};

package/dist/drizzle.module.js

@@ -0,0 +1 @@
+var __decorate=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{Module,needsDefaultAlias,runAll,Service}from"@elysiumjs/core";import{AbstractDatabase,DATABASE_TRANSACTION_SERVICE,MnemosyneModule,TENANCY_CONFIG_SERVICE,TENANCY_STRATEGY_SERVICE}from"@elysiumjs/mnemosyne";import{MigrationGenerateCommand}from"./commands/migration_generate.command";import{MigrationRunCommand}from"./commands/migration_run.command";import{Database}from"./database";import{DrizzleRLSTenancy,DrizzleSchemaTenancy}from"./tenancy";let DrizzleModule=class DrizzleModule extends Module.configurable({defaults:{default:"default"},required:["connections"]}){async onDestroy(){const names=Object.keys(this.config.connections).map(AbstractDatabase.getConnectionName);await runAll(names.filter((name)=>Service.isConstructed(name)).map((name)=>()=>Service.get(name)?.$client.close()))}};DrizzleModule=__decorate([Module.register({imports:[MnemosyneModule],commands:[MigrationGenerateCommand,MigrationRunCommand],services:(config)=>{const alias=needsDefaultAlias("DrizzleModule",config);const tenancy=config.tenancy??{mode:"schema"};return[...Object.entries(config.connections).map(([name,props])=>({name:AbstractDatabase.getConnectionName(name),global:true,factory:()=>Database.createConnection(props,name)})),...alias?[{name:AbstractDatabase.getConnectionName("default"),global:true,factory:(_config,get)=>get(AbstractDatabase.getConnectionName(config.default))}]:[],{name:DATABASE_TRANSACTION_SERVICE,global:true,factory:()=>(callback,connection)=>Database.transaction(()=>callback(),connection)},{name:TENANCY_CONFIG_SERVICE,global:true,factory:()=>tenancy},{name:TENANCY_STRATEGY_SERVICE,global:true,factory:()=>tenancy.mode==="rls"?new DrizzleRLSTenancy:new DrizzleSchemaTenancy}]}})],DrizzleModule);export{DrizzleModule};

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export * from 'drizzle-orm';
 export * from 'drizzle-orm/pg-core';
-export type { ColumnsWithTable, SelectedFields, SelectedFieldsFlat, SelectedFieldsOrdered, TableConfig } from 'drizzle-orm/pg-core';
+export type { SelectedFields, SelectedFieldsFlat, SelectedFieldsOrdered, TableConfig } from 'drizzle-orm/pg-core';
 export { pgTable, getTableBuilders } from './table';
-export { Database, DrizzleDatabaseCache } from './database';
+export { Database, DEFAULT_CACHE_TTL, DrizzleDatabaseCache, TenantMismatchError } from './database';
 export type { DrizzleConnectionProps, DrizzleConnection } from './database';
 export { DrizzleModel, createSchemaFromDrizzle, drizzleAdapter, type DrizzleModelOptions } from './model';
+export { DrizzleModule, type DrizzleModuleConfig } from './drizzle.module';
 export { DrizzleRepository } from './repository';
-export { DrizzleSchemaTenancy, DrizzleRLSTenancy, wrapTenantSchema, registerTenantSchema, getTenantSchema, withRLS, setConnectionTenant, getSessionTenant, createRLSPolicy } from './tenancy';
+export { DrizzleSchemaTenancy, DrizzleRLSTenancy, wrapTenantSchema, registerTenantSchema, getTenantSchema, withRLS, getSessionTenant, createRLSPolicy } from './tenancy';

package/dist/index.js

@@ -1,2 +1 @@
-// @bun
-import{Application as T,Event as d}from"@elysiumjs/core";import{registerTenancyStrategy as N}from"@elysiumjs/mnemosyne";import{AbstractDatabase as j,createDatabaseCacheStorage as w}from"@elysiumjs/mnemosyne";import{getTableName as $,is as B,Table as I}from"drizzle-orm";import{drizzle as L}from"drizzle-orm/bun-sql";import{Cache as P}from"drizzle-orm/cache/core";class X extends P{cacheStrategy;globalTtl;#F;usedTablesPerKey={};constructor(F="explicit",G=1,H="redis"){super();this.cacheStrategy=F;this.globalTtl=G;this.#F=w({storage:H})}strategy(){return this.cacheStrategy}async get(F){return await this.#F.get(F)??void 0}async put(F,G,H,J,K){await this.#F.set(F,G,(K?.ex??this.globalTtl)*1000);for(let M of H){let U=this.usedTablesPerKey[M];if(U===void 0)this.usedTablesPerKey[M]=[F];else U.push(F)}}async onMutate(F){let G=F.tags?Array.isArray(F.tags)?F.tags:[F.tags]:[],H=F.tables?Array.isArray(F.tables)?F.tables:[F.tables]:[],J=new Set;for(let K of H){let M=B(K,I)?$(K):K,U=this.usedTablesPerKey[M]??[];for(let E of U)J.add(E)}if(J.size>0||G.length>0){await this.#F.mdel(G),await this.#F.mdel([...J]);for(let K of H){let M=B(K,I)?$(K):K;this.usedTablesPerKey[M]=[]}}}}class O extends j{driver={createConnection(F){let G=F.cache===void 0?void 0:F.cache===!0?new X:F.cache.enabled!==!1?new X(F.cache.strategy,F.cache.ttl,F.cache.storage):void 0;return L({...F,cache:G})},withTransaction(F,G){return F.transaction((H)=>G(H))},getRawClient(F){return F.$client}}}var V=new O;import{getTenancyConfig as q}from"@elysiumjs/mnemosyne";import{sql as A}from"drizzle-orm";import{getTableConfig as v,pgPolicy as s,pgSchema as x,pgTable as C}from"drizzle-orm/pg-core";import{pgTable as g}from"drizzle-orm/pg-core";var R=new WeakMap,Q=(F)=>{return R.get(F)};var Y=new Map,W=new Map,S=(F)=>{return W.get(F)??k(F)},k=(F)=>{if(W.has(F))return W.get(F);let G=x(F);return W.set(F,G),G},D=(F,G,H)=>{if(F==="public")return C(G,H);let J=`${F}.${G}`;if(Y.has(J))return Y.get(J);let M=S(F).table(G,H);return Y.set(J,M),M};class Z{mode="schema";resolveTable(F,G){let H=Q(F);if(!H)throw Error("No column builders registered for table. Use pgTable() from '@elysiumjs/mnemosyne-drizzle' for tenant support.");let J=v(F);return D(G,J.name,H)}async withIsolation(F,G,H){return H()}}class _{mode="rls";resolveTable(F,G){return F}async withIsolation(F,G,H){let K=q().rls?.sessionVariable??"app.current_tenant";return F.transaction(async(M)=>{return await M.execute(A`SELECT set_config(${K}, ${G}, true)`),H()})}}export*from"drizzle-orm";export*from"drizzle-orm/pg-core";d.once("elysium:app:launched",()=>{let G=T.instance.getConfig("elysium:mnemosyne");if(G?.database){for(let[H,J]of Object.entries(G.database.connections))V.registerConnection(H,J);if(V.connectionExists(G.database.default))V.setDefaultConnection(G.database.default)}if(G?.tenancy){let H=G.tenancy.mode==="rls"?new _:new Z;N(H)}});export{QF as wrapTenantSchema,wF as withRLS,LF as setConnectionTenant,EF as registerTenantSchema,JF as pgTable,jF as getTenantSchema,KF as getTableBuilders,PF as getSessionTenant,ZF as drizzleAdapter,YF as createSchemaFromDrizzle,RF as createRLSPolicy,IF as DrizzleSchemaTenancy,$F as DrizzleRepository,OF as DrizzleRLSTenancy,XF as DrizzleModel,VF as DrizzleDatabaseCache,UF as Database};
+export*from"drizzle-orm";export*from"drizzle-orm/pg-core";export{pgTable,getTableBuilders}from"./table";export{Database,DEFAULT_CACHE_TTL,DrizzleDatabaseCache,TenantMismatchError}from"./database";export{DrizzleModel,createSchemaFromDrizzle,drizzleAdapter}from"./model";export{DrizzleModule}from"./drizzle.module";export{DrizzleRepository}from"./repository";export{DrizzleSchemaTenancy,DrizzleRLSTenancy,wrapTenantSchema,registerTenantSchema,getTenantSchema,withRLS,getSessionTenant,createRLSPolicy}from"./tenancy";

package/dist/migrations.d.ts

@@ -0,0 +1,45 @@
+/** A migration recorded as applied in `elysium_migrations`. */
+export type AppliedMigration = {
+    name: string;
+    appliedAt: Date;
+};
+/** The migrations to run, and the applied records to rename to their new names. */
+export type MigrationPlan = {
+    pending: string[];
+    renames: {
+        from: string;
+        to: string;
+    }[];
+};
+/**
+ * Gets the name under which a migration file is tracked. Drizzle Kit 1.0 stores each migration
+ * as `<folder>/migration.sql`, in which case the folder name identifies the migration.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param path The path of the migration file.
+ */
+export declare const getMigrationName: (path: string) => string;
+/**
+ * Decides which migration files to run.
+ *
+ * `drizzle-kit up` moves each flat `<prefix>_<name>.sql` file into a
+ * `<timestamp>_<name>/migration.sql` folder, where the timestamp is when the migration was
+ * generated. An applied record whose flat file is gone is matched, in order, to a folder with
+ * the same `<name>` generated before the record was applied; that folder is not run again and
+ * the record is renamed. Folders generated later are new migrations and run.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param files The paths of the migration files.
+ * @param applied The applied migrations.
+ */
+export declare const planMigrations: (files: string[], applied: AppliedMigration[]) => MigrationPlan;
+/**
+ * Removes the `"public".` qualifier Drizzle Kit writes before identifiers, so that a migration
+ * runs in the schema selected by the `search_path` (the tenant schema).
+ *
+ * Only identifier qualifiers are changed: string literals, dollar-quoted bodies (functions, `DO`
+ * blocks), comments and other quoted identifiers are kept as is. Qualifiers inside a `DO` block
+ * are therefore kept: such blocks are not rewritten, since their contents are not parsed here.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param sql The migration SQL.
+ * @returns The SQL without the public schema qualifiers.
+ */
+export declare const stripPublicSchema: (sql: string) => string;

package/dist/migrations.js

@@ -0,0 +1,2 @@
+import{basename,dirname}from"node:path";const FOLDER_MIGRATION_FILE="migration.sql";export const getMigrationName=(path)=>basename(path)===FOLDER_MIGRATION_FILE?basename(dirname(path)):basename(path);const descriptiveName=(name)=>name.replace(/\.sql$/,"").split("_").slice(1).join("_");const folderTime=(name)=>{const match=/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(name);return match?Date.UTC(+match[1],+match[2]-1,+match[3],+match[4],+match[5],+match[6]):undefined};export const planMigrations=(files,applied)=>{const appliedNames=new Set(applied.map(({name})=>name));const fileNames=new Set(files.map(getMigrationName));const moved=new Map;for(const record of[...applied].sort((a,b)=>a.name.localeCompare(b.name))){if(!record.name.endsWith(".sql")||fileNames.has(record.name))continue;const key=descriptiveName(record.name);moved.set(key,[...moved.get(key)??[],record])}const plan={pending:[],renames:[]};for(const file of[...files].sort()){const name=getMigrationName(file);if(appliedNames.has(name))continue;const from=basename(file)===FOLDER_MIGRATION_FILE?takeMoved(moved,name):undefined;if(from)plan.renames.push({from,to:name});else plan.pending.push(file)}return plan};const takeMoved=(moved,name)=>{const records=moved.get(descriptiveName(name));const generatedAt=folderTime(name);const index=records?.findIndex(({appliedAt})=>generatedAt===undefined||generatedAt<=appliedAt.getTime())??-1;return index<0?undefined:records.splice(index,1)[0].name};const IDENTIFIER_CHAR=/[A-Za-z0-9_$]/;const PUBLIC_QUALIFIER='"public".';const endOfQuoted=(sql,start,quote,backslash)=>{let i=start+1;while(i<sql.length){if(backslash&&sql[i]==="\\")i+=2;else if(sql[i]!==quote)i++;else if(sql[i+1]===quote)i+=2;else return i+1}return sql.length};const endOfVerbatim=(sql,i)=>{const previous=sql[i-1]??"";if(sql.startsWith("--",i)){const end=sql.indexOf(`
+`,i);return end<0?sql.length:end}if(sql.startsWith("/*",i)){const end=sql.indexOf("*/",i+2);return end<0?sql.length:end+2}if(sql[i]==="'"){const escape=/[Ee]/.test(previous)&&!IDENTIFIER_CHAR.test(sql[i-2]??"");return endOfQuoted(sql,i,"'",escape)}if(sql[i]==="$"&&!IDENTIFIER_CHAR.test(previous)){const tag=/^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql.slice(i,i+64))?.[0];if(tag){const end=sql.indexOf(tag,i+tag.length);return end<0?sql.length:end+tag.length}}return-1};export const stripPublicSchema=(sql)=>{let output="";let i=0;while(i<sql.length){const verbatim=endOfVerbatim(sql,i);if(verbatim>=0){output+=sql.slice(i,verbatim);i=verbatim}else if(sql.startsWith(PUBLIC_QUALIFIER,i)&&sql[i+PUBLIC_QUALIFIER.length]==='"'){i+=PUBLIC_QUALIFIER.length}else if(sql[i]==='"'){const end=endOfQuoted(sql,i,'"',false);output+=sql.slice(i,end);i=end}else{output+=sql[i];i++}}return output};