@elysiumjs/mnemosyne-drizzle 0.1.3 → 0.2.0

package/.omc/state/agent-replay-3920b579-6d8e-4f5f-924a-319202936685.jsonl

@@ -0,0 +1,7 @@
+{"t":0,"agent":"aac206b","agent_type":"executor","event":"agent_start","parent_mode":"none"}
+{"t":0,"agent":"a914068","agent_type":"executor","event":"agent_stop","success":true,"duration_ms":31478}
+{"t":0,"agent":"aa0cc16","agent_type":"untracked-native-fork","event":"agent_stop","success":true,"synthetic":true,"telemetry_status":"unmatched_stop","reason":"SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."}
+{"t":0,"agent":"a55f688","agent_type":"untracked-native-fork","event":"agent_stop","success":true,"synthetic":true,"telemetry_status":"unmatched_stop","reason":"SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."}
+{"t":0,"agent":"a0ba584","agent_type":"untracked-native-fork","event":"agent_stop","success":true,"synthetic":true,"telemetry_status":"unmatched_stop","reason":"SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."}
+{"t":0,"agent":"a6e8774","agent_type":"untracked-native-fork","event":"agent_stop","success":true,"synthetic":true,"telemetry_status":"unmatched_stop","reason":"SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."}
+{"t":0,"agent":"aac206b","agent_type":"executor","event":"agent_stop","success":true,"duration_ms":168112}

package/.omc/state/sessions/3920b579-6d8e-4f5f-924a-319202936685/last-tool-error-state.json

@@ -0,0 +1,7 @@
+{
+  "tool_name": "Bash",
+  "tool_input_preview": "{\"command\":\"perl -0pi -e 's/\\\\t\\\\t\\\\tconst migrations: \\\\{ name: string \\\\}\\\\[\\\\] = await sql`SELECT name FROM elysium_migrations;`;\\\\n\\\\t\\\\t\\\\tconst completedMigrations = migrations\\\\.map\\\\(\\\\(row\\\\)...",
+  "error": "Exit code 1\n\t\t\t}\n\n\t\t\tconst rows: { name: string; applied_at: Date }[] =\n\t\t\t\tawait sql`SELECT name, applied_at FROM elysium_migrations;`;\n\t\t\tconst completedMigrations = rows.map((row) => ({ name: row.name, appliedAt: row.applied_at }));\n\n\t\t\tconst filesIt = new Bun.Glob(`./src/database/migrations/**/*.sql`).scan({\n\t\t\t\tabsolute: true,\n\t\t\t\tonlyFiles: true\n\t\t\t});\n\n\t\t\tconst files = await Array.fromAsync(filesIt);\n\t\t\tconst { pending: sqlFiles, renames } = planMigrations(files, completedMigrations);\nChe...",
+  "timestamp": "2026-10-26T02:29:07.154Z",
+  "retry_count": 1
+}

package/.omc/state/sessions/3920b579-6d8e-4f5f-924a-319202936685/mission-state.json

