@falkordb/mcpserver 1.0.1

package/dist/services/logger.service.test.js

@@ -0,0 +1,115 @@
+// Simple test for logger service to avoid import.meta issues
+// Focus on testing the public interface without requiring complex mocking
+// Mock platformdirs before importing logger service
+jest.mock('platformdirs', () => ({
+    userLogDir: jest.fn().mockReturnValue('/mock/user/logs'),
+}));
+import { logger } from './logger.service';
+// Mock file system operations
+jest.mock('fs', () => ({
+    appendFileSync: jest.fn(),
+    existsSync: jest.fn().mockReturnValue(true), // Directory exists
+    mkdirSync: jest.fn(),
+}));
+// Mock path module
+jest.mock('path', () => ({
+    join: jest.fn().mockReturnValue('/mock/logs/test.log'),
+}));
+describe('Logger Service', () => {
+    // Mock console to avoid actual logging during tests
+    let consoleErrorSpy;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+    });
+    describe('Singleton Instance', () => {
+        it('should export a singleton logger instance', () => {
+            expect(logger).toBeDefined();
+            expect(typeof logger.info).toBe('function');
+            expect(typeof logger.warn).toBe('function');
+            expect(typeof logger.error).toBe('function');
+            expect(typeof logger.debug).toBe('function');
+        });
+        it('should have sync logging methods', () => {
+            expect(typeof logger.infoSync).toBe('function');
+            expect(typeof logger.warnSync).toBe('function');
+            expect(typeof logger.errorSync).toBe('function');
+            expect(typeof logger.debugSync).toBe('function');
+        });
+        it('should have setMcpServer method', () => {
+            expect(typeof logger.setMcpServer).toBe('function');
+        });
+    });
+    describe('Async Logging Methods', () => {
+        it('should handle info logging without throwing', async () => {
+            await expect(logger.info('Test info message')).resolves.not.toThrow();
+            await expect(logger.info('Test with context', { key: 'value' })).resolves.not.toThrow();
+        });
+        it('should handle warn logging without throwing', async () => {
+            await expect(logger.warn('Test warning')).resolves.not.toThrow();
+            await expect(logger.warn('Test with context', { code: 123 })).resolves.not.toThrow();
+        });
+        it('should handle error logging without throwing', async () => {
+            const error = new Error('Test error');
+            await expect(logger.error('Error occurred')).resolves.not.toThrow();
+            await expect(logger.error('Error with object', error)).resolves.not.toThrow();
+            await expect(logger.error('Error with context', error, { extra: 'data' })).resolves.not.toThrow();
+        });
+        it('should handle debug logging without throwing', async () => {
+            await expect(logger.debug('Debug message')).resolves.not.toThrow();
+            await expect(logger.debug('Debug with context', { debug: true })).resolves.not.toThrow();
+        });
+    });
+    describe('Sync Logging Methods', () => {
+        it('should handle sync info logging without throwing', () => {
+            expect(() => logger.infoSync('Sync info')).not.toThrow();
+            expect(() => logger.infoSync('Sync info with context', { sync: true })).not.toThrow();
+        });
+        it('should handle sync warn logging without throwing', () => {
+            expect(() => logger.warnSync('Sync warning')).not.toThrow();
+            expect(() => logger.warnSync('Sync warning with context', { level: 'warn' })).not.toThrow();
+        });
+        it('should handle sync error logging without throwing', () => {
+            const error = new Error('Sync error');
+            expect(() => logger.errorSync('Sync error occurred')).not.toThrow();
+            expect(() => logger.errorSync('Sync error with object', error)).not.toThrow();
+            expect(() => logger.errorSync('Sync error with context', error, { extra: 'data' })).not.toThrow();
+        });
+        it('should handle sync debug logging without throwing', () => {
+            expect(() => logger.debugSync('Sync debug')).not.toThrow();
+            expect(() => logger.debugSync('Sync debug with context', { debug: true })).not.toThrow();
+        });
+    });
+    describe('MCP Server Integration', () => {
+        it('should accept MCP server instance without throwing', () => {
+            const mockMcpServer = {
+                server: {
+                    notification: jest.fn().mockResolvedValue(undefined),
+                },
+            };
+            expect(() => logger.setMcpServer(mockMcpServer)).not.toThrow();
+        });
+    });
+    describe('Error Resilience', () => {
+        it('should handle file system errors gracefully', async () => {
+            // The logger should not throw even if file operations fail
+            // This tests the try-catch blocks in the logging methods
+            await expect(logger.info('Test message during potential file error')).resolves.not.toThrow();
+            await expect(logger.error('Test error during potential file error', new Error('Test'))).resolves.not.toThrow();
+        });
+        it('should handle MCP notification errors gracefully', async () => {
+            // Set up a mock server that throws errors
+            const failingMcpServer = {
+                server: {
+                    notification: jest.fn().mockRejectedValue(new Error('MCP notification failed')),
+                },
+            };
+            logger.setMcpServer(failingMcpServer);
+            // Logger should not throw even if MCP notifications fail
+            await expect(logger.info('Test with failing MCP')).resolves.not.toThrow();
+        });
+    });
+});

package/dist/services/redis.service.js

