@falkordb/mcpserver 1.0.1 → 1.1.1

package/.env.example

@@ -17,10 +17,5 @@ FALKORDB_PASSWORD=
 # Set to 'true' to use read-only queries by default (useful for replica instances)
 FALKORDB_DEFAULT_READONLY=false
 
-# Redis Configuration (for key-value operations)
-REDIS_URL=redis://localhost:6379
-REDIS_USERNAME=
-REDIS_PASSWORD=
-
 # Logging Configuration (optional)
 ENABLE_FILE_LOGGING=false

package/README.md

@@ -17,7 +17,6 @@ FalkorDB MCP Server enables AI assistants like Claude to interact with FalkorDB
 This server implements the [Model Context Protocol (MCP)](https://modelcontextprotocol.io), allowing AI models to:
 - **Query graph databases** using OpenCypher (with read-only mode support)
 - **Create and manage** nodes and relationships
-- **Store and retrieve** key-value data
 - **List and explore** multiple graphs
 - **Delete graphs** when needed
 - **Read-only queries** for replica instances or to prevent accidental writes
@@ -54,6 +53,32 @@ Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_
 }
 ```
 
+### Running with npx
+
+You can run the server directly from the command line using npx:
+
+**Using inline environment variables:**
+
+```bash
+# Run with stdio transport (default)
+FALKORDB_HOST=localhost FALKORDB_PORT=6379 npx -y @falkordb/mcpserver
+
+# Run with HTTP transport
+MCP_TRANSPORT=http MCP_PORT=3005 FALKORDB_HOST=localhost FALKORDB_PORT=6379 npx -y @falkordb/mcpserver
+```
+
+**Using a .env file:**
+
+```bash
+# Using dotenv-cli to load environment variables from .env
+npx dotenv-cli -e .env -- npx @falkordb/mcpserver
+```
+
+This is useful for:
+- Quick testing and development
+- Running the server standalone without Claude Desktop
+- Custom integrations and scripting
+
 ### Installation
 
 1. **Clone and install:**
@@ -72,19 +97,14 @@ Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_
    ```env
    # Environment Configuration
    NODE_ENV=development
-   
+
    # FalkorDB Configuration
    FALKORDB_HOST=localhost
    FALKORDB_PORT=6379
    FALKORDB_USERNAME=    # Optional
    FALKORDB_PASSWORD=    # Optional
    FALKORDB_DEFAULT_READONLY=false  # Set to 'true' for read-only mode (useful for replicas)
-   
-   # Redis Configuration (for key-value operations)
-   REDIS_URL=redis://localhost:6379
-   REDIS_USERNAME=       # Optional
-   REDIS_PASSWORD=       # Optional
-   
+
    # Logging Configuration (optional)
    ENABLE_FILE_LOGGING=false
    ```
@@ -136,7 +156,6 @@ There's also a dedicated `query_graph_readonly` tool that always executes querie
 ```text
 "Create a new person named Alice who knows Bob"
 "Add a 'WORKS_AT' relationship between Alice and TechCorp"
