@elysiumjs/mnemosyne 0.1.2 → 0.2.0

package/src/mnemosyne.module.ts

@@ -0,0 +1,83 @@
+// 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 { ServiceFactoryDefinition } from '@elysiumjs/core';
+
+import { Module } from '@elysiumjs/core';
+import { KeyvCacheableMemory } from 'cacheable';
+
+import { makeCacheInterface, MEMORY_CACHE_SERVICE, REDIS_CACHE_SERVICE } from './cache';
+import { KeyvRedis } from './keyv-redis';
+
+/**
+ * Configuration of the {@link MnemosyneModule}.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export type MnemosyneModuleConfig = {
+	cache: {
+		/** The Redis-backed cache. Set to `false` to not provide `Cache.redis`. */
+		redis?:
+			| {
+					/** The name of the Redis connection to use. */
+					connection: string;
+			  }
+			| false;
+
+		/** The memory cache. Set to `false` to not provide `Cache.memory`. */
+		memory?:
+			| {
+					/** The default TTL of entries, in milliseconds. */
+					ttl: number;
+
+					/** The maximum number of entries kept. */
+					lruSize: number;
+			  }
+			| false;
+	};
+};
+
+/**
+ * Provides the caches as the global services `mnemosyne.cache.redis` and
+ * `mnemosyne.cache.memory`. Tenancy config and strategy, and database connections, are
+ * registered by the database driver modules.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+@Module.register<MnemosyneModuleConfig>({
+	services: (config) => {
+		const services: ServiceFactoryDefinition[] = [];
+		const { redis, memory } = config.cache;
+
+		if (redis) {
+			services.push({
+				name: REDIS_CACHE_SERVICE,
+				global: true,
+				factory: () => makeCacheInterface(new KeyvRedis({ connection: redis.connection }))
+			});
+		}
+
+		if (memory) {
+			services.push({
+				name: MEMORY_CACHE_SERVICE,
+				global: true,
+				factory: () =>
+					makeCacheInterface(new KeyvCacheableMemory({ ttl: memory.ttl, lruSize: memory.lruSize }))
+			});
+		}
+
+		return services;
+	}
+})
+export class MnemosyneModule extends Module.configurable<MnemosyneModuleConfig>({
+	defaults: { cache: { redis: { connection: 'cache' }, memory: { ttl: 60000, lruSize: 5000 } } }
+}) {}

package/src/tenancy.ts

@@ -15,7 +15,7 @@
 import type { Context } from '@elysiumjs/core';
 import type { TenancyStrategy } from './interfaces';
 
-import { Application, Middleware } from '@elysiumjs/core';
+import { Application, Middleware, Service } from '@elysiumjs/core';
 
 // ============================================================================
 // Types
@@ -95,53 +95,36 @@ export interface ModelTenancyConfig {
 }
 
 // ============================================================================
-// Internal State
+// Configuration
 // ============================================================================
 
-let _strategy: TenancyStrategy<unknown, unknown> | null = null;
+/** Name of the global service holding the {@link TenancyConfig}, registered by driver modules. */
+export const TENANCY_CONFIG_SERVICE = 'mnemosyne.tenancy.config';
 
-// ============================================================================
-// Configuration
-// ============================================================================
+/** Name of the global service holding the {@link TenancyStrategy}, registered by driver modules. */
+export const TENANCY_STRATEGY_SERVICE = 'mnemosyne.tenancy.strategy';
 
 /**
  * Gets the current global tenancy configuration.
  *
- * Reads from the 'elysium:mnemosyne' app config key. Returns a default
- * configuration if the app is not yet initialized or no tenancy config is set.
+ * Reads the global service `mnemosyne.tenancy.config`. Returns a default
+ * configuration if none is registered.
  *
  * @author Axel Nana <axel.nana@workbud.com>
  * @returns The current tenancy configuration.
  */
 export const getTenancyConfig = (): TenancyConfig => {
-	const app = Application.instance;
-	if (!app) {
-		return { mode: 'schema' };
-	}
-	const config = app.getConfig<{ tenancy?: TenancyConfig }>('elysium:mnemosyne' as any);
-	return config?.tenancy ?? { mode: 'schema' };
-};
-
-// ============================================================================
-// Strategy Registry
-// ============================================================================
-
-/**
- * Registers the tenancy strategy to use for table resolution and isolation.
- * @author Axel Nana <axel.nana@workbud.com>
- * @param strategy The tenancy strategy to register.
- */
-export const registerTenancyStrategy = (strategy: TenancyStrategy<unknown, unknown>): void => {
-	_strategy = strategy;
+	return Service.get<TenancyConfig>(TENANCY_CONFIG_SERVICE) ?? { mode: 'schema' };
 };
 
 /**
- * Gets the currently registered tenancy strategy.
+ * Gets the tenancy strategy registered by the driver module as the global service
+ * `mnemosyne.tenancy.strategy`.
  * @author Axel Nana <axel.nana@workbud.com>
  * @returns The current tenancy strategy, or `null` if none is registered.
  */
 export const getTenancyStrategy = (): TenancyStrategy<unknown, unknown> | null => {
-	return _strategy;
+	return Service.get<TenancyStrategy<unknown, unknown>>(TENANCY_STRATEGY_SERVICE);
 };
 
 // ============================================================================