@@ -0,0 +1,179 @@
+import { createClient } from 'redis';
+import { config } from '../config/index.js';
+import { AppError, CommonErrors } from '../errors/AppError.js';
+import { logger } from './logger.service.js';
+class RedisService {
+    client = null;
+    maxRetries = 5;
+    retryCount = 0;
+    initializingPromise = null;
+    constructor() {
+        // Don't initialize in constructor - use explicit initialization
+    }
+    sanitizeUrl(url) {
+        try {
+            const parsed = new URL(url);
+            if (parsed.username || parsed.password) {
+                parsed.username = parsed.username ? '***' : '';
+                parsed.password = parsed.password ? '***' : '';
+            }
+            return parsed.toString();
+        }
+        catch {
+            return '<invalid-url>';
+        }
+    }
+    async initialize() {
+        // Idempotency guard: don't overwrite an already-connected client
+        if (this.client) {
+            return;
+        }
+        if (this.initializingPromise) {
+            return this.initializingPromise;
+        }
+        this.retryCount = 0;
+        this.initializingPromise = this._initialize();
+        try {
+            await this.initializingPromise;
+        }
+        finally {
+            this.initializingPromise = null;
+        }
+    }
+    async _initialize() {
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                // Fire-and-forget: non-critical connection attempt log
+                logger.info('Attempting to connect to Redis', {
+                    url: this.sanitizeUrl(config.redis.url),
+                    attempt: attempt + 1
+                });
+                this.client = createClient({
+                    url: config.redis.url,
+                    username: config.redis.username,
+                    password: config.redis.password,
+                });
+                await this.client.connect();
+                await this.client.ping();
+                // Fire-and-forget: non-critical success log
+                logger.info('Successfully connected to Redis');
+                this.retryCount = 0;
+                return;
+            }
+            catch (error) {
+                // Clean up failed client before retrying or throwing
+                if (this.client) {
+                    try {
+                        await this.client.disconnect();
+                    }
+                    catch {
+                        // Ignore disconnect errors
+                    }
+                    this.client = null;
+                }
+                if (attempt < this.maxRetries) {
+                    this.retryCount = attempt + 1;
+                    const delay = Math.min(5000 * 2 ** attempt, 30000) + Math.random() * 1000;
+                    // Fire-and-forget: non-critical retry log
+                    logger.warn('Failed to connect to Redis, retrying...', {
+                        attempt: this.retryCount,
+                        maxRetries: this.maxRetries,
+                        nextRetryMs: Math.round(delay),
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+                else {
+                    const appError = new AppError(CommonErrors.CONNECTION_FAILED, `Failed to connect to Redis after ${this.maxRetries} attempts: ${error instanceof Error ? error.message : String(error)}`, true);
+                    await logger.error('Redis connection failed permanently', appError);
+                    throw appError;
+                }
+            }
+        }
+    }
+    async get(key) {
+        if (!this.client) {
+            throw new AppError(CommonErrors.CONNECTION_FAILED, 'Redis client not initialized. Call initialize() first.', true);
+        }
+        try {
+            const value = await this.client.get(key);
+            logger.debug('Redis GET operation completed', { key, hasValue: value !== null });
+            return value;
+        }
+        catch (error) {
+            const appError = new AppError(CommonErrors.OPERATION_FAILED, `Failed to get key '${key}' from Redis: ${error instanceof Error ? error.message : String(error)}`, true);
+            await logger.error('Redis GET operation failed', appError, { key });
+            throw appError;
+        }
+    }
+    async set(key, value) {
+        if (!this.client) {
+            throw new AppError(CommonErrors.CONNECTION_FAILED, 'Redis client not initialized. Call initialize() first.', true);
+        }
+        try {
+            await this.client.set(key, value);
+            logger.debug('Redis SET operation completed', { key });
+        }
+        catch (error) {
+            const appError = new AppError(CommonErrors.OPERATION_FAILED, `Failed to set key '${key}' in Redis: ${error instanceof Error ? error.message : String(error)}`, true);
+            await logger.error('Redis SET operation failed', appError, { key });
+            throw appError;
+        }
+    }
+    async delete(key) {
+        if (!this.client) {
+            throw new AppError(CommonErrors.CONNECTION_FAILED, 'Redis client not initialized. Call initialize() first.', true);
+        }
+        try {
+            await this.client.del(key);
+            logger.debug('Redis DEL operation completed', { key });
+        }
+        catch (error) {
+            const appError = new AppError(CommonErrors.OPERATION_FAILED, `Failed to delete key '${key}' from Redis: ${error instanceof Error ? error.message : String(error)}`, true);
+            await logger.error('Redis DEL operation failed', appError, { key });
+            throw appError;
+        }
+    }
+    async listKeys() {
+        if (!this.client) {
+            throw new AppError(CommonErrors.CONNECTION_FAILED, 'Redis client not initialized. Call initialize() first.', true);
+        }
+        try {
+            let cursor = 0;
+            const allKeys = [];
+            do {
+                const result = await this.client.scan(cursor, {
+                    MATCH: '*',
+                    COUNT: 1000
+                });
+                allKeys.push(...result.keys);
+                // Depending on the redis client, cursor may be a string; normalize to number
+                cursor = typeof result.cursor === 'string' ? Number(result.cursor) : result.cursor;
+            } while (cursor !== 0);
+            logger.debug('Redis KEYS operation completed', { count: allKeys.length });
+            return allKeys;
+        }
+        catch (error) {
+            const appError = new AppError(CommonErrors.OPERATION_FAILED, `Failed to list keys in Redis: ${error instanceof Error ? error.message : String(error)}`, true);
+            await logger.error('Redis KEYS operation failed', appError);
+            throw appError;
+        }
+    }
+    async close() {
+        if (this.client) {
+            try {
+                await this.client.quit();
+                logger.info('Redis connection closed successfully');
+            }
+            catch (error) {
+                // Fire-and-forget: best-effort log during cleanup
+                logger.error('Error closing Redis connection', error instanceof Error ? error : new Error(String(error)));
+            }
+            finally {
+                this.client = null;
+                this.retryCount = 0;
+            }
+        }
+    }
+}
+export const redisService = new RedisService();