@@ -0,0 +1,93 @@
+{
+  "updatedAt": "2026-10-24T23:32:53.900Z",
+  "missions": [
+    {
+      "id": "session:3920b579-6d8e-4f5f-924a-319202936685:none",
+      "source": "session",
+      "name": "none",
+      "objective": "Session mission",
+      "createdAt": "2026-10-24T23:30:05.788Z",
+      "updatedAt": "2026-10-24T23:32:53.900Z",
+      "status": "done",
+      "workerCount": 1,
+      "taskCounts": {
+        "total": 1,
+        "pending": 0,
+        "blocked": 0,
+        "inProgress": 0,
+        "completed": 1,
+        "failed": 0
+      },
+      "agents": [
+        {
+          "name": "executor:aac206b",
+          "role": "executor",
+          "ownership": "aac206b9ab7956eb4",
+          "status": "done",
+          "currentStep": null,
+          "latestUpdate": "completed",
+          "completedSummary": null,
+          "updatedAt": "2026-10-24T23:32:53.900Z"
+        }
+      ],
+      "timeline": [
+        {
+          "id": "session-start:aac206b9ab7956eb4:2026-10-24T23:30:05.788Z",
+          "at": "2026-10-24T23:30:05.788Z",
+          "kind": "update",
+          "agent": "executor:aac206b",
+          "detail": "started executor:aac206b",
+          "sourceKey": "session-start:aac206b9ab7956eb4"
+        },
+        {
+          "id": "session-stop:a914068b2d3b26e56:2026-10-24T23:30:37.266Z",
+          "at": "2026-10-24T23:30:37.266Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:a914068b2d3b26e56"
+        },
+        {
+          "id": "session-stop:aa0cc16535a1e4c83:2026-10-24T23:31:08.989Z",
+          "at": "2026-10-24T23:31:08.989Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:aa0cc16535a1e4c83"
+        },
+        {
+          "id": "session-stop:a55f6887513d75db7:2026-10-24T23:31:40.515Z",
+          "at": "2026-10-24T23:31:40.515Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:a55f6887513d75db7"
+        },
+        {
+          "id": "session-stop:a0ba584b3d851e834:2026-10-24T23:32:12.704Z",
+          "at": "2026-10-24T23:32:12.704Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:a0ba584b3d851e834"
+        },
+        {
+          "id": "session-stop:a6e8774450f70f52b:2026-10-24T23:32:44.262Z",
+          "at": "2026-10-24T23:32:44.262Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:a6e8774450f70f52b"
+        },
+        {
+          "id": "session-stop:aac206b9ab7956eb4:2026-10-24T23:32:53.900Z",
+          "at": "2026-10-24T23:32:53.900Z",
+          "kind": "completion",
+          "agent": "executor:aac206b",
+          "detail": "completed",
+          "sourceKey": "session-stop:aac206b9ab7956eb4"
+        }
+      ]
+    }
+  ]
+}

package/.omc/state/sessions/3920b579-6d8e-4f5f-924a-319202936685/pre-tool-advisory-throttle.json

@@ -0,0 +1,18 @@
+{
+  "version": 1,
+  "entries": {
+    "445ed27a3872b681d98190bae61ccb84954e1bc4e140df5370be958dee776b3a": {
+      "last_emitted_at_ms": 1792981759903,
+      "message": "Verify changes work after editing. Test functionality before marking complete."
+    },
+    "79a93d4a2f8f50b95f852280616242fee1855dc99a3c75211917f55e72e95fae": {
+      "last_emitted_at_ms": 1792981745167,
+      "message": "Use parallel execution for independent tasks. Use run_in_background for long operations (npm install, builds, tests)."
+    },
+    "466399dafa2d20f60587180bad0a07358eb7f2bce724df0ff682f038ad33f5ad": {
+      "last_emitted_at_ms": 1792981448165,
+      "message": "Read multiple files in parallel when possible for faster analysis."
+    }
+  },
+  "updated_at": "2026-10-26T02:29:19.903Z"
+}

package/.omc/state/sessions/3920b579-6d8e-4f5f-924a-319202936685/subagent-tracking-state.json

@@ -0,0 +1,61 @@
+{
+  "agents": [
+    {
+      "agent_id": "aac206b9ab7956eb4",
+      "agent_type": "oh-my-claudecode:executor",
+      "started_at": "2026-10-24T23:30:05.788Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-10-24T23:32:53.900Z",
+      "duration_ms": 168112
+    },
+    {
+      "agent_id": "aa0cc16535a1e4c83",
+      "agent_type": "untracked-native-fork",
+      "started_at": "2026-10-24T23:31:08.989Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-10-24T23:31:08.989Z",
+      "synthetic": true,
+      "telemetry_status": "unmatched_stop",
+      "telemetry_note": "SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."
+    },
+    {
+      "agent_id": "a55f6887513d75db7",
+      "agent_type": "untracked-native-fork",
+      "started_at": "2026-10-24T23:31:40.515Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-10-24T23:31:40.515Z",
+      "synthetic": true,
+      "telemetry_status": "unmatched_stop",
+      "telemetry_note": "SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."
+    },
+    {
+      "agent_id": "a0ba584b3d851e834",
+      "agent_type": "untracked-native-fork",
+      "started_at": "2026-10-24T23:32:12.704Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-10-24T23:32:12.704Z",
+      "synthetic": true,
+      "telemetry_status": "unmatched_stop",
+      "telemetry_note": "SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."
+    },
+    {
+      "agent_id": "a6e8774450f70f52b",
+      "agent_type": "untracked-native-fork",
+      "started_at": "2026-10-24T23:32:44.262Z",
+      "parent_mode": "none",
+      "status": "completed",
+      "completed_at": "2026-10-24T23:32:44.262Z",
+      "synthetic": true,
+      "telemetry_status": "unmatched_stop",
+      "telemetry_note": "SubagentStop arrived without a matching SubagentStart; native Agent/Task start telemetry was not observed."
+    }
+  ],
+  "total_spawned": 1,
+  "total_completed": 6,
+  "total_failed": 0,
+  "last_updated": "2026-10-24T23:32:53.907Z"
+}

