@elysiumjs/mnemosyne-drizzle 0.2.0 → 0.3.1

package/src/repository.ts

@@ -1,113 +0,0 @@
-// Copyright (c) 2026-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { IdType, ModelClass } from '@elysiumjs/mnemosyne';
-import type { PgTableWithColumns } from 'drizzle-orm/pg-core';
-import type { DrizzleConnection } from './database';
-
-import { AbstractRepository } from '@elysiumjs/mnemosyne';
-import { eq } from 'drizzle-orm';
-
-import { Database } from './database';
-
-// ============================================================================
-// DrizzleRepository Mixin
-// ============================================================================
-
-/**
- * Drizzle-specific repository mixin with concrete CRUD operations.
- *
- * Extends the abstract repository with Drizzle query builder calls
- * for all standard CRUD methods.
- *
- * @author Axel Nana <axel.nana@workbud.com>
- * @template TModel The model class type.
- * @param model The model class to create the repository for.
- * @returns A concrete repository class with CRUD methods.
- */
-export const DrizzleRepository = <
-	TModel extends ModelClass<any, any, any, PgTableWithColumns<any>>
->(
-	model: TModel
-) => {
-	type TSelect = TModel['$inferSelect'];
-	type TInsert = TModel['$inferInsert'];
-	type TUpdate = TModel['$inferUpdate'];
-
-	class R extends AbstractRepository<TModel, DrizzleConnection>(model, Database) {
-		public async all(): Promise<TSelect[]> {
-			return await this.db.select().from(model.table);
-		}
-
-		public async paginate(
-			count: number,
-			page: number = 1
-		): Promise<{ page: number; data: TSelect[]; total: number }> {
-			const total = await this.db.$count(model.table);
-			const offset = Math.max(page - 1, 0) * count;
-			return {
-				page,
-				total,
-				data: await this.db.select().from(model.table).offset(offset).limit(count)
-			};
-		}
-
-		public async find(id: IdType): Promise<TSelect | null> {
-			const [row] = await this.db.select().from(model.table).where(eq(model.table.id, id));
-			return (row ?? null) as TSelect | null;
-		}
-
-		public async findBy<TKey extends keyof TSelect>(
-			column: TKey,
-			value: TSelect[TKey]
-		): Promise<TSelect | null> {
-			const [row] = await this.db.select().from(model.table).where(eq(model.table[column], value));
-			return (row ?? null) as TSelect | null;
-		}
-
-		public async insert(data: TInsert): Promise<TSelect> {
-			const [row] = await this.db.insert(model.table).values(data).returning();
-			return row as TSelect;
-		}
-
-		public async update(id: IdType, data: TUpdate): Promise<TSelect> {
-			const [row] = await this.db
-				.update(model.table)
-				.set(data)
-				.where(eq(model.table.id, id))
-				.returning();
-			return row as TSelect;
-		}
-
-		public async updateAll(data: TUpdate): Promise<TSelect[]> {
-			return await this.db.update(model.table).set(data).returning();
-		}
-
-		public async delete(id: IdType): Promise<TSelect> {
-			const [row] = await this.db.delete(model.table).where(eq(model.table.id, id)).returning();
-			return row as TSelect;
-		}
-
-		public async deleteAll(): Promise<TSelect[]> {
-			return await this.db.delete(model.table).returning();
-		}
-
-		public async exists(id: IdType): Promise<boolean> {
-			const count = await this.db.$count(model.table, eq(model.table.id, id));
-			return count > 0;
-		}
-	}
-
-	return R;
-};

package/src/table.ts

