@elysiumjs/mnemosyne-drizzle 0.2.0 → 0.4.0

package/tests/model.test.ts

@@ -1,362 +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 { afterAll, afterEach, beforeAll, describe, expect, it, jest, mock, spyOn } from 'bun:test';
-import * as d from 'drizzle-orm/pg-core';
-import { t } from 'elysia';
-
-import { Application } from '@elysiumjs/core';
-
-import { createSchemaFromDrizzle, drizzleAdapter, DrizzleModel } from '../src/model';
-import { pgTable } from '../src/table';
-import * as Tenancy from '../src/tenancy';
-
-// ============================================================================
-// Test Fixtures
-// ============================================================================
-
-const mockColumns = {
-	id: d.uuid().primaryKey().defaultRandom(),
-	name: d.varchar().notNull(),
-	age: d.integer().notNull(),
-	email: d.varchar().notNull().unique(),
-	is_confirmed: d.boolean().default(false)
-};
-
-const mockTable = d.pgTable('users', mockColumns);
-
-const enhancedMockTable = pgTable('enhanced_users', mockColumns);
-
-const mockStore = new Map([['tenant', 'test-tenant']]);
-const mockGetStore = mock(() => mockStore);
-
-// ============================================================================
-// Mock Application context
-// ============================================================================
-
-beforeAll(() => {
-	Object.defineProperty(Application, 'context', {
-		get: () => ({
-			getStore: mockGetStore,
-			run: mock((_: any, callback: any) => callback())
-		}),
-		configurable: true
-	});
-});
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('DrizzleModel', () => {
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	afterAll(() => {
-		mock.restore();
-	});
-
-	describe('drizzleAdapter', () => {
-		describe('getTableName', () => {
-			it('should return the table name', () => {
-				const name = drizzleAdapter.getTableName(mockTable);
-				expect(name).toBe('users');
-			});
-		});
-
-		describe('getColumns', () => {
-			it('should return normalized column metadata', () => {
-				const columns = drizzleAdapter.getColumns(mockTable);
-
-				expect(columns).toBeArrayOfSize(5);
-
-				const idCol = columns.find(c => c.name === 'id');
-				expect(idCol).toBeDefined();
-				expect(idCol!.dataType).toBe('uuid');
-				expect(idCol!.isPrimaryKey).toBe(true);
-				expect(idCol!.hasDefault).toBe(true);
-				expect(idCol!.nullable).toBe(false);
-
-				const nameCol = columns.find(c => c.name === 'name');
-				expect(nameCol).toBeDefined();
-				expect(nameCol!.dataType).toBe('string');
-				expect(nameCol!.nullable).toBe(false);
-				expect(nameCol!.hasDefault).toBe(false);
-
-				const ageCol = columns.find(c => c.name === 'age');
-				expect(ageCol).toBeDefined();
-				expect(ageCol!.dataType).toBe('number');
-
-				const confirmedCol = columns.find(c => c.name === 'is_confirmed');
-				expect(confirmedCol).toBeDefined();
-				expect(confirmedCol!.dataType).toBe('boolean');
-				expect(confirmedCol!.hasDefault).toBe(true);
-			});
-		});
-
-		describe('createTenantTable', () => {
-			it('should create a tenant-scoped table when column builders are registered', () => {
-				// Use enhanced pgTable which auto-registers builders
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					name: d.varchar().notNull()
-				};
-				const table = pgTable('items', cols);
-
-				const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-				const tenantTable = drizzleAdapter.createTenantTable(table, 'tenant-abc');
-
-				expect(pgSchemaSpy).toHaveBeenCalledWith('tenant-abc');
-				expect(tenantTable).toBeDefined();
-			});
-
-			it('should create a public table for the public tenant', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					name: d.varchar().notNull()
-				};
-				const table = pgTable('items_public', cols);
-
-				const pgTableSpy = spyOn(d, 'pgTable');
-
-				const publicTable = drizzleAdapter.createTenantTable(table, 'public');
-
-				expect(pgTableSpy).toHaveBeenCalledWith('items_public', cols);
-				expect(publicTable).toBeDefined();
-			});
-
-			it('should throw if column builders are not registered', () => {
-				const unregisteredTable = d.pgTable('orphan', {
-					id: d.uuid().primaryKey()
-				});
-
-				expect(() => {
-					drizzleAdapter.createTenantTable(unregisteredTable, 'some-tenant');
-				}).toThrow('No column builders registered');
-			});
-		});
-	});
-
-	describe('createSchemaFromDrizzle', () => {
-		it('should create a schema for select mode', () => {
-			const getTableConfigSpy = spyOn(d, 'getTableConfig');
-			const objectSpy = spyOn(t, 'Object');
-
-			createSchemaFromDrizzle(mockTable, { mode: 'select' });
-
-			expect(getTableConfigSpy).toHaveBeenCalledWith(mockTable);
-			expect(objectSpy).toHaveBeenCalledWith(
-				expect.objectContaining({
-					id: expect.any(Object),
-					name: expect.any(Object),
-					email: expect.any(Object),
-					age: expect.any(Object),
-					is_confirmed: expect.any(Object)
-				})
-			);
-
-			objectSpy.mockRestore();
-		});
-
-		it('should create a schema for create mode', () => {
-			const getTableConfigSpy = spyOn(d, 'getTableConfig');
-			const objectSpy = spyOn(t, 'Object');
-
-			createSchemaFromDrizzle(mockTable, { mode: 'create' });
-
-			expect(getTableConfigSpy).toHaveBeenCalledWith(mockTable);
-
-			// Primary key should be excluded in create mode
-			expect(objectSpy).toHaveBeenCalledWith(
-				expect.objectContaining({
-					name: expect.any(Object),
-					email: expect.any(Object),
-					age: expect.any(Object),
-					is_confirmed: expect.any(Object)
-				})
-			);
-
-			expect(objectSpy).not.toHaveBeenCalledWith(
-				expect.objectContaining({
-					id: expect.any(Object)
-				})
-			);
-
-			objectSpy.mockRestore();
-		});
-
-		it('should create a schema for update mode', () => {
-			const getTableConfigSpy = spyOn(d, 'getTableConfig');
-			const objectSpy = spyOn(t, 'Object');
-
-			createSchemaFromDrizzle(mockTable, { mode: 'update' });
-
-			expect(getTableConfigSpy).toHaveBeenCalledWith(mockTable);
-
-			// Primary key should be excluded in update mode
-			expect(objectSpy).toHaveBeenCalledWith(
-				expect.objectContaining({
-					name: expect.any(Object),
-					email: expect.any(Object),
-					age: expect.any(Object),
-					is_confirmed: expect.any(Object)
-				})
-			);
-
-			expect(objectSpy).not.toHaveBeenCalledWith(
-				expect.objectContaining({
-					id: expect.any(Object)
-				})
-			);
-
-			objectSpy.mockRestore();
-		});
-	});
-
-	describe('DrizzleModel with pgTable', () => {
-		describe('single signature API', () => {
-			it('should accept a pgTable directly', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					title: d.varchar().notNull()
-				};
-				const posts = pgTable('posts', cols);
-
-				class Post extends DrizzleModel(posts) {}
-
-				expect(Post.tableName).toBe('posts');
-				expect(Post.table).toBeDefined();
-				expect(Post.insertSchema).toBeDefined();
-				expect(Post.updateSchema).toBeDefined();
-				expect(Post.selectSchema).toBeDefined();
-			});
-
-			it('should support supportTenancy option', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					name: d.varchar().notNull()
-				};
-				const tenants = pgTable('tenants', cols);
-
-				class Tenant extends DrizzleModel(tenants, { supportTenancy: true }) {}
-
-				expect(Tenant.supportTenancy).toBe(true);
-			});
-
-			it('should default supportTenancy to false', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom()
-				};
-				const items = pgTable('items', cols);
-
-				class Item extends DrizzleModel(items) {}
-
-				expect(Item.supportTenancy).toBe(false);
-			});
-
-			it('should infer types from the table', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					email: d.varchar().notNull(),
-					age: d.integer()
-				};
-				const users = pgTable('typed_users', cols);
-
-				class TypedUser extends DrizzleModel(users) {}
-
-				// Type inference markers
-				expect(TypedUser.$inferSelect).toBeUndefined();
-				expect(TypedUser.$inferInsert).toBeUndefined();
-				expect(TypedUser.$inferUpdate).toBeUndefined();
-			});
-		});
-
-		describe('tenancy with pgTable', () => {
-			it('should create tenant table when tenancy is enabled', () => {
-				const cols = {
-					id: d.uuid().primaryKey().defaultRandom(),
-					data: d.varchar().notNull()
-				};
-				const tenantData = pgTable('tenant_data', cols);
-
-				class TenantData extends DrizzleModel(tenantData, { supportTenancy: true }) {}
-
-				// Should not throw when accessing table
-				expect(TenantData.table).toBeDefined();
-			});
-		});
-	});
-
-	describe('Tenancy', () => {
-		it('should register a new tenant schema', () => {
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			const schema = Tenancy.registerTenantSchema('new-tenant');
-
-			expect(pgSchemaSpy).toHaveBeenCalledWith('new-tenant');
-			expect(schema).toBeDefined();
-		});
-
-		it('should wrap columns with a tenant schema', () => {
-			const pgTableSpy = spyOn(d, 'pgTable');
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom(),
-				name: d.varchar().notNull()
-			};
-
-			// Call the function with a non-public tenant
-			const table = Tenancy.wrapTenantSchema('wrap-test-tenant', 'items', cols);
-
-			expect(pgSchemaSpy).toHaveBeenCalledWith('wrap-test-tenant');
-			expect(table).toBeDefined();
-
-			// Call the function with the public tenant
-			const publicTable = Tenancy.wrapTenantSchema('public', 'items', cols);
-
-			expect(pgTableSpy).toHaveBeenCalledWith('items', cols);
-			expect(publicTable).toBeDefined();
-		});
-
-		it('should reuse existing tenant schemas', () => {
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			Tenancy.registerTenantSchema('existing-tenant');
-			pgSchemaSpy.mockClear();
-
-			const schema = Tenancy.registerTenantSchema('existing-tenant');
-
-			expect(pgSchemaSpy).not.toHaveBeenCalled();
-			expect(schema).toBeDefined();
-		});
-
-		it('should reuse existing tenant tables', () => {
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom()
-			};
-
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			Tenancy.wrapTenantSchema('cache-tenant', 'cached_items', cols);
-			pgSchemaSpy.mockClear();
-
-			Tenancy.wrapTenantSchema('cache-tenant', 'cached_items', cols);
-
-			expect(pgSchemaSpy).not.toHaveBeenCalled();
-		});
-	});
-});