-"Store my API key in the database"
 ```
 
 ### 📊 Explore Structure
@@ -195,7 +214,6 @@ src/
 ├── index.ts                   # MCP server entry point
 ├── services/                  # Core business logic
 │   ├── falkordb.service.ts   # FalkorDB operations
-│   ├── redis.service.ts      # Key-value operations
 │   └── logger.service.ts     # Logging and MCP notifications
 ├── mcp/                      # MCP protocol implementations
 │   ├── tools.ts             # MCP tool definitions

package/dist/config/index.js

@@ -15,11 +15,6 @@ export const config = {
         password: process.env.FALKORDB_PASSWORD || '',
         defaultReadOnly: process.env.FALKORDB_DEFAULT_READONLY === 'true',
     },
-    redis: {
-        url: process.env.REDIS_URL || 'redis://localhost:6379',
-        username: process.env.REDIS_USERNAME || '',
-        password: process.env.REDIS_PASSWORD || '',
-    },
     mcp: {
         transport: (process.env.MCP_TRANSPORT || 'stdio'),
         apiKey: process.env.MCP_API_KEY || '',

package/dist/index.js

@@ -6,7 +6,6 @@ import { falkorDBService } from './services/falkordb.service.js';
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { redisService } from './services/redis.service.js';
 import { errorHandler } from './errors/ErrorHandler.js';
 import { logger } from './services/logger.service.js';
 import { config } from './config/index.js';
@@ -39,7 +38,6 @@ const gracefulShutdown = async (signal) => {
             });
         }
         await falkorDBService.close();
-        await redisService.close();
         await logger.info('All services closed successfully');
         process.exit(0);
     }
@@ -81,7 +79,6 @@ async function initializeServices() {
     await logger.info('Initializing FalkorDB MCP server...');
     try {
         await falkorDBService.initialize();
-        await redisService.initialize();
         await logger.info('All services initialized successfully');
     }
     catch (error) {

package/dist/mcp/tools.js

@@ -1,6 +1,5 @@
 import { z } from 'zod';
 import { falkorDBService } from '../services/falkordb.service.js';
-import { redisService } from '../services/redis.service.js';
 import { logger } from '../services/logger.service.js';
 import { AppError, CommonErrors } from '../errors/AppError.js';
 import { config } from '../config/index.js';
@@ -18,17 +17,6 @@ const deleteGraphSchema = {
     graphName: z.string().describe("The name of the graph to delete"),
     confirmDelete: z.literal(true).describe("Must be set to true to confirm deletion. This is a safety measure to prevent accidental data loss."),
 };
-const setKeySchema = {
-    key: z.string().describe("The key to set"),
-    value: z.string().describe("The value to set"),
-};
-const getKeySchema = {
-    key: z.string().describe("The key to get."),
-};
-const deleteKeySchema = {
-    key: z.string().describe("The key to delete"),
-    confirmDelete: z.literal(true).describe("Must be set to true to confirm deletion. This is a safety measure to prevent accidental data loss."),
-};
 function registerQueryGraphTool(server) {
     server.registerTool("query_graph", {
         title: "Query Graph",
@@ -140,119 +128,10 @@ function registerDeleteGraphTool(server) {
         }
     });
 }
-function registerListKeysTool(server) {
-    server.registerTool("list_keys", {
-        title: "List Keys",
-        description: "List all keys in Redis",
-        inputSchema: {},
-    }, async () => {
-        try {
-            const keys = await redisService.listKeys();
-            await logger.debug('List keys tool executed', { count: keys.length });
-            return {
-                content: [{
-                        type: "text",
-                        text: keys.join("\n"),
-                    }]
-            };
-        }
-        catch (error) {
-            await logger.error('List keys tool execution failed', error instanceof Error ? error : new Error(String(error)));
-            throw error;
-        }
-    });
-}
-function registerSetKeyTool(server) {
-    // Register set_key tool
-    server.registerTool("set_key", {
-        title: "Set Key",
-        description: "Set a key in Redis",
-        inputSchema: setKeySchema,
-    }, async (args) => {
-        const { key, value } = z.object(setKeySchema).parse(args);
-        try {
-            if (!key?.trim()) {
-                throw new AppError(CommonErrors.INVALID_INPUT, 'Key is required and cannot be empty', true);
-            }
-            if (value === undefined || value === null) {
-                throw new AppError(CommonErrors.INVALID_INPUT, 'Value is required', true);
-            }
-            await redisService.set(key, value);
-            await logger.debug('Set key tool executed successfully', { key });
-            return {
-                content: [{
-                        type: "text",
-                        text: `Key ${key} set successfully`
-                    }]
-            };
-        }
-        catch (error) {
-            await logger.error('Set key tool execution failed', error instanceof Error ? error : new Error(String(error)), { key });
-            throw error;
-        }
-    });
-}
-function registerGetKeyTool(server) {
-    // Register get_key tool
-    server.registerTool("get_key", {
-        title: "Get Key",
-        description: "Get a key from Redis",
-        inputSchema: getKeySchema,
-    }, async (args) => {
-        const { key } = z.object(getKeySchema).parse(args);
-        try {
-            if (!key?.trim()) {
-                throw new AppError(CommonErrors.INVALID_INPUT, 'Key is required and cannot be empty', true);
-            }
-            const value = await redisService.get(key);
-            await logger.debug('Get key tool executed successfully', { key, hasValue: value !== null });
-            return {
-                content: [{
-                        type: "text",
-                        text: `Key ${key} is ${value ?? 'null (not found)'}`
-                    }]
-            };
-        }
-        catch (error) {
-            await logger.error('Get key tool execution failed', error instanceof Error ? error : new Error(String(error)), { key });
-            throw error;
-        }
-    });
-}
-function registerDeleteKeyTool(server) {
-    server.registerTool("delete_key", {
-        title: "Delete Key",
-        description: "Permanently delete a key from Redis. WARNING: This action is irreversible. You must set confirmDelete to true to proceed.",
-        inputSchema: deleteKeySchema,
-    }, async (args) => {
-        const { key } = z.object(deleteKeySchema).parse(args);
-        try {
-            if (!key?.trim()) {
-                throw new AppError(CommonErrors.INVALID_INPUT, 'Key is required and cannot be empty', true);
-            }
-            await redisService.delete(key);
-            await logger.debug('Delete key tool executed successfully', { key });
-            return {
-                content: [{
-                        type: "text",
-                        text: `Key ${key} deleted`
-                    }]
-            };
-        }
-        catch (error) {
-            await logger.error('Delete key tool execution failed', error instanceof Error ? error : new Error(String(error)), { key });
-            throw error;
-        }
-    });
-}
 export default function registerAllTools(server) {
     // Register query_graph tools
     registerQueryGraphTool(server);
     registerQueryGraphReadOnlyTool(server);
     registerListGraphsTool(server);
     registerDeleteGraphTool(server);
-    registerSetKeyTool(server);
-    registerGetKeyTool(server);
-    registerDeleteKeyTool(server);
-    registerListKeysTool(server);
 }

package/dist/services/falkordb.service.js

@@ -41,8 +41,8 @@ class FalkorDBService {
                         host: config.falkorDB.host,
                         port: config.falkorDB.port,
                     },
-                    password: config.falkorDB.password,
-                    username: config.falkorDB.username,
+                    ...(config.falkorDB.username && { username: config.falkorDB.username }),
+                    ...(config.falkorDB.password && { password: config.falkorDB.password }),
                 });
                 // Test connection
                 const connection = await this.client.connection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falkordb/mcpserver",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Model Context Protocol server for FalkorDB graph databases - enables AI assistants to query and manage graph data using natural language",
   "main": "dist/index.js",
   "type": "module",
@@ -32,7 +32,6 @@
     "claude",
     "opencypher",
     "cypher",
-    "redis",
     "graph",
     "database",
     "typescript",
@@ -85,7 +84,6 @@
     "dotenv": "^17.2.1",
     "falkordb": "^6.3.0",
     "platformdirs": "^4.3.8-rc3",
-    "redis": "^4.0.0",
     "zod": "^3.23.0"
   },
   "publishConfig": {

package/dist/services/redis.service.js

@@ -1,179 +0,0 @@
-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();

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

@@ -1,399 +0,0 @@
-import { redisService } from './redis.service';
-import { AppError, CommonErrors } from '../errors/AppError.js';
-// Mock the logger service
-jest.mock('./logger.service.js', () => ({
-    logger: {
-        info: jest.fn().mockResolvedValue(undefined),
-        warn: jest.fn().mockResolvedValue(undefined),
-        error: jest.fn().mockResolvedValue(undefined),
-        debug: jest.fn().mockResolvedValue(undefined),
-    }
-}));
-// Mock the config
-jest.mock('../config/index.js', () => ({
-    config: {
-        redis: {
-            url: 'redis://localhost:6379',
-            username: 'testuser',
-            password: 'testpass'
-        }
-    }
-}));
-// Mock the Redis library
-jest.mock('redis', () => {
-    const mockConnect = jest.fn();
-    const mockPing = jest.fn();
-    const mockGet = jest.fn();
-    const mockSet = jest.fn();
-    const mockDel = jest.fn();
-    const mockScan = jest.fn();
-    const mockQuit = jest.fn();
-    const mockClient = {
-        connect: mockConnect,
-        ping: mockPing,
-        get: mockGet,
-        set: mockSet,
-        del: mockDel,
-        scan: mockScan,
-        quit: mockQuit
-    };
-    return {
-        createClient: jest.fn().mockReturnValue(mockClient),
-        mockConnect,
-        mockPing,
-        mockGet,
-        mockSet,
-        mockDel,
-        mockScan,
-        mockQuit,
-        mockClient
-    };
-});
-describe('Redis Service', () => {
-    let mockRedis;
-    beforeAll(async () => {
-        // Access the mocks
-        mockRedis = await import('redis');
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Reset service state
-        redisService.client = null;
-        redisService.retryCount = 0;
-        redisService.initializingPromise = null;
-    });
-    describe('initialize', () => {
-        it('should successfully initialize and connect to Redis', async () => {
-            // Arrange
-            mockRedis.mockConnect.mockResolvedValue(undefined);
-            mockRedis.mockPing.mockResolvedValue('PONG');
-            // Act
-            await redisService.initialize();
-            // Assert
-            expect(mockRedis.createClient).toHaveBeenCalledWith({
-                url: 'redis://localhost:6379',
-                username: 'testuser',
-                password: 'testpass',
-            });
-            expect(mockRedis.mockConnect).toHaveBeenCalled();
-            expect(mockRedis.mockPing).toHaveBeenCalled();
-            expect(redisService.client).not.toBeNull();
-            expect(redisService.retryCount).toBe(0);
-            expect(redisService.initializingPromise).toBeNull();
-        });
-        it('should await ongoing initialization if already initializing', async () => {
-            // Arrange
-            mockRedis.mockConnect.mockResolvedValue(undefined);
-            mockRedis.mockPing.mockResolvedValue('PONG');
-            // Act - start two initializations concurrently
-            const init1 = redisService.initialize();
-            const init2 = redisService.initialize();
-            await Promise.all([init1, init2]);
-            // Assert - createClient should only be called once
-            expect(mockRedis.createClient).toHaveBeenCalledTimes(1);
-            expect(redisService.client).not.toBeNull();
-        });
-        it('should retry connection on failure and eventually succeed', async () => {
-            // Arrange
-            const connectError = new Error('Connection failed');
-            mockRedis.mockConnect
-                .mockRejectedValueOnce(connectError)
-                .mockRejectedValueOnce(connectError)
-                .mockResolvedValueOnce(undefined);
-            mockRedis.mockPing.mockResolvedValue('PONG');
-            // Mock setTimeout to avoid actual delays
-            const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((callback) => {
-                setImmediate(callback);
-                return {};
-            });
-            // Act
-            await redisService.initialize();
-            // Assert
-            expect(mockRedis.createClient).toHaveBeenCalledTimes(3);
-            expect(redisService.client).not.toBeNull();
-            expect(redisService.retryCount).toBe(0);
-            // Cleanup
-            setTimeoutSpy.mockRestore();
-        });
-        it('should throw AppError after max retries exceeded', async () => {
-            // Arrange
-            const connectError = new Error('Connection failed');
-            mockRedis.mockConnect.mockRejectedValue(connectError);
-            // Mock setTimeout to avoid actual delays
-            const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((callback) => {
-                setImmediate(callback);
-                return {};
-            });
-            // Act & Assert
-            try {
-                await redisService.initialize();
-                fail('Expected initialize to throw AppError');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(AppError);
-                expect(error.name).toBe(CommonErrors.CONNECTION_FAILED);
-            }
-            expect(mockRedis.createClient).toHaveBeenCalledTimes(6); // 1 initial + 5 retries
-            // Cleanup
-            setTimeoutSpy.mockRestore();
-        });
-        it('should handle ping failure during connection test', async () => {
-            // Arrange
-            const pingError = new Error('Ping failed');
-            mockRedis.mockConnect.mockResolvedValue(undefined);
-            mockRedis.mockPing.mockRejectedValue(pingError);
-            // Mock setTimeout to avoid actual delays
-            const setTimeoutSpy = jest.spyOn(global, 'setTimeout').mockImplementation((callback) => {
-                setImmediate(callback);
-                return {};
-            });
-            // Act & Assert
-            await expect(redisService.initialize()).rejects.toThrow(AppError);
-            // Cleanup
-            setTimeoutSpy.mockRestore();
-        });
-    });
-    describe('get', () => {
-        it('should get a value from Redis', async () => {
-            // Arrange
-            const key = 'testKey';
-            const expectedValue = 'testValue';
-            mockRedis.mockGet.mockResolvedValue(expectedValue);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            const result = await redisService.get(key);
-            // Assert
-            expect(mockRedis.mockGet).toHaveBeenCalledWith(key);
-            expect(result).toBe(expectedValue);
-        });
-        it('should return null when key does not exist', async () => {
-            // Arrange
-            const key = 'nonExistentKey';
-            mockRedis.mockGet.mockResolvedValue(null);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            const result = await redisService.get(key);
-            // Assert
-            expect(mockRedis.mockGet).toHaveBeenCalledWith(key);
-            expect(result).toBeNull();
-        });
-        it('should throw AppError if client is not initialized', async () => {
-            // Arrange
-            redisService.client = null;
-            // Act & Assert
-            await expect(redisService.get('testKey'))
-                .rejects
-                .toThrow(AppError);
-            await expect(redisService.get('testKey'))
-                .rejects
-                .toThrow('Redis client not initialized');
-        });
-        it('should throw AppError when get operation fails', async () => {
-            // Arrange
-            const key = 'testKey';
-            const getError = new Error('Redis GET failed');
-            mockRedis.mockGet.mockRejectedValue(getError);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act & Assert
-            try {
-                await redisService.get(key);
-                fail('Expected get to throw AppError');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(AppError);
-                expect(error.name).toBe(CommonErrors.OPERATION_FAILED);
-            }
-        });
-    });
-    describe('set', () => {
-        it('should set a value in Redis', async () => {
-            // Arrange
-            const key = 'testKey';
-            const value = 'testValue';
-            mockRedis.mockSet.mockResolvedValue('OK');
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            await redisService.set(key, value);
-            // Assert
-            expect(mockRedis.mockSet).toHaveBeenCalledWith(key, value);
-        });
-        it('should throw AppError if client is not initialized', async () => {
-            // Arrange
-            redisService.client = null;
-            // Act & Assert
-            await expect(redisService.set('testKey', 'testValue'))
-                .rejects
-                .toThrow(AppError);
-            await expect(redisService.set('testKey', 'testValue'))
-                .rejects
-                .toThrow('Redis client not initialized');
-        });
-        it('should throw AppError when set operation fails', async () => {
-            // Arrange
-            const key = 'testKey';
-            const value = 'testValue';
-            const setError = new Error('Redis SET failed');
-            mockRedis.mockSet.mockRejectedValue(setError);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act & Assert
-            try {
-                await redisService.set(key, value);
-                fail('Expected set to throw AppError');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(AppError);
-                expect(error.name).toBe(CommonErrors.OPERATION_FAILED);
-            }
-        });
-    });
-    describe('close', () => {
-        it('should close the client connection successfully', async () => {
-            // Arrange
-            mockRedis.mockQuit.mockResolvedValue('OK');
-            redisService.client = mockRedis.mockClient;
-            redisService.retryCount = 3;
-            // Act
-            await redisService.close();
-            // Assert
-            expect(mockRedis.mockQuit).toHaveBeenCalled();
-            expect(redisService.client).toBeNull();
-            expect(redisService.retryCount).toBe(0);
-        });
-        it('should handle close error gracefully', async () => {
-            // Arrange
-            const closeError = new Error('Close failed');
-            mockRedis.mockQuit.mockRejectedValue(closeError);
-            redisService.client = mockRedis.mockClient;
-            redisService.retryCount = 2;
-            // Act
-            await redisService.close();
-            // Assert
-            expect(mockRedis.mockQuit).toHaveBeenCalled();
-            expect(redisService.client).toBeNull();
-            expect(redisService.retryCount).toBe(0);
-        });
-        it('should not throw if client is already null', async () => {
-            // Arrange
-            redisService.client = null;
-            // Act & Assert
-            await expect(redisService.close()).resolves.not.toThrow();
-            expect(mockRedis.mockQuit).not.toHaveBeenCalled();
-        });
-    });
-    describe('delete', () => {
-        it('should delete a key from Redis', async () => {
-            // Arrange
-            const key = 'testKey';
-            mockRedis.mockDel.mockResolvedValue(1);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            await redisService.delete(key);
-            // Assert
-            expect(mockRedis.mockDel).toHaveBeenCalledWith(key);
-        });
-        it('should throw AppError if client is not initialized', async () => {
-            // Arrange
-            redisService.client = null;
-            // Act & Assert
-            await expect(redisService.delete('testKey'))
-                .rejects
-                .toThrow(AppError);
-            await expect(redisService.delete('testKey'))
-                .rejects
-                .toThrow('Redis client not initialized');
-        });
-        it('should throw AppError when delete operation fails', async () => {
-            // Arrange
-            const key = 'testKey';
-            const delError = new Error('Redis DEL failed');
-            mockRedis.mockDel.mockRejectedValue(delError);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act & Assert
-            try {
-                await redisService.delete(key);
-                fail('Expected delete to throw AppError');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(AppError);
-                expect(error.name).toBe(CommonErrors.OPERATION_FAILED);
-            }
-        });
-    });
-    describe('listKeys', () => {
-        it('should list all keys from Redis using scan iteration', async () => {
-            // Arrange
-            mockRedis.mockScan
-                .mockResolvedValueOnce({ cursor: 5, keys: ['key1', 'key2'] })
-                .mockResolvedValueOnce({ cursor: 10, keys: ['key3', 'key4'] })
-                .mockResolvedValueOnce({ cursor: 0, keys: ['key5'] });
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            const result = await redisService.listKeys();
-            // Assert
-            expect(mockRedis.mockScan).toHaveBeenCalledTimes(3);
-            expect(mockRedis.mockScan).toHaveBeenCalledWith(0, { MATCH: '*', COUNT: 1000 });
-            expect(mockRedis.mockScan).toHaveBeenCalledWith(5, { MATCH: '*', COUNT: 1000 });
-            expect(mockRedis.mockScan).toHaveBeenCalledWith(10, { MATCH: '*', COUNT: 1000 });
-            expect(result).toEqual(['key1', 'key2', 'key3', 'key4', 'key5']);
-        });
-        it('should handle cursor as string and convert to number', async () => {
-            // Arrange
-            mockRedis.mockScan
-                .mockResolvedValueOnce({ cursor: '5', keys: ['key1'] })
-                .mockResolvedValueOnce({ cursor: '0', keys: ['key2'] });
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            const result = await redisService.listKeys();
-            // Assert
-            expect(mockRedis.mockScan).toHaveBeenCalledTimes(2);
-            expect(result).toEqual(['key1', 'key2']);
-        });
-        it('should return empty array when no keys exist', async () => {
-            // Arrange
-            mockRedis.mockScan.mockResolvedValueOnce({ cursor: 0, keys: [] });
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act
-            const result = await redisService.listKeys();
-            // Assert
-            expect(mockRedis.mockScan).toHaveBeenCalledTimes(1);
-            expect(result).toEqual([]);
-        });
-        it('should throw AppError if client is not initialized', async () => {
-            // Arrange
-            redisService.client = null;
-            // Act & Assert
-            await expect(redisService.listKeys())
-                .rejects
-                .toThrow(AppError);
-            await expect(redisService.listKeys())
-                .rejects
-                .toThrow('Redis client not initialized');
-        });
-        it('should throw AppError when listKeys operation fails', async () => {
-            // Arrange
-            const scanError = new Error('Redis SCAN failed');
-            mockRedis.mockScan.mockRejectedValue(scanError);
-            // Force client to be available
-            redisService.client = mockRedis.mockClient;
-            // Act & Assert
-            try {
-                await redisService.listKeys();
-                fail('Expected listKeys to throw AppError');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(AppError);
-                expect(error.name).toBe(CommonErrors.OPERATION_FAILED);
-            }
-        });
-    });
-});