@elysiumjs/mnemosyne 0.1.0 → 0.2.0

package/src/index.ts

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type { TenancyConfig } from './tenancy';
-
 export type {
 	ColumnMetadata,
 	DatabaseCacheConfig,
@@ -27,31 +25,13 @@ export type {
 	TenancyStrategy
 } from './interfaces';
 
-export { AbstractDatabase, createDatabaseCacheStorage } from './database';
-export { createSchemaFromModel, AbstractModel } from './model';
-export { AbstractRepository } from './repository';
+export * from './database';
+export * from './model';
+export * from './repository';
 
-export {
-	getConfig as getTenancyConfig,
-	getCurrentTenant,
-	withTenant,
-	registerTenancyStrategy,
-	getTenancyStrategy,
-	TenantMiddleware,
-	SimpleTenantMiddleware,
-	StrictTenantMiddleware
-} from './tenancy';
+export * from './tenancy';
 export type { TenancyConfig, TenancyMode, ModelTenancyConfig } from './tenancy';
 
-export { Cache } from './cache';
-export type { CacheInterface } from './cache';
-export { KeyvRedis } from './keyv-redis';
-
-// Configuration types
-export interface MnemosyneConfig<TConnectionConfig = unknown> {
-	database?: {
-		default: string;
-		connections: Record<string, TConnectionConfig>;
-	};
-	tenancy?: TenancyConfig;
-}
+export { Cache, type CacheInterface, MEMORY_CACHE_SERVICE, REDIS_CACHE_SERVICE } from './cache';
+export * from './mnemosyne.module';
+export * from './keyv-redis';

package/src/keyv-redis.ts

@@ -17,7 +17,7 @@ import type { KeyvEntry, StoredData } from 'keyv';
 
 import { EventEmitter } from 'node:events';
 
-import { Event, Redis } from '@elysiumjs/core';
+import { Event, Redis, Service } from '@elysiumjs/core';
 
 /**
  * Keyv adapter for redis. This adapter is based on the Bun's Redis client.
@@ -68,10 +68,6 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 	}) {
 		super();
 
-		Event.once('elysium:app:launched', () => {
-			this.#client = Redis.getConnection(props.connection);
-		});
-
 		this.#connection = props.connection;
 		this.#namespace = props.namespace;
 		this.#keyPrefixSeparator = props.keyPrefixSeparator ?? '::';
@@ -84,8 +80,15 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 		});
 	}
 
-	public get client() {
-		return this.#client!;
+	/**
+	 * Resolves the Redis client on first use. The async path is always safe, even when the
+	 * Redis module has not been initialised yet (lazy boot).
+	 */
+	protected async getClient(): Promise<Bun.RedisClient> {
+		this.#client ??= await Service.resolve<Bun.RedisClient>(
+			Redis.getConnectionName(this.#connection)
+		);
+		return this.#client;
 	}
 
 	/**
@@ -118,23 +121,26 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 	}
 
 	public async get<Value>(key: string): Promise<StoredData<Value> | undefined> {
+		const client = await this.getClient();
 		key = this.createKeyPrefix(key, this.#namespace);
-		const value = await this.client.get(key);
+		const value = await client.get(key);
 
 		return value === null ? undefined : (value as Value);
 	}
 
 	public async set(key: string, value: any, ttl?: number) {
+		const client = await this.getClient();
 		key = this.createKeyPrefix(key, this.#namespace);
 
 		if (ttl) {
-			await this.client.set(key, value, 'PX', ttl);
+			await client.set(key, value, 'PX', ttl);
 		} else {
-			await this.client.set(key, value);
+			await client.set(key, value);
 		}
 	}
 
 	public async setMany(values: Array<KeyvEntry>): Promise<void> {
+		const client = await this.getClient();
 		// TODO: Use MULTI when available in Bun
 		const multi = [];
 
@@ -142,10 +148,10 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 			const prefixedKey = this.createKeyPrefix(key, this.#namespace);
 			if (ttl) {
 				// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-unsafe-argument
-				multi.push(this.client.set(prefixedKey, value, 'PX', ttl));
+				multi.push(client.set(prefixedKey, value, 'PX', ttl));
 			} else {
 				// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-				multi.push(this.client.set(prefixedKey, value));
+				multi.push(client.set(prefixedKey, value));
 			}
 		}
 
@@ -153,19 +159,20 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 	}
 
 	public async delete(key: string): Promise<boolean> {
+		const client = await this.getClient();
 		key = this.createKeyPrefix(key, this.#namespace);
 		// TODO: Use UNLINK when available in Bun
-		const deleted = await (this.#useUnlink
-			? this.client.send('UNLINK', [key])
-			: this.client.del(key));
+		const deleted = await (this.#useUnlink ? client.send('UNLINK', [key]) : client.del(key));
 
 		return deleted > 0;
 	}
 
 	public async clear(): Promise<void> {
 		try {
+			const client = await this.getClient();
+
 			if (!this.#namespace && this.#noNamespaceAffectsAll) {
-				await this.client.send('FLUSHDB', []);
+				await client.send('FLUSHDB', []);
 				return;
 			}
 
@@ -175,7 +182,7 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 			const deletePromises = [];
 
 			do {
-				const result = await this.client.send('SCAN', [
+				const result = await client.send('SCAN', [
 					cursor,
 					'MATCH',
 					match,
@@ -197,7 +204,7 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 					keys = keys.filter((key: string) => !key.includes(this.#keyPrefixSeparator));
 				}
 
-				deletePromises.push(keys.map((key: string) => this.client.del(key)));
+				deletePromises.push(keys.map((key: string) => client.del(key)));
 			} while (cursor !== '0');
 
 			await Promise.all(deletePromises);
@@ -207,37 +214,42 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 	}
 
 	public async has(key: string): Promise<boolean> {
+		const client = await this.getClient();
 		key = this.createKeyPrefix(key, this.#namespace);
-		return this.client.exists(key);
+		return client.exists(key);
 	}
 
 	public async hasMany(keys: string[]): Promise<boolean[]> {
+		const client = await this.getClient();
 		const multi = [];
 
 		for (const key of keys) {
 			const prefixedKey = this.createKeyPrefix(key, this.#namespace);
-			multi.push(this.client.exists(prefixedKey));
+			multi.push(client.exists(prefixedKey));
 		}
 
 		return Promise.all(multi);
 	}
 
 	public async getMany<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>> {
+		const client = await this.getClient();
 		if (keys.length === 0) {
 			return [];
 		}
 
 		keys = keys.map((key) => this.createKeyPrefix(key, this.#namespace));
-		const values = await this.client.mget(...keys);
+		const values = await client.mget(...keys);
 
 		return values as Value[];
 	}
 
 	public async disconnect(): Promise<void> {
-		this.client.close();
+		// The connection is owned by the Redis module; only drop our reference to it.
+		this.#client = undefined;
 	}
 
 	public async deleteMany(keys: string[]): Promise<boolean> {
+		const client = await this.getClient();
 		let result = false;
 
 		// TODO: Use MULTI when available in Bun
@@ -246,9 +258,9 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 		for (const key of keys) {
 			const prefixedKey = this.createKeyPrefix(key, this.#namespace);
 			if (this.#useUnlink) {
-				multi.push(this.client.send('UNLINK', [prefixedKey]));
+				multi.push(client.send('UNLINK', [prefixedKey]));
 			} else {
-				multi.push(this.client.del(prefixedKey));
+				multi.push(client.del(prefixedKey));
 			}
 		}
 
@@ -266,11 +278,12 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 	public async *iterator<Value>(
 		namespace?: string
 	): AsyncGenerator<Array<string | Awaited<Value> | undefined>, void> {
+		const client = await this.getClient();
 		const match = namespace ? `${namespace}${this.#keyPrefixSeparator}*` : '*';
 		let cursor = '0';
 
 		do {
-			const result = await this.client.send('SCAN', [cursor, 'MATCH', match, 'TYPE', 'string']);
+			const result = await client.send('SCAN', [cursor, 'MATCH', match, 'TYPE', 'string']);
 
 			// Parse the result
 			let [newCursor, keys] = result;
@@ -281,7 +294,7 @@ export class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
 			}
 
 			if (keys.length > 0) {
-				const values = await this.client.mget(...keys);
+				const values = await client.mget(...keys);
 				for (const i of keys.keys()) {
 					const key = this.getKeyWithoutPrefix(keys[i], namespace);
 					const value = values[i];

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 getConfig = (): 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;
+export const getTenancyConfig = (): TenancyConfig => {
+	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'
 			})