@elysiumjs/mnemosyne 0.1.0 → 0.2.0

package/tests/database.test.ts

@@ -12,16 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { afterEach, beforeEach, describe, expect, it, jest, mock, spyOn } from 'bun:test';
-
-import { Application, Service } from '@elysiumjs/core';
+import { Application, Service, ServiceNotFoundError } from '@elysiumjs/core';
+import { afterEach, describe, expect, it, jest, mock, spyOn } from 'bun:test';
 
 import { AbstractDatabase } from '../src/database';
 
 const mockDriver = {
 	createConnection: mock((config: any) => ({ mockConnection: true, config })),
 	withTransaction: mock((conn: any, cb: any) => cb(conn)),
-	getRawClient: mock((conn: any) => ({ rawClient: true })),
+	getRawClient: mock((_conn: any) => ({ rawClient: true }))
 };
 
 class TestDatabase extends AbstractDatabase<any, any> {
@@ -29,220 +28,85 @@ class TestDatabase extends AbstractDatabase<any, any> {
 }
 
 describe('AbstractDatabase', () => {
-	// Mock console.error and process.exit to prevent actual console output and process exit
-	const originalConsoleError = console.error;
-	const originalProcessExit = process.exit;
-
-	beforeEach(() => {
-		console.error = mock();
-		process.exit = mock() as any;
-	});
-
 	afterEach(() => {
-		console.error = originalConsoleError;
-		process.exit = originalProcessExit;
+		jest.restoreAllMocks();
 		jest.clearAllMocks();
 	});
 
-	describe('registerConnection', () => {
-		it('should register a new connection', () => {
-			const db = new TestDatabase();
-
-			// Mock Service.exists to return false (connection doesn't exist)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
-			const instanceSpy = spyOn(Service, 'instance');
-
-			// Call the function
-			const result = db.registerConnection('test', { connection: 'sqlite:test.db' });
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the driver's createConnection was called with the config
-			expect(mockDriver.createConnection).toHaveBeenCalledWith({ connection: 'sqlite:test.db' });
-
-			// Check if Service.instance was called with the correct parameters
-			expect(instanceSpy).toHaveBeenCalledWith('db.connection.test', {
-				mockConnection: true,
-				config: { connection: 'sqlite:test.db' }
-			});
-		});
-
-		it('should throw an error if the connection already exists', () => {
-			const db = new TestDatabase();
-
-			// Mock Service.exists to return true (connection exists)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Call the function
-			db.registerConnection('test', { connection: 'sqlite:test.db' });
-
-			// Check if console.error and process.exit were called
-			expect(console.error).toHaveBeenCalledWith(
-				expect.stringContaining('A connection with the name test has already been registered')
-			);
-			expect(process.exit).toHaveBeenCalledWith(1);
-		});
-	});
-
 	describe('getConnection', () => {
 		it('should retrieve an existing connection', () => {
-			const db = new TestDatabase();
-
-			// Mock Service.exists to return true (connection exists)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Mock Service.get to return a mock connection
 			const mockConnection = { mockConnection: true };
 			const getSpy = spyOn(Service, 'get').mockReturnValue(mockConnection);
 
-			// Call the function
-			const result = db.getConnection('test');
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
+			const result = new TestDatabase().getConnection('test');
 
-			// Check if Service.get was called with the correct connection name
 			expect(getSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
+			expect(result).toBe(mockConnection);
 		});
 
-		it('should throw an error if the connection does not exist', () => {
-			const db = new TestDatabase();
+		it('should throw ServiceNotFoundError if the connection does not exist', () => {
+			spyOn(Service, 'get').mockReturnValue(null);
 
-			// Mock Service.exists to return false (connection doesn't exist)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
+			expect(() => new TestDatabase().getConnection('test')).toThrow(ServiceNotFoundError);
+		});
 
-			// Call the function
-			db.getConnection('test');
+		it('should return the transaction handle for the default connection', () => {
+			const tx = { tx: true };
+			const originalDescriptor = Object.getOwnPropertyDescriptor(Application, 'context');
+			Object.defineProperty(Application, 'context', {
+				get: () => ({ getStore: () => new Map([['db:tx', tx]]) }),
+				configurable: true
+			});
 
-			// Check if console.error and process.exit were called
-			expect(console.error).toHaveBeenCalledWith(
-				expect.stringContaining('No connection with name test found')
-			);
-			expect(process.exit).toHaveBeenCalledWith(1);
+			try {
+				expect(new TestDatabase().getConnection()).toBe(tx);
+			} finally {
+				if (originalDescriptor) Object.defineProperty(Application, 'context', originalDescriptor);
+			}
 		});
 	});
 
 	describe('connectionExists', () => {
-		it('should return true if the connection exists', () => {
-			const db = new TestDatabase();
-
-			// Mock Service.exists to return true
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(true);
-
-			// Call the function
-			const result = db.connectionExists('test');
-
-			// Check if Service.exists was called with the correct connection name
-			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result).toBe(true);
-		});
-
-		it('should return false if the connection does not exist', () => {
+		it('should delegate to Service.exists', () => {
+			const existsSpy = spyOn(Service, 'exists')
+				.mockReturnValueOnce(true)
+				.mockReturnValueOnce(false);
 			const db = new TestDatabase();
 
-			// Mock Service.exists to return false
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
-
-			// Call the function
-			const result = db.connectionExists('test');
-
-			// Check if Service.exists was called with the correct connection name
+			expect(db.connectionExists('test')).toBe(true);
+			expect(db.connectionExists('test')).toBe(false);
 			expect(existsSpy).toHaveBeenCalledWith('db.connection.test');
-
-			// Check if the result is correct
-			expect(result).toBe(false);
 		});
 	});
 
 	describe('getDefaultConnection', () => {
 		it('should retrieve the default connection', () => {
-			const db = new TestDatabase();
-
-			// Save original descriptor and mock Application.context
-			const originalDescriptor = Object.getOwnPropertyDescriptor(Application, 'context');
-			Object.defineProperty(Application, 'context', {
-				get: () => ({ getStore: () => null }),
-				configurable: true,
-			});
-
-			// Mock Service.exists to return true and Service.get to return a mock connection
-			const mockConnection = { mockConnection: true };
-			spyOn(Service, 'exists').mockReturnValueOnce(true);
-			spyOn(Service, 'get').mockReturnValue(mockConnection);
-
-			// Call the function
-			const result = db.getDefaultConnection();
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-
-			// Restore original descriptor
-			if (originalDescriptor) {
-				Object.defineProperty(Application, 'context', originalDescriptor);
-			}
-		});
-	});
-
-	describe('setDefaultConnection', () => {
-		it('should set the default connection', () => {
-			const db = new TestDatabase();
-
-			// Save original descriptor and mock Application.context
 			const originalDescriptor = Object.getOwnPropertyDescriptor(Application, 'context');
 			Object.defineProperty(Application, 'context', {
 				get: () => ({ getStore: () => null }),
-				configurable: true,
+				configurable: true
 			});
 
-			const instanceSpy = spyOn(Service, 'instance');
-			const removeSpy = spyOn(Service, 'remove');
-
-			// Mock getConnection to return a mock connection
-			const mockConnection = { mockConnection: true };
-			spyOn(Service, 'exists').mockReturnValue(true);
-			spyOn(Service, 'get').mockReturnValue(mockConnection);
-
-			// Call the function
-			const result = db.setDefaultConnection('test');
-
-			// Check if Service.remove was called with the correct connection name
-			expect(removeSpy).toHaveBeenCalledWith('db.connection.default');
-
-			// Check if Service.instance was called with the correct parameters
-			expect(instanceSpy).toHaveBeenCalledWith('db.connection.default', mockConnection);
+			try {
+				const mockConnection = { mockConnection: true };
+				const getSpy = spyOn(Service, 'get').mockReturnValue(mockConnection);
 
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-
-			// Restore original descriptor
-			if (originalDescriptor) {
-				Object.defineProperty(Application, 'context', originalDescriptor);
+				expect(new TestDatabase().getDefaultConnection()).toBe(mockConnection);
+				expect(getSpy).toHaveBeenCalledWith('db.connection.default');
+			} finally {
+				if (originalDescriptor) Object.defineProperty(Application, 'context', originalDescriptor);
 			}
 		});
 	});
 
 	describe('getRawClient', () => {
 		it('should return the raw client from the driver', () => {
-			const db = new TestDatabase();
-
-			// Mock getConnection to return a mock connection
 			const mockConnection = { mockConnection: true };
-			spyOn(Service, 'exists').mockReturnValue(true);
 			spyOn(Service, 'get').mockReturnValue(mockConnection);
 
-			// Call the function
-			const result = db.getRawClient('test');
+			const result = new TestDatabase().getRawClient('test');
 
-			// Check if the driver's getRawClient was called with the connection
 			expect(mockDriver.getRawClient).toHaveBeenCalledWith(mockConnection);
-
-			// Check if the result is correct
 			expect(result).toEqual({ rawClient: true });
 		});
 	});

package/tests/mnemosyne.module.test.ts

@@ -0,0 +1,214 @@
+// 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 { TestingApp } from '@elysiumjs/core';
+
+import { Application, RedisModule, Service, ServiceNotFoundError } from '@elysiumjs/core';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test';
+
+import * as pkg from '../src';
+import { Cache, MnemosyneModule } from '../src';
+import { AbstractDatabase } from '../src/database';
+import { KeyvRedis } from '../src/keyv-redis';
+import { getTenancyConfig, getTenancyStrategy } from '../src/tenancy';
+
+const store = new Map<string, string>();
+const originalRedisClient = Bun.RedisClient;
+const ClientMock = mock(function (_url: string, _options?: object) {
+	return {
+		close: mock(),
+		get: mock(async (k: string) => store.get(k) ?? null),
+		set: mock(async (k: string, v: string) => {
+			store.set(k, v);
+			return 'OK';
+		})
+	};
+});
+beforeAll(() => {
+	Bun.RedisClient = ClientMock as unknown as typeof Bun.RedisClient;
+});
+
+afterAll(() => {
+	Bun.RedisClient = originalRedisClient;
+});
+
+const redis = RedisModule.with({
+	default: 'cache',
+	connections: { cache: { url: 'redis://cache:6379' } }
+});
+
+class TestDatabase extends AbstractDatabase<any, any> {
+	protected driver = {
+		createConnection: mock(),
+		withTransaction: mock(),
+		getRawClient: mock()
+	} as any;
+}
+
+describe('MnemosyneModule', () => {
+	let app: TestingApp | undefined;
+
+	beforeEach(() => {
+		store.clear();
+		ClientMock.mockClear();
+	});
+
+	afterEach(async () => {
+		await app?.shutdown();
+		app = undefined;
+	});
+
+	it('registers nothing on import', () => {
+		expect(Service.exists('mnemosyne.cache.redis')).toBe(false);
+		expect(Service.exists('mnemosyne.cache.memory')).toBe(false);
+		expect(() => Cache.redis).toThrow(ServiceNotFoundError);
+		expect(() => Cache.memory).toThrow(ServiceNotFoundError);
+	});
+
+	it('exports the module', () => {
+		expect(pkg.MnemosyneModule).toBe(MnemosyneModule);
+	});
+
+	it('serves Cache.redis without opening a client until first use', async () => {
+		app = await Application.testing({ modules: [redis, MnemosyneModule] });
+		await app.get('mnemosyne.cache.redis');
+		const cache = Cache.redis;
+		expect(cache).toBeDefined();
+		expect(ClientMock).not.toHaveBeenCalled();
+
+		await cache.set('a', 'b');
+		expect(ClientMock).toHaveBeenCalledTimes(1);
+		expect(await cache.get('a')).toBe('b');
+	});
+
+	it('resolves the redis client through the async path on a lazy boot', async () => {
+		app = await Application.testing({ modules: [redis, MnemosyneModule], boot: 'lazy' });
+		await app.get('mnemosyne.cache.redis');
+		expect(await Cache.redis.get('missing')).toBeUndefined();
+	});
+
+	it('uses the configured redis connection', async () => {
+		app = await Application.testing({
+			modules: [
+				RedisModule.with({
+					default: 'other',
+					connections: { other: { url: 'redis://other:6379' } }
+				}),
+				MnemosyneModule.with({ cache: { redis: { connection: 'other' } } })
+			]
+		});
+		await app.get('mnemosyne.cache.redis');
+		await Cache.redis.set('a', 'b');
+		expect(ClientMock).toHaveBeenCalledWith('redis://other:6379', {});
+	});
+
+	it('Cache.memory uses the configured TTL', async () => {
+		app = await Application.testing({
+			modules: [MnemosyneModule.with({ cache: { memory: { ttl: 40, lruSize: 10 } } })]
+		});
+		await app.get('mnemosyne.cache.memory');
+		await Cache.memory.set('k', 'v');
+		expect(await Cache.memory.get('k')).toBe('v');
+
+		await Bun.sleep(80);
+		expect(await Cache.memory.get('k')).toBeUndefined();
+	});
+
+	it('merges the defaults into a partial config', async () => {
+		app = await Application.testing({
+			modules: [MnemosyneModule.with({ cache: { memory: { ttl: 1000, lruSize: 10 } } })]
+		});
+		await app.get('mnemosyne.cache.memory');
+		expect(Service.exists('mnemosyne.cache.memory')).toBe(true);
+		expect(Service.exists('mnemosyne.cache.redis')).toBe(true);
+	});
+
+	it('registers no redis cache when it is set to false', async () => {
+		app = await Application.testing({
+			modules: [MnemosyneModule.with({ cache: { redis: false } })]
+		});
+		await app.get('mnemosyne.cache.memory');
+
+		expect(Service.exists('mnemosyne.cache.redis')).toBe(false);
+		expect(() => Cache.redis).toThrow(ServiceNotFoundError);
+		await Cache.memory.set('k', 'v');
+		expect(await Cache.memory.get('k')).toBe('v');
+	});
+
+	it('registers no memory cache when it is set to false', async () => {
+		app = await Application.testing({
+			modules: [redis, MnemosyneModule.with({ cache: { memory: false } })]
+		});
+		await app.get('mnemosyne.cache.redis');
+
+		expect(Service.exists('mnemosyne.cache.memory')).toBe(false);
+		expect(() => Cache.memory).toThrow(ServiceNotFoundError);
+	});
+
+	it('disconnect leaves the shared redis client open', async () => {
+		app = await Application.testing({ modules: [redis, MnemosyneModule] });
+		const client = (await app.get('redis.connection.cache')) as { close: ReturnType<typeof mock> };
+		const adapter = new KeyvRedis({ connection: 'cache' });
+
+		await adapter.set('a', 'b');
+		await adapter.disconnect();
+
+		expect(client.close).not.toHaveBeenCalled();
+		expect(ClientMock).toHaveBeenCalledTimes(1);
+		expect(await adapter.get('a')).toBe('b');
+	});
+
+	describe('tenancy', () => {
+		it('falls back to schema mode when no config is registered', async () => {
+			app = await Application.testing({ modules: [MnemosyneModule] });
+			expect(getTenancyConfig()).toEqual({ mode: 'schema' });
+			expect(getTenancyStrategy()).toBeNull();
+		});
+
+		it('reads the registered tenancy config', async () => {
+			app = await Application.testing({
+				modules: [MnemosyneModule],
+				overrides: { 'mnemosyne.tenancy.config': { mode: 'rls' } }
+			});
+			expect(getTenancyConfig()).toEqual({ mode: 'rls' });
+		});
+
+		it('reads the registered tenancy strategy', async () => {
+			const strategy = { name: 'test' };
+			app = await Application.testing({
+				modules: [MnemosyneModule],
+				overrides: { 'mnemosyne.tenancy.strategy': strategy }
+			});
+			expect(getTenancyStrategy()).toBe(strategy as any);
+		});
+	});
+
+	describe('AbstractDatabase', () => {
+		it('throws ServiceNotFoundError for a missing connection', async () => {
+			app = await Application.testing({ modules: [MnemosyneModule] });
+			expect(() => new TestDatabase().getConnection('missing')).toThrow(ServiceNotFoundError);
+		});
+
+		it('returns a registered connection', async () => {
+			const connection = { id: 1 };
+			app = await Application.testing({
+				modules: [MnemosyneModule],
+				overrides: { 'db.connection.main': connection }
+			});
+			const db = new TestDatabase();
+			expect(db.connectionExists('main')).toBe(true);
+			expect(db.getConnection('main')).toBe(connection);
+		});
+	});
+});

package/tests/setup.ts

@@ -11,16 +11,3 @@
 // 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 'reflect-metadata';
-
-import { mock } from 'bun:test';
-
-// Mock dependencies
-
-mock.module('node:async_hooks', () => ({
-	AsyncLocalStorage: class {
-		public run = mock((_map, callback) => callback());
-		public disable = mock();
-	}
-}));

package/.turbo/turbo-typecheck.log

@@ -1 +0,0 @@
-$ tsc --noEmit