@@ -1,70 +0,0 @@
-// Copyright (c) 2026-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { AnyPgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
-
-import { pgTable as drizzlePgTable } from 'drizzle-orm/pg-core';
-
-// ============================================================================
-// Column Builder Registry
-// ============================================================================
-
-/**
- * Maps tables to their original column builder definitions.
- *
- * When `pgTable()` is called, column builders are consumed and turned into
- * built `PgColumn` instances. This registry preserves the original builder
- * objects so that tenant tables can be re-created in different schemas.
- */
-const tableRegistry = new WeakMap<PgTableWithColumns<any>, Record<string, AnyPgColumnBuilder>>();
-
-/**
- * Retrieves the original column builders for a table.
- * @param table The table created with enhanced pgTable.
- * @returns The original column builder definitions, or `undefined`.
- */
-export const getTableBuilders = (
-	table: PgTableWithColumns<any>
-): Record<string, AnyPgColumnBuilder> | undefined => {
-	return tableRegistry.get(table);
-};
-
-// ============================================================================
-// Enhanced pgTable Function
-// ============================================================================
-
-/**
- * Creates a PostgreSQL table with automatic column builder registration.
- *
- * This is an enhanced version of Drizzle's `pgTable` that automatically
- * registers column builders for tenancy support. It has the exact same
- * signature and behavior as the original.
- *
- * @param tableName The name of the database table.
- * @param columns The column definitions.
- * @param extraConfig Optional extra Drizzle table configuration.
- * @returns A Drizzle PostgreSQL table with registered column builders.
- */
-export const pgTable = <
-	TTableName extends string,
-	TColumns extends Record<string, AnyPgColumnBuilder>
->(
-	tableName: TTableName,
-	columns: TColumns,
-	extraConfig?: (table: any) => any
-) => {
-	const table = drizzlePgTable(tableName, columns, extraConfig);
-	tableRegistry.set(table, columns);
-	return table;
-};

package/src/tenancy.ts

