@elysiumjs/mnemosyne 0.1.2 → 0.2.0

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/bunfig.toml

@@ -1,19 +0,0 @@
-[test]
-# The root directory of all unit tests
-root = "./tests"
-# A file loaded right before running `bun test`
-preload = ["./tests/setup.ts"]
-# Enable code coverage by default
-coverage = true
-# Requires 90% line coverage, 70% function coverage, and 80% statement coverage
-coverageThreshold = { line = 0.9, function = 0.7, statement = 0.8 }
-# Tests files are included in the coverage statistics
-coverageSkipTestFiles = true
-# Use lcov as the coverage reporter
-coverageReporter = ["lcov", "text"]
-# Path the output coverage results
-coverageDir = "./coverage"
-
-[run]
-# Always use bun runtime for every `bun run` commands
-bun = true