package/tests/table.test.ts

@@ -1,72 +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 { describe, expect, it } from 'bun:test';
-import * as d from 'drizzle-orm/pg-core';
-
-import { getTableBuilders, pgTable } from '../src/table';
-
-describe('pgTable', () => {
-	describe('table creation', () => {
-		it('should create a table with the same signature as drizzle pgTable', () => {
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom(),
-				name: d.varchar().notNull()
-			};
-
-			const table = pgTable('users', cols);
-
-			expect(table).toBeDefined();
-			expect(table).toHaveProperty('id');
-			expect(table).toHaveProperty('name');
-		});
-
-		it('should support extraConfig parameter', () => {
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom()
-			};
-
-			const table = pgTable('items', cols, (t) => ({
-				unique: t.unique().on(t.id)
-			}));
-
-			expect(table).toBeDefined();
-		});
-	});
-
-	describe('column builder registry', () => {
-		it('should register column builders for created tables', () => {
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom(),
-				email: d.varchar().notNull()
-			};
-
-			const table = pgTable('registered', cols);
-			const builders = getTableBuilders(table);
-
-			expect(builders).toBeDefined();
-			expect(builders).toHaveProperty('id');
-			expect(builders).toHaveProperty('email');
-		});
-
-		it('should return undefined for tables not created with enhanced pgTable', () => {
-			const rawTable = d.pgTable('raw', {
-				id: d.uuid().primaryKey()
-			});
-
-			const builders = getTableBuilders(rawTable);
-			expect(builders).toBeUndefined();
-		});
-	});
-});