@@ -1,249 +0,0 @@
-// Copyright (c) 2026-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import type { TenancyStrategy } from '@elysiumjs/mnemosyne';
-import type { AnyPgColumnBuilder, PgAsyncTransaction, PgSchema, PgTable } from 'drizzle-orm/pg-core';
-import type { DrizzleConnection } from './database';
-
-import { getTenancyConfig } from '@elysiumjs/mnemosyne';
-import { sql } from 'drizzle-orm';
-import { getTableConfig, pgPolicy, pgSchema, pgTable } from 'drizzle-orm/pg-core';
-
-import { Database } from './database';
-import { getTableBuilders } from './table';
-
-// ============================================================================
-// Internal State
-// ============================================================================
-
-const tenantSchemas: Map<string, PgTable> = new Map();
-const schemaRegistry: Map<string, PgSchema> = new Map();
-
-// ============================================================================
-// Schema-based Tenancy Helpers
-// ============================================================================
-
-/**
- * Returns the Drizzle `PgSchema` for the given tenant, creating it if needed.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tenant The tenant identifier.
- * @returns The tenant's PostgreSQL schema.
- */
-export const getTenantSchema = (tenant: string): PgSchema => {
-	return schemaRegistry.get(tenant) ?? registerTenantSchema(tenant);
-};
-
-/**
- * Registers a new tenant schema in the registry.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tenant The tenant identifier.
- * @returns The newly registered (or existing) `PgSchema`.
- */
-export const registerTenantSchema = (tenant: string): PgSchema => {
-	if (schemaRegistry.has(tenant)) {
-		return schemaRegistry.get(tenant)!;
-	}
-	const tenantSchema = pgSchema(tenant);
-	schemaRegistry.set(tenant, tenantSchema);
-	return tenantSchema;
-};
-
-/**
- * Wraps a table definition in a tenant-specific schema.
- *
- * For the `'public'` tenant, returns a standard `pgTable`.
- * For other tenants, creates a schema-qualified table and caches it.
- *
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tenant The tenant identifier.
- * @param tableName The table name.
- * @param columns The column definitions.
- * @returns A tenant-scoped `PgTable`.
- */
-export const wrapTenantSchema = <
-	TTableName extends string,
-	TColumnsMap extends Record<string, AnyPgColumnBuilder>
->(
-	tenant: string,
-	tableName: TTableName,
-	columns: TColumnsMap
-): PgTable => {
-	if (tenant === 'public') {
-		return pgTable(tableName, columns);
-	}
-
-	const fullTableName = `${tenant}.${tableName}`;
-	if (tenantSchemas.has(fullTableName)) {
-		return tenantSchemas.get(fullTableName)!;
-	}
-
-	const tenantSchema = getTenantSchema(tenant);
-	const schemaTable = tenantSchema.table(tableName, columns);
-	tenantSchemas.set(fullTableName, schemaTable);
-
-	return schemaTable;
-};
-
-// ============================================================================
-// RLS-based Tenancy Helpers
-// ============================================================================
-
-/**
- * Executes a callback within an RLS-scoped transaction for the given tenant.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tenant The tenant identifier (or `null` for 'public').
- * @param callback The function to execute within the transaction.
- * @param connectionName The database connection name.
- * @returns The return value of the callback.
- */
-export const withRLS = async <T>(
-	tenant: string | null,
-	callback: (tx: PgAsyncTransaction<any, any>) => Promise<T>,
-	connectionName: string = 'default'
-): Promise<T> => {
-	const db = Database.getConnection(connectionName);
-	const config = getTenancyConfig();
-	const varName = config.rls?.sessionVariable ?? 'app.current_tenant';
-	const value = tenant ?? 'public';
-
-	return (db as any).transaction(async (tx: PgAsyncTransaction<any, any>) => {
-		await tx.execute(sql`SELECT set_config(${varName}, ${value}, true)`);
-		return callback(tx);
-	});
-};
-
-/**
- * Sets the current tenant on a persistent database connection (session-level).
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tenant The tenant identifier (or `null` for 'public').
- * @param connectionName The database connection name.
- */
-export const setConnectionTenant = async (
-	tenant: string | null,
-	connectionName: string = 'default'
-): Promise<void> => {
-	const db = Database.getConnection(connectionName);
-	const config = getTenancyConfig();
-	const varName = config.rls?.sessionVariable ?? 'app.current_tenant';
-	const value = tenant ?? 'public';
-
-	await (db as any).execute(sql`SELECT set_config(${varName}, ${value}, false)`);
-};
-
-/**
- * Reads the current tenant from the PostgreSQL session variable.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param connectionName The database connection name.
- * @returns The current tenant identifier, or `null`.
- */
-export const getSessionTenant = async (
-	connectionName: string = 'default'
-): Promise<string | null> => {
-	const db = Database.getConnection(connectionName);
-	const config = getTenancyConfig();
-	const varName = config.rls?.sessionVariable ?? 'app.current_tenant';
-
-	const result = await (db as any).execute(sql`SELECT current_setting(${varName}, true) as tenant`);
-	return (result as any)?.rows?.[0]?.tenant ?? null;
-};
-
-/**
- * Creates an RLS policy for tenant isolation on a table.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param tableName The table name.
- * @param columnName The tenant column name (defaults to config or 'tenant_id').
- * @param policyName The policy name (defaults to `{tableName}_tenant_isolation`).
- * @returns A Drizzle `PgPolicy` instance.
- */
-export const createRLSPolicy = (tableName: string, columnName?: string, policyName?: string) => {
-	const config = getTenancyConfig();
-	const varName = config.rls?.sessionVariable ?? 'app.current_tenant';
-	const column = columnName ?? config.rls?.defaultColumn ?? 'tenant_id';
-	const name = policyName ?? `${tableName}_tenant_isolation`;
-
-	return pgPolicy(name, {
-		for: 'all',
-		to: 'public',
-		using: sql`${sql.identifier(column)} = current_setting(${varName}, true)::text`,
-		withCheck: sql`${sql.identifier(column)} = current_setting(${varName}, true)::text`
-	});
-};
-
-// ============================================================================
-// TenancyStrategy Implementations
-// ============================================================================
-
-/**
- * Schema-based tenancy strategy for Drizzle.
- *
- * Each tenant gets its own PostgreSQL schema. Table resolution maps
- * the base table to a schema-qualified equivalent.
- *
- * @author Axel Nana <axel.nana@workbud.com>
- */
-export class DrizzleSchemaTenancy implements TenancyStrategy<PgTable, DrizzleConnection> {
-	readonly mode = 'schema';
-
-	resolveTable(table: PgTable, tenant: string): PgTable {
-		const builders = getTableBuilders(table as any);
-		if (!builders) {
-			throw new Error(
-				`No column builders registered for table. ` +
-					`Use pgTable() from '@elysiumjs/mnemosyne-drizzle' for tenant support.`
-			);
-		}
-		const config = getTableConfig(table as any);
-		return wrapTenantSchema(tenant, config.name, builders) as PgTable;
-	}
-
-	async withIsolation<T>(
-		_connection: DrizzleConnection,
-		_tenant: string,
-		callback: () => Promise<T>
-	): Promise<T> {
-		// Schema-based isolation doesn't need transaction wrapping
-		return callback();
-	}
-}
-
-/**
- * Row-Level Security tenancy strategy for Drizzle.
- *
- * All tenants share the same schema. Isolation is achieved via
- * PostgreSQL RLS policies and a session variable set in each transaction.
- *
- * @author Axel Nana <axel.nana@workbud.com>
- */
-export class DrizzleRLSTenancy implements TenancyStrategy<PgTable, DrizzleConnection> {
-	readonly mode = 'rls';
-
-	resolveTable(table: PgTable, _tenant: string): PgTable {
-		// RLS doesn't modify the table - filtering is handled by policies
-		return table;
-	}
-
-	async withIsolation<T>(
-		connection: DrizzleConnection,
-		tenant: string,
-		callback: () => Promise<T>
-	): Promise<T> {
-		const config = getTenancyConfig();
-		const varName = config.rls?.sessionVariable ?? 'app.current_tenant';
-
-		return (connection as any).transaction(async (tx: PgAsyncTransaction<any, any>) => {
-			await tx.execute(sql`SELECT set_config(${varName}, ${tenant}, true)`);
-			return callback();
-		});
-	}
-}