package/tests/cache.test.ts

@@ -14,21 +14,63 @@
 
 import type { Mock } from 'bun:test';
 
+import { Application, RedisModule } from '@elysiumjs/core';
 import { afterAll, beforeAll, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test';
 import { createCache } from 'cache-manager';
 import * as KV from 'keyv';
 
-import { Event, Redis } from '@elysiumjs/core';
-
-import { Cache } from '../src/cache';
+import { Cache, MnemosyneModule } from '../src';
 
 // Mock dependencies
 mock.module('cache-manager', () => ({
 	createCache: mock(createCache)
 }));
 
-Redis.registerConnection('cache', {
-	url: process.env.REDIS_TEST_URL!
+// A minimal in-memory stand-in for Bun.RedisClient
+const data = new Map<string, string>();
+const originalRedisClient = Bun.RedisClient;
+const RedisClientFake = mock(function () {
+	return {
+		close: mock(),
+		get: async (k: string) => data.get(k) ?? null,
+		set: async (k: string, v: string) => {
+			data.set(k, v);
+			return 'OK';
+		},
+		del: async (k: string) => Number(data.delete(k)),
+		exists: async (k: string) => data.has(k),
+		mget: async (...keys: string[]) => keys.map((k) => data.get(k) ?? null),
+		send: async (cmd: string, args: string[]) => {
+			if (cmd === 'UNLINK') return Number(data.delete(args[0]));
+			if (cmd === 'SCAN') return ['0', [...data.keys()]];
+			if (cmd === 'FLUSHDB') return data.clear();
+			return null;
+		}
+	};
+}) as unknown as typeof Bun.RedisClient;
+
+let app: Awaited<ReturnType<typeof Application.testing>>;
+
+beforeAll(async () => {
+	Bun.RedisClient = RedisClientFake;
+	app = await Application.testing({
+		modules: [
+			RedisModule.with({
+				default: 'cache',
+				connections: { cache: { url: 'redis://cache:6379' } }
+			}),
+			MnemosyneModule
+		]
+	});
+	await app.get('mnemosyne.cache.redis');
+	await app.get('mnemosyne.cache.memory');
+});
+
+afterAll(async () => {
+	// Some tests spy on Keyv without restoring it
+	mock.restore();
+	await app.shutdown();
+	Bun.RedisClient = originalRedisClient;
 });
 
 // Test the weak cache
@@ -82,9 +124,8 @@ describe('Cache.weak', () => {
 
 // Test the Redis cache
 describe('Cache.redis', () => {
-	beforeAll(() => {
-		Cache.redis.clear();
-		Event.emit('elysium:app:launched', null, null);
+	beforeAll(async () => {
+		await Cache.redis.clear();
 	});
 
 	// Reset mocks before each test
@@ -109,7 +150,7 @@ describe('Cache.redis', () => {
 		expect(getSpy).toHaveBeenCalledWith('test-key');
 
 		// Check if the result is correct
-		expect(result).toBeNull();
+		expect(result).toBeUndefined();
 	});
 
 	it('should call set method with the correct parameters', async () => {
@@ -443,7 +484,7 @@ describe('Cache namespacing and tagging', () => {
 		Cache.memory.tags('tag1', 'tag2', 'tag3');
 
 		// Check if Keyv was instantiated with the correct namespace
-		expect(keyvSpy).toHaveBeenLastCalledWith(
+		expect(keyvSpy).toHaveBeenCalledWith(
 			expect.objectContaining({
 				namespace: 'cache__tag1__tag2__tag3'
 			})

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 });
 		});
 	});