package/.turbo/turbo-build.log

@@ -0,0 +1,3 @@
+$ bun run clean && tsc && bun run build:minify
+$ rimraf dist
+$ bun scripts/minify.ts

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# @elysiumjs/mnemosyne-drizzle
+
+## 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/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{existsSync}from"node:fs";import{exists}from"node:fs/promises";import{dirname,join}from"node:path";import{Command,CommandArgumentType}from"@elysiumjs/core";import prompts from"prompts";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};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();let schemaPath=`${projectRoot}/src/database/schemas`;if(await exists(`${projectRoot}/src/database/schema.ts`)){schemaPath=`${projectRoot}/src/database/schema.ts`}await Bun.$`bunx --bun drizzle-kit generate --dialect postgresql --schema ${schemaPath} --out ${projectRoot}/src/database/migrations --name ${this.name}`;const sqlFiles=new Bun.Glob(`${projectRoot}/src/database/migrations/**/*.sql`).scan();for await(const path of sqlFiles){const file=Bun.file(path);const content=await file.text();await file.write(content.replace(/"public"\./gm,""))}}};__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,13 @@
+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;
+    run(): Promise<void>;
+}

package/dist/commands/migration_run.command.js

@@ -0,0 +1,15 @@
+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 prompts from"prompts";import{Database}from"../database";import{getMigrationName,planMigrations}from"../migrations";let MigrationRunCommand=class MigrationRunCommand extends Command{static command="migration:run";static description="Runs pending migrations.";tenant="";connection="default";fresh=false;async run(){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();await sql.begin(async(sql)=>{if(this.fresh){await sql`DROP SCHEMA IF EXISTS ${sql(this.tenant)} CASCADE;`;await sql`CREATE SCHEMA ${sql(this.tenant)};`}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){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){await sql`CREATE SCHEMA ${sql(this.tenant)};`}else{this.error(`Schema ${this.bold(this.tenant)} creation cancelled.`);return process.exit(1)}}await sql`SET search_path TO ${sql(this.tenant)};`;const[{table_exists}]=await sql`SELECT EXISTS (
+			SELECT *
+			  FROM information_schema.tables
+			 WHERE table_name = 'elysium_migrations'
+			   AND table_schema = ${this.tenant}
+		) AS table_exists;`;if(!table_exists){await sql`CREATE TABLE elysium_migrations (
+				id SERIAL PRIMARY KEY,
+				name TEXT NOT NULL,
+				batch INTEGER NOT NULL,
+				applied_at TIMESTAMP NOT NULL
+			);`}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(`./src/database/migrations/**/*.sql`).scan({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.`)});await sql.close()}};__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);MigrationRunCommand=__decorate([Command.register()],MigrationRunCommand);export{MigrationRunCommand};

package/dist/database.d.ts

@@ -0,0 +1,79 @@
+import type { DatabaseCacheConfig, DatabaseDriver } from '@elysiumjs/mnemosyne';
+import type { DrizzleConfig } from 'drizzle-orm';
+import type { BunSQLDatabase } from 'drizzle-orm/bun-sql/postgres';
+import type { CacheConfig } from 'drizzle-orm/cache/core/types';
+import { AbstractDatabase } from '@elysiumjs/mnemosyne';
+import { Table } from 'drizzle-orm';
+import { Cache as DrizzleCache } from 'drizzle-orm/cache/core';
+/**
+ * Connection configuration for Drizzle ORM.
+ *
+ * Extends `DrizzleConfig` with connection details and optional caching.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @template TSchema The Drizzle schema type.
+ */
+export type DrizzleConnectionProps<TSchema extends Record<string, unknown> = Record<string, never>> = Omit<DrizzleConfig<TSchema>, 'cache'> & ({
+    connection: string | ({
+        url?: string;
+    } & Bun.SQLOptions);
+} | {
+    client: Bun.SQL;
+}) & {
+    cache?: true | DatabaseCacheConfig;
+};
+/**
+ * A Drizzle database connection backed by Bun's SQL driver.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+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.
+ *
+ * @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>;
+}
+/**
+ * Drizzle-specific database manager.
+ *
+ * Implements the abstract database class with a driver that creates
+ * Drizzle connections using Bun's built-in SQL client.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+declare class DrizzleDatabase extends AbstractDatabase<DrizzleConnection, DrizzleConnectionProps> {
+    /**
+     * 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.
+     * @returns A new connection.
+     */
+    createConnection(props: DrizzleConnectionProps): DrizzleConnection;
+    protected driver: DatabaseDriver<DrizzleConnection, DrizzleConnectionProps>;
+}
+/**
+ * Singleton Drizzle database manager.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const Database: DrizzleDatabase;
+export {};

package/dist/database.js

@@ -0,0 +1 @@
+import{Service,ServiceNotReadyError}from"@elysiumjs/core";import{AbstractDatabase,createDatabaseCacheStorage}from"@elysiumjs/mnemosyne";import{getTableName,is,Table}from"drizzle-orm";import{drizzle}from"drizzle-orm/bun-sql";import{Cache as DrizzleCache}from"drizzle-orm/cache/core";export class DrizzleDatabaseCache extends DrizzleCache{cacheStrategy;globalTtl;#storageEngine;#cache;usedTablesPerKey={};constructor(cacheStrategy="explicit",globalTtl=1,storageEngine="redis"){super();this.cacheStrategy=cacheStrategy;this.globalTtl=globalTtl;this.#storageEngine=storageEngine}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 get(key){return await(await this.#storage()).get(key)??undefined}async put(key,response,tables,_isTag,config){await(await this.#storage()).set(key,response,(config?.ex??this.globalTtl)*1000);for(const table of tables){const keys=this.usedTablesPerKey[table];if(keys===undefined){this.usedTablesPerKey[table]=[key]}else{keys.push(key)}}}async onMutate(params){const tagsArray=params.tags?Array.isArray(params.tags)?params.tags:[params.tags]:[];const tablesArray=params.tables?Array.isArray(params.tables)?params.tables:[params.tables]:[];const keysToDelete=new Set;for(const table of tablesArray){const tableName=is(table,Table)?getTableName(table):table;const keys=this.usedTablesPerKey[tableName]??[];for(const key of keys)keysToDelete.add(key)}if(keysToDelete.size>0||tagsArray.length>0){const cache=await this.#storage();await cache.mdel(tagsArray);await cache.mdel([...keysToDelete]);for(const table of tablesArray){const tableName=is(table,Table)?getTableName(table):table;this.usedTablesPerKey[tableName]=[]}}}}class DrizzleDatabase extends AbstractDatabase{createConnection(props){return this.driver.createConnection(props)}driver={createConnection(config){const cache=config.cache===undefined?undefined:config.cache===true?new DrizzleDatabaseCache:config.cache.enabled!==false?new DrizzleDatabaseCache(config.cache.strategy,config.cache.ttl,config.cache.storage):undefined;return drizzle({...config,cache})},withTransaction(connection,callback){return connection.transaction((tx)=>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, 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,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)})),...alias?[{name:AbstractDatabase.getConnectionName("default"),global:true,factory:(_config,get)=>get(AbstractDatabase.getConnectionName(config.default))}]:[],{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

@@ -0,0 +1,10 @@
+export * from 'drizzle-orm';
+export * 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 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';

package/dist/index.js

@@ -0,0 +1 @@
+export*from"drizzle-orm";export*from"drizzle-orm/pg-core";export{pgTable,getTableBuilders}from"./table";export{Database,DrizzleDatabaseCache}from"./database";export{DrizzleModel,createSchemaFromDrizzle,drizzleAdapter}from"./model";export{DrizzleModule}from"./drizzle.module";export{DrizzleRepository}from"./repository";export{DrizzleSchemaTenancy,DrizzleRLSTenancy,wrapTenantSchema,registerTenantSchema,getTenantSchema,withRLS,setConnectionTenant,getSessionTenant,createRLSPolicy}from"./tenancy";

package/dist/migrations.d.ts

@@ -0,0 +1,33 @@
+/** 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;

package/dist/migrations.js

@@ -0,0 +1 @@
+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};

package/dist/model.d.ts

@@ -0,0 +1,61 @@
+import type { ModelAdapter } from '@elysiumjs/mnemosyne';
+import type { PgTableWithColumns, TableConfig } from 'drizzle-orm/pg-core';
+/**
+ * Drizzle-specific model adapter.
+ *
+ * Bridges Drizzle's `PgTableWithColumns` to the framework's
+ * normalized model metadata.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export declare const drizzleAdapter: ModelAdapter<PgTableWithColumns<any>>;
+/**
+ * Creates Elysia validation schemas from a Drizzle table.
+ *
+ * This is a convenience wrapper around `createSchemaFromModel` that
+ * automatically extracts column metadata via the `drizzleAdapter`.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param table The Drizzle table to generate schemas for.
+ * @param opts Schema generation options.
+ * @returns An Elysia validation schema.
+ */
+export declare const createSchemaFromDrizzle: (table: PgTableWithColumns<any>, opts?: {
+    mode?: 'create' | 'update' | 'select';
+}) => import("@sinclair/typebox").TObject<{}>;
+/**
+ * Options for creating a DrizzleModel.
+ */
+export interface DrizzleModelOptions {
+    /**
+     * Enable tenant schema support for this model.
+     * @default false
+     */
+    supportTenancy?: boolean;
+}
+/**
+ * Creates a model class backed by a Drizzle pgTable.
+ *
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param table The Drizzle table (created with enhanced pgTable).
+ * @param options Model configuration options.
+ * @returns A model class with Drizzle-backed static metadata.
+ */
+export declare const DrizzleModel: <TTable extends PgTableWithColumns<TableConfig>>(table: TTable, options?: DrizzleModelOptions) => {
+    new (): {};
+    readonly $inferSelect: unknown;
+    readonly $inferInsert: unknown;
+    readonly $inferUpdate: unknown;
+    readonly table: any;
+    readonly tableName: string;
+    readonly columns: Record<string, import("drizzle-orm/pg-core").AnyPgColumnBuilder>;
+    readonly insertSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly updateSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly selectSchema: import("@sinclair/typebox").TObject<{}>;
+    readonly supportTenancy: boolean;
+} & {
+    readonly $inferSelect: TTable["$inferSelect"];
+    readonly $inferInsert: TTable["$inferInsert"];
+    readonly $inferUpdate: Partial<TTable["$inferInsert"]>;
+    readonly table: TTable;
+};

package/dist/model.js

@@ -0,0 +1 @@
+import{AbstractModel,createSchemaFromModel}from"@elysiumjs/mnemosyne";import{getTableConfig}from"drizzle-orm/pg-core";import{getTableBuilders}from"./table";import{wrapTenantSchema}from"./tenancy";const mapDrizzleDataType=(col)=>{if(col.columnType==="PgUUID")return"uuid";if(col.dimensions)return"array";const[kind,constraint]=col.dataType.split(" ");switch(kind){case"number":return"number";case"boolean":return"boolean";case"array":return"array";case"bigint":return"bigint";case"object":switch(constraint){case"json":return"json";case"date":return"date";case"buffer":return"buffer";default:return"string"}default:return"string"}};export const drizzleAdapter={getTableName(table){return getTableConfig(table).name},getColumns(table){const config=getTableConfig(table);return config.columns.map((col)=>({name:col.name,dataType:mapDrizzleDataType(col),nullable:!col.notNull,hasDefault:col.hasDefault,isPrimaryKey:col.primary||config.primaryKeys.some((pk)=>pk.columns.some((c)=>c.name===col.name))}))},createTenantTable(table,tenant){const builders=getTableBuilders(table);if(!builders){throw new Error(`No column builders registered for table. `+`Use pgTable() from '@elysiumjs/mnemosyne-drizzle' for tenant support.`)}const config=getTableConfig(table);return wrapTenantSchema(tenant,config.name,builders)}};export const createSchemaFromDrizzle=(table,opts)=>{return createSchemaFromModel(drizzleAdapter.getColumns(table),opts)};export const DrizzleModel=(table,options)=>{const config=getTableConfig(table);const builders=getTableBuilders(table);const Base=AbstractModel(config.name,builders??{},drizzleAdapter,table);if(options?.supportTenancy!==undefined){Base.supportTenancy=options.supportTenancy}return Base};