package/tests/tenancy.test.ts

@@ -1,212 +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 { afterAll, afterEach, beforeAll, describe, expect, it, jest, mock, spyOn } from 'bun:test';
-import * as d from 'drizzle-orm/pg-core';
-
-import { Application, Service } from '@elysiumjs/core';
-
-import { Database } from '../src/database';
-import { DrizzleModel } from '../src/model';
-import { pgTable } from '../src/table';
-import {
-	createRLSPolicy,
-	DrizzleRLSTenancy,
-	DrizzleSchemaTenancy,
-	getTenantSchema,
-	registerTenantSchema,
-	wrapTenantSchema
-} from '../src/tenancy';
-
-// ============================================================================
-// Mock setup
-// ============================================================================
-
-mock.module('drizzle-orm/bun-sql', () => ({
-	drizzle: mock(() => ({ mockDrizzleInstance: true }))
-}));
-
-beforeAll(() => {
-	const mockContext = {
-		getStore: mock(() => new Map()),
-		run: mock((_: any, callback: any) => callback())
-	};
-	Object.defineProperty(Application, 'context', {
-		get: () => mockContext,
-		configurable: true
-	});
-});
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('Tenancy', () => {
-	afterEach(() => {
-		jest.clearAllMocks();
-	});
-
-	afterAll(() => {
-		mock.restore();
-	});
-
-	describe('getTenantSchema', () => {
-		it('should return a PgSchema for the tenant', () => {
-			const schema = getTenantSchema('schema-test-tenant');
-			expect(schema).toBeDefined();
-			expect(schema.schemaName).toBe('schema-test-tenant');
-		});
-
-		it('should return the same schema for the same tenant', () => {
-			const schema1 = getTenantSchema('reuse-schema-tenant');
-			const schema2 = getTenantSchema('reuse-schema-tenant');
-			expect(schema1).toBe(schema2);
-		});
-	});
-
-	describe('registerTenantSchema', () => {
-		it('should register and return a new tenant schema', () => {
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			const schema = registerTenantSchema('register-tenant');
-
-			expect(pgSchemaSpy).toHaveBeenCalledWith('register-tenant');
-			expect(schema).toBeDefined();
-		});
-
-		it('should not re-register existing tenant schemas', () => {
-			const pgSchemaSpy = spyOn(d, 'pgSchema');
-
-			registerTenantSchema('already-registered');
-			pgSchemaSpy.mockClear();
-
-			const schema = registerTenantSchema('already-registered');
-
-			expect(pgSchemaSpy).not.toHaveBeenCalled();
-			expect(schema).toBeDefined();
-		});
-	});
-
-	describe('wrapTenantSchema', () => {
-		it('should return a regular pgTable for the public tenant', () => {
-			const pgTableSpy = spyOn(d, 'pgTable');
-			const cols = { id: d.uuid().primaryKey().defaultRandom() };
-
-			const table = wrapTenantSchema('public', 'wrap_public', cols);
-
-			expect(pgTableSpy).toHaveBeenCalledWith('wrap_public', cols);
-			expect(table).toBeDefined();
-		});
-
-		it('should return a schema-qualified table for non-public tenants', () => {
-			const cols = { id: d.uuid().primaryKey().defaultRandom() };
-
-			const table = wrapTenantSchema('tenant-wrap', 'wrap_test', cols);
-
-			expect(table).toBeDefined();
-		});
-
-		it('should cache tenant tables', () => {
-			const cols = { id: d.uuid().primaryKey().defaultRandom() };
-
-			const table1 = wrapTenantSchema('cached-wrap', 'cache_wrap_test', cols);
-			const table2 = wrapTenantSchema('cached-wrap', 'cache_wrap_test', cols);
-
-			expect(table1).toBe(table2);
-		});
-	});
-
-	describe('DrizzleSchemaTenancy', () => {
-		it('should have mode set to schema', () => {
-			const strategy = new DrizzleSchemaTenancy();
-			expect(strategy.mode).toBe('schema');
-		});
-
-		it('should resolve a table to a tenant-scoped table', () => {
-			const cols = {
-				id: d.uuid().primaryKey().defaultRandom(),
-				name: d.varchar().notNull()
-			};
-			const table = pgTable('schema_strategy_test', cols);
-
-			const strategy = new DrizzleSchemaTenancy();
-			const resolved = strategy.resolveTable(table, 'strategy-tenant');
-
-			expect(resolved).toBeDefined();
-			expect(resolved).not.toBe(table);
-		});
-
-		it('should pass through callback in withIsolation', async () => {
-			const strategy = new DrizzleSchemaTenancy();
-			const result = await strategy.withIsolation(null, 'tenant', async () => 'test-result');
-			expect(result).toBe('test-result');
-		});
-	});
-
-	describe('DrizzleRLSTenancy', () => {
-		it('should have mode set to rls', () => {
-			const strategy = new DrizzleRLSTenancy();
-			expect(strategy.mode).toBe('rls');
-		});
-
-		it('should return the same table in resolveTable', () => {
-			const table = d.pgTable('rls_test', {
-				id: d.uuid().primaryKey().defaultRandom()
-			});
-
-			const strategy = new DrizzleRLSTenancy();
-			const resolved = strategy.resolveTable(table, 'any-tenant');
-
-			expect(resolved).toBe(table);
-		});
-
-		it('should wrap callback in a transaction with set_config', async () => {
-			const mockTx = {
-				execute: mock(() => Promise.resolve())
-			};
-			const mockConnection = {
-				transaction: mock(async (fn: any) => fn(mockTx))
-			};
-
-			const strategy = new DrizzleRLSTenancy();
-			const result = await strategy.withIsolation(
-				mockConnection,
-				'rls-tenant',
-				async () => 'rls-result'
-			);
-
-			expect(mockConnection.transaction).toHaveBeenCalled();
-			expect(mockTx.execute).toHaveBeenCalled();
-			expect(result).toBe('rls-result');
-		});
-	});
-
-	describe('createRLSPolicy', () => {
-		it('should create an RLS policy with default settings', () => {
-			const policy = createRLSPolicy('users');
-
-			expect(policy).toBeDefined();
-			expect(policy.name).toBe('users_tenant_isolation');
-			expect(policy.for).toBe('all');
-			expect(policy.to).toBe('public');
-		});
-
-		it('should create an RLS policy with custom column and policy name', () => {
-			const policy = createRLSPolicy('orders', 'org_id', 'orders_org_policy');
-
-			expect(policy).toBeDefined();
-			expect(policy.name).toBe('orders_org_policy');
-		});
-	});
-});

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-	"extends": "../../tsconfig.base.json",
-	"compilerOptions": {
-		"outDir": "dist",
-		"declaration": true,
-		"declarationMap": false,
-		"declarationDir": "dist",
-		"rootDir": "src",
-		"allowImportingTsExtensions": false
-	},
-	"include": ["src"]
-}