@elysiumjs/mnemosyne 0.1.2 → 0.3.1

package/tests/cache.test.ts

@@ -1,464 +0,0 @@
-// Copyright (c) 2025-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 { Mock } from 'bun:test';
-
-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';
-
-// Mock dependencies
-mock.module('cache-manager', () => ({
-	createCache: mock(createCache)
-}));
-
-Redis.registerConnection('cache', {
-	url: process.env.REDIS_TEST_URL!
-});
-
-// Test the weak cache
-describe('Cache.weak', () => {
-	it('should get data from the weak cache', () => {
-		// Create a test object to use as a context
-		const testContext = {};
-
-		// Get data from the cache (should initialize with empty object)
-		const data = Cache.weak.get(testContext);
-
-		// Check if the data is an empty object
-		expect(data).toEqual({});
-
-		// Verify that the context is now in the map
-		expect(Cache.weak.map.has(testContext)).toBe(true);
-	});
-
-	it('should return existing data from the weak cache', () => {
-		// Create a test object to use as a context
-		const testContext = {};
-
-		// Set some data in the cache
-		const testData = { test: 'data' };
-		Cache.weak.map.set(testContext, testData);
-
-		// Get data from the cache
-		const data = Cache.weak.get(testContext);
-
-		// Check if the data matches what we set
-		expect(data).toBe(testData);
-	});
-
-	it('should delete data from the weak cache', () => {
-		// Create a test object to use as a context
-		const testContext = {};
-
-		// Set some data in the cache
-		Cache.weak.map.set(testContext, { test: 'data' });
-
-		// Verify that the context is in the map
-		expect(Cache.weak.map.has(testContext)).toBe(true);
-
-		// Delete the data
-		Cache.weak.del(testContext);
-
-		// Verify that the context is no longer in the map
-		expect(Cache.weak.map.has(testContext)).toBe(false);
-	});
-});
-
-// Test the Redis cache
-describe('Cache.redis', () => {
-	beforeAll(() => {
-		Cache.redis.clear();
-		Event.emit('elysium:app:launched', null, null);
-	});
-
-	// Reset mocks before each test
-	beforeEach(() => {
-		mock.restore();
-	});
-
-	it('should be created with the correct configuration', async () => {
-		// Check if createCache was called with the correct parameters
-		expect(createCache).toHaveBeenCalledWith({
-			stores: expect.arrayContaining([expect.any(Object)])
-		});
-	});
-
-	it('should call get method with the correct parameters', async () => {
-		const getSpy = spyOn(Cache.redis, 'get');
-
-		// Call the get method
-		const result = await Cache.redis.get('test-key');
-
-		// Check if the get method was called with the correct parameters
-		expect(getSpy).toHaveBeenCalledWith('test-key');
-
-		// Check if the result is correct
-		expect(result).toBeNull();
-	});
-
-	it('should call set method with the correct parameters', async () => {
-		const setSpy = spyOn(Cache.redis, 'set');
-
-		// Call the set method
-		const result = await Cache.redis.set('test-key', 'test-value', 3600);
-
-		// Check if the set method was called with the correct parameters
-		expect(setSpy).toHaveBeenCalledWith('test-key', 'test-value', 3600);
-
-		// Check if the result is correct
-		expect(result).toBe('test-value');
-	});
-
-	it('should call ttl method with the correct parameters', async () => {
-		const ttlSpy = spyOn(Cache.redis, 'ttl');
-
-		// Call the ttl method
-		const result = await Cache.redis.ttl('test-key');
-
-		// Check if the ttl method was called with the correct parameters
-		expect(ttlSpy).toHaveBeenCalledWith('test-key');
-
-		const date = new Date(result!);
-
-		// Check if the result is correct
-		expect(date.getTime()).toBeGreaterThanOrEqual(Date.now() - 3600 * 1000);
-	});
-
-	it('should call del method with the correct parameters', async () => {
-		const delSpy = spyOn(Cache.redis, 'del');
-
-		// Call the del method
-		const result = await Cache.redis.del('test-key');
-
-		// Check if the del method was called with the correct parameters
-		expect(delSpy).toHaveBeenCalledWith('test-key');
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should call mset method with the correct parameters', async () => {
-		const msetSpy = spyOn(Cache.redis, 'mset');
-
-		// Set up the mock to return the test data
-		const testData = [
-			{ key: 'key1', value: 'value1', ttl: 3600 },
-			{ key: 'key2', value: 'value2' }
-		];
-
-		// Call the mset method
-		const result = await Cache.redis.mset(testData);
-
-		// Check if the mset method was called with the correct parameters
-		expect(msetSpy).toHaveBeenCalledWith(testData);
-
-		// Check if the result is correct
-		expect(result).toEqual(testData);
-	});
-
-	it('should call mget method with the correct parameters', async () => {
-		const mgetSpy = spyOn(Cache.redis, 'mget');
-
-		// Call the mget method
-		const result = await Cache.redis.mget(['key1', 'key2']);
-
-		// Check if the mget method was called with the correct parameters
-		expect(mgetSpy).toHaveBeenCalledWith(['key1', 'key2']);
-
-		// Check if the result is correct
-		expect(result).toEqual(['value1', 'value2']);
-	});
-
-	it('should call mdel method with the correct parameters', async () => {
-		const mdelSpy = spyOn(Cache.redis, 'mdel');
-
-		// Call the mdel method
-		const result = await Cache.redis.mdel(['key1', 'key2']);
-
-		// Check if the mdel method was called with the correct parameters
-		expect(mdelSpy).toHaveBeenCalledWith(['key1', 'key2']);
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should call clear method', async () => {
-		const clearSpy = spyOn(Cache.redis, 'clear');
-
-		// Call the clear method
-		const result = await Cache.redis.clear();
-
-		// Check if the clear method was called
-		expect(clearSpy).toHaveBeenCalled();
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should create a tagged cache with the correct namespace', () => {
-		const keyvSpy = spyOn(KV, 'Keyv').mockReturnThis();
-
-		// Call the tags method
-		Cache.redis.tags('tag1', 'tag2');
-
-		// Check if Keyv was instantiated with the correct namespace
-		expect(keyvSpy).toHaveBeenCalledWith({
-			store: expect.any(Object),
-			namespace: 'cache__tag1__tag2'
-		});
-
-		// Check if createCache was called
-		expect(createCache).toHaveBeenCalled();
-	});
-});
-
-// Test the memory cache
-describe('Cache.memory', () => {
-	// Reset mocks before each test
-	beforeEach(() => {
-		mock.restore();
-	});
-
-	it('should be created with the correct configuration', () => {
-		// Check if createCache was called with the correct parameters
-		expect(createCache).toHaveBeenCalledWith({
-			stores: expect.arrayContaining([expect.any(Object)])
-		});
-	});
-
-	it('should call set method with the correct parameters', async () => {
-		const setSpy = spyOn(Cache.memory, 'set');
-
-		// Call the set method
-		const result = await Cache.memory.set('test-key', 'test-value', 3600);
-
-		// Check if the set method was called with the correct parameters
-		expect(setSpy).toHaveBeenCalledWith('test-key', 'test-value', 3600);
-
-		// Check if the result is correct
-		expect(result).toBe('test-value');
-	});
-	it('should call get method with the correct parameters', async () => {
-		const getSpy = spyOn(Cache.memory, 'get');
-
-		// Call the get method
-		const result = await Cache.memory.get('test-key');
-
-		// Check if the get method was called with the correct parameters
-		expect(getSpy).toHaveBeenCalledWith('test-key');
-
-		// Check if the result is correct
-		expect(result).toBe('test-value');
-	});
-
-	it('should call ttl method with the correct parameters', async () => {
-		const ttlSpy = spyOn(Cache.memory, 'ttl');
-
-		// Call the ttl method
-		const result = await Cache.memory.ttl('test-key');
-
-		// Check if the ttl method was called with the correct parameters
-		expect(ttlSpy).toHaveBeenCalledWith('test-key');
-
-		const date = new Date(result!);
-
-		// Check if the result is correct
-		expect(date.getTime()).toBeGreaterThanOrEqual(Date.now() - 3600 * 1000);
-	});
-
-	it('should call del method with the correct parameters', async () => {
-		const delSpy = spyOn(Cache.memory, 'del');
-
-		// Call the del method
-		const result = await Cache.memory.del('test-key');
-
-		// Check if the del method was called with the correct parameters
-		expect(delSpy).toHaveBeenCalledWith('test-key');
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should call mset method with the correct parameters', async () => {
-		const msetSpy = spyOn(Cache.memory, 'mset');
-
-		// Set up the mock to return the test data
-		const testData = [
-			{ key: 'key1', value: 'value1', ttl: 3600 },
-			{ key: 'key2', value: 'value2' }
-		];
-
-		// Call the mset method
-		const result = await Cache.memory.mset(testData);
-
-		// Check if the mset method was called with the correct parameters
-		expect(msetSpy).toHaveBeenCalledWith(testData);
-
-		// Check if the result is correct
-		expect(result).toEqual(testData);
-	});
-
-	it('should call mget method with the correct parameters', async () => {
-		const mgetSpy = spyOn(Cache.memory, 'mget');
-
-		// Call the mget method
-		const result = await Cache.memory.mget(['key1', 'key2']);
-
-		// Check if the mget method was called with the correct parameters
-		expect(mgetSpy).toHaveBeenCalledWith(['key1', 'key2']);
-
-		// Check if the result is correct
-		expect(result).toEqual(['value1', 'value2']);
-	});
-
-	it('should call mdel method with the correct parameters', async () => {
-		const mdelSpy = spyOn(Cache.memory, 'mdel');
-
-		// Call the mdel method
-		const result = await Cache.memory.mdel(['key1', 'key2']);
-
-		// Check if the mdel method was called with the correct parameters
-		expect(mdelSpy).toHaveBeenCalledWith(['key1', 'key2']);
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should call clear method', async () => {
-		const clearSpy = spyOn(Cache.memory, 'clear');
-
-		// Call the clear method
-		const result = await Cache.memory.clear();
-
-		// Check if the clear method was called
-		expect(clearSpy).toHaveBeenCalled();
-
-		// Check if the result is correct
-		expect(result).toBe(true);
-	});
-
-	it('should create a tagged cache with the correct namespace', () => {
-		const keyvSpy = spyOn(KV, 'Keyv').mockReturnThis();
-
-		// Call the tags method
-		Cache.memory.tags('tag1', 'tag2');
-
-		// Check if Keyv was instantiated with the correct namespace
-		expect(keyvSpy).toHaveBeenCalledWith({
-			store: expect.any(Object),
-			namespace: 'cache__tag1__tag2'
-		});
-
-		// Check if createCache was called
-		expect(createCache).toHaveBeenCalled();
-	});
-});
-
-// Test cache with different TTL values
-describe('Cache with TTL', () => {
-	beforeEach(() => {
-		mock.restore();
-	});
-
-	it('should set cache with TTL', async () => {
-		const setSpy = spyOn(Cache.memory, 'set');
-
-		// Call the set method with TTL
-		await Cache.memory.set('test-key', 'test-value', 3600);
-
-		// Check if the set method was called with the correct TTL
-		expect(setSpy).toHaveBeenCalledWith('test-key', 'test-value', 3600);
-	});
-
-	it('should set cache without TTL', async () => {
-		const setSpy = spyOn(Cache.memory, 'set');
-
-		// Call the set method without TTL
-		await Cache.memory.set('test-key', 'test-value');
-
-		// Check if the set method was called without TTL
-		expect(setSpy).toHaveBeenCalledWith('test-key', 'test-value');
-	});
-
-	it('should set multiple cache entries with different TTLs', async () => {
-		const msetSpy = spyOn(Cache.memory, 'mset');
-
-		// Set up the mock to return the test data
-		const testData = [
-			{ key: 'key1', value: 'value1', ttl: 3600 },
-			{ key: 'key2', value: 'value2' }
-		];
-
-		// Call the mset method
-		await Cache.memory.mset(testData);
-
-		// Check if the mset method was called with the correct parameters
-		expect(msetSpy).toHaveBeenCalledWith(testData);
-	});
-});
-
-// Test cache namespacing and tagging
-describe('Cache namespacing and tagging', () => {
-	beforeEach(() => {
-		mock.restore();
-	});
-
-	it('should create a tagged cache with a single tag', () => {
-		const keyvSpy = spyOn(KV, 'Keyv').mockReturnThis();
-
-		// Call the tags method with a single tag
-		Cache.memory.tags('tag1');
-
-		// Check if Keyv was instantiated with the correct namespace
-		expect(keyvSpy).toHaveBeenCalledWith(
-			expect.objectContaining({
-				namespace: 'cache__tag1'
-			})
-		);
-
-		// Check if createCache was called
-		expect(createCache).toHaveBeenCalled();
-	});
-
-	it('should create a tagged cache with multiple tags', () => {
-		const keyvSpy = spyOn(KV, 'Keyv').mockReturnThis();
-
-		// Call the tags method with multiple tags
-		Cache.memory.tags('tag1', 'tag2', 'tag3');
-
-		// Check if Keyv was instantiated with the correct namespace
-		expect(keyvSpy).toHaveBeenLastCalledWith(
-			expect.objectContaining({
-				namespace: 'cache__tag1__tag2__tag3'
-			})
-		);
-
-		// Check if createCache was called
-		expect(createCache).toHaveBeenCalled();
-
-		keyvSpy.mockClear();
-		(createCache as Mock<typeof createCache>).mockClear();
-
-		// Call the tags method with multiple tags
-		Cache.memory.tags('tag3', 'tag2', 'tag1');
-
-		expect(keyvSpy).not.toHaveBeenCalled();
-		expect(createCache).not.toHaveBeenCalled();
-	});
-});

package/tests/database.test.ts

@@ -1,249 +0,0 @@
-// Copyright (c) 2025-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 { afterEach, beforeEach, describe, expect, it, jest, mock, spyOn } from 'bun:test';
-
-import { Application, Service } from '@elysiumjs/core';
-
-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 })),
-};
-
-class TestDatabase extends AbstractDatabase<any, any> {
-	protected driver = mockDriver;
-}
-
-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.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');
-
-			// 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);
-		});
-
-		it('should throw an error if the connection does not exist', () => {
-			const db = new TestDatabase();
-
-			// Mock Service.exists to return false (connection doesn't exist)
-			const existsSpy = spyOn(Service, 'exists').mockReturnValueOnce(false);
-
-			// Call the function
-			db.getConnection('test');
-
-			// 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);
-		});
-	});
-
-	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', () => {
-			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(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,
-			});
-
-			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);
-
-			// Check if the result is correct
-			expect(result as any).toEqual(mockConnection);
-
-			// Restore original descriptor
-			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');
-
-			// 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 });
-		});
-	});
-});