package/tests/drizzle.module.test.ts

@@ -1,201 +0,0 @@
-// Copyright (c) 2026-present Workbud Technologies Inc. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { Application, Event, Service } from '@elysiumjs/core';
-import { getTenancyConfig, getTenancyStrategy } from '@elysiumjs/mnemosyne';
-import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test';
-
-import * as pkg from '../src';
-import { Database, DrizzleDatabaseCache, DrizzleModule, DrizzleRLSTenancy, DrizzleSchemaTenancy } from '../src';
-
-const URL = 'postgres://u:p@localhost:5432/db';
-
-const stubClient = () => ({
-	options: {},
-	connect: mock(async () => {}),
-	begin: mock(async (_callback: unknown) => {}),
-	close: mock(async () => {})
-});
-
-describe('DrizzleModule', () => {
-	let app: Awaited<ReturnType<typeof Application.testing>> | undefined;
-
-	afterEach(async () => {
-		await app?.shutdown();
-		app = undefined;
-	});
-
-	it('registers nothing when the package is imported', async () => {
-		const once = spyOn(Event, 'once');
-		const on = spyOn(Event, 'on');
-		await import('../src/index.ts?fresh-import');
-		expect(once).not.toHaveBeenCalled();
-		expect(on).not.toHaveBeenCalled();
-		once.mockRestore();
-		on.mockRestore();
-		expect(Service.exists('db.connection.default')).toBe(false);
-		expect(Service.exists('mnemosyne.tenancy.config')).toBe(false);
-		expect(typeof pkg.DrizzleModule.with).toBe('function');
-	});
-
-	it('provides connections, the default alias and the schema strategy by default', async () => {
-		app = await Application.testing({
-			modules: [DrizzleModule.with({ default: 'main', connections: { main: { connection: URL } } })],
-			boot: 'eager'
-		});
-
-		expect(Database.connectionExists('main')).toBe(true);
-		expect(Database.connectionExists('default')).toBe(true);
-		const main = Database.getConnection('main');
-		expect(main).toBeDefined();
-		expect(Database.getConnection()).toBe(main);
-		expect(getTenancyConfig()).toEqual({ mode: 'schema' });
-		expect(getTenancyStrategy()).toBeInstanceOf(DrizzleSchemaTenancy);
-	});
-
-	it('uses the RLS strategy when tenancy mode is rls', async () => {
-		app = await Application.testing({
-			modules: [
-				DrizzleModule.with({
-					connections: { default: { connection: URL } },
-					tenancy: { mode: 'rls' }
-				})
-			],
-			boot: 'eager'
-		});
-
-		expect(getTenancyConfig()).toEqual({ mode: 'rls' });
-		expect(getTenancyStrategy()).toBeInstanceOf(DrizzleRLSTenancy);
-	});
-
-	it('rejects a default that is not a declared connection', async () => {
-		await expect(
-			Application.testing({
-				modules: [DrizzleModule.with({ default: 'nope', connections: { main: { connection: URL } } })]
-			})
-		).rejects.toThrow(/nope/);
-	});
-
-	it('builds a connection with a cache on a lazy boot', async () => {
-		app = await Application.testing({
-			modules: [
-				DrizzleModule.with({
-					connections: { default: { connection: URL, cache: { storage: 'memory' } } }
-				})
-			],
-			boot: 'lazy'
-		});
-
-		expect(await app.get('db.connection.default')).toBeDefined();
-	});
-
-	it('resolves its cache storage on first use', async () => {
-		app = await Application.testing({
-			modules: [DrizzleModule.with({ connections: { default: { connection: URL } } })],
-			boot: 'eager'
-		});
-		const cache = new DrizzleDatabaseCache('all', 1, 'memory');
-		await cache.put('k', [1], ['t'], false);
-		expect(await cache.get('k')).toEqual([1]);
-	});
-
-	it('closes only the connections that were created', async () => {
-		const used = stubClient();
-		const unused = stubClient();
-		app = await Application.testing({
-			modules: [
-				DrizzleModule.with({
-					default: 'a',
-					connections: { a: { client: used as never }, b: { client: unused as never } }
-				})
-			],
-			boot: 'lazy'
-		});
-		await app.get('db.connection.default');
-
-		await app.shutdown();
-		app = undefined;
-
-		expect(used.close).toHaveBeenCalledTimes(1);
-		expect(unused.close).not.toHaveBeenCalled();
-	});
-});
-
-describe('migration commands', () => {
-	const originalExit = process.exit;
-	const originalStderr = process.stderr.write;
-	const originalStdout = process.stdout.write;
-	let errors = '';
-
-	beforeEach(() => {
-		errors = '';
-		process.exit = mock() as never;
-		process.stderr.write = mock((message: string) => {
-			errors += message;
-			return true;
-		}) as never;
-		process.stdout.write = mock(() => true) as never;
-	});
-
-	let started: Application | undefined;
-
-	afterEach(async () => {
-		await started?.kernel.shutdown();
-		started = undefined;
-		Service.clear();
-		process.exit = originalExit;
-		process.stderr.write = originalStderr;
-		process.stdout.write = originalStdout;
-		for (const signal of ['SIGINT', 'SIGTERM'] as const) process.removeAllListeners(signal);
-	});
-
-	const makeApp = () => {
-		const client = stubClient();
-		@Application.register({
-			modules: [
-				DrizzleModule.with({ connections: { default: { client: client as never } } })
-			]
-		})
-		class TestApp extends Application {}
-		const app = new TestApp();
-		started = app;
-		return { app, client };
-	};
-
-	it('migration:run finds db.connection.default', async () => {
-		const { app, client } = makeApp();
-		await app.run(['migration:run', '--tenant', 'public']);
-
-		expect(errors).not.toContain('does not exist');
-		expect(client.connect).toHaveBeenCalled();
-		expect(client.begin).toHaveBeenCalled();
-		expect(Database.connectionExists('default')).toBe(true);
-	});
-
-	it('lists the migration commands under NODE_ENV=production', async () => {
-		const previous = Bun.env.NODE_ENV;
-		Bun.env.NODE_ENV = 'production';
-		try {
-			const { app } = makeApp();
-			await app.run(['list']);
-			const names = (app.kernel.graph.collect('commands') as { item: { command: string } }[]).map(
-				({ item }) => item.command
-			);
-			expect(names).toContain('migration:run');
-			expect(names).toContain('migration:generate');
-		} finally {
-			Bun.env.NODE_ENV = previous;
-		}
-	});
-});