@falkordb/mcpserver 1.0.1

package/dist/utils/connection-parser.test.js

@@ -0,0 +1,232 @@
+import { parseFalkorDBConnectionString } from './connection-parser';
+describe('Connection Parser Utility', () => {
+    // Mock console.error to avoid noise in test output
+    let consoleErrorSpy;
+    beforeEach(() => {
+        consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+    });
+    describe('parseFalkorDBConnectionString', () => {
+        it('should return default options for empty string', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('');
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 6379
+            });
+        });
+        it('should return default options for undefined input', () => {
+            // Act
+            const result = parseFalkorDBConnectionString(undefined);
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 6379
+            });
+        });
+        it('should return default options for null input', () => {
+            // Act
+            const result = parseFalkorDBConnectionString(null);
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 6379
+            });
+        });
+        it('should parse simple host', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('redis.example.com');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 6379
+            });
+        });
+        it('should parse host with port', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234
+            });
+        });
+        it('should parse host with invalid port (use default)', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('redis.example.com:invalid');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 6379
+            });
+        });
+        it('should parse connection string with protocol prefix', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234
+            });
+        });
+        it('should parse connection string with username and password', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user:pass@redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234,
+                username: 'user',
+                password: 'pass'
+            });
+        });
+        it('should parse connection string with only password', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://mypassword@redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234,
+                password: 'mypassword'
+            });
+        });
+        it('should parse connection string with empty username', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://:password@redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234,
+                password: 'password'
+            });
+        });
+        it('should parse connection string with empty password', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://username:@redis.example.com:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 1234,
+                username: 'username'
+            });
+        });
+        it('should handle missing host part with default', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 1234
+            });
+        });
+        it('should handle missing port part with default', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://redis.example.com:');
+            // Assert
+            expect(result).toEqual({
+                host: 'redis.example.com',
+                port: 6379
+            });
+        });
+        it('should handle auth with missing host part', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user:pass@:1234');
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 1234,
+                username: 'user',
+                password: 'pass'
+            });
+        });
+        it('should handle complex real-world connection string', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://admin:secret123@prod-redis.company.com:16379');
+            // Assert
+            expect(result).toEqual({
+                host: 'prod-redis.company.com',
+                port: 16379,
+                username: 'admin',
+                password: 'secret123'
+            });
+        });
+        it('should handle localhost with auth', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user:pass@localhost:6379');
+            // Assert
+            expect(result).toEqual({
+                host: 'localhost',
+                port: 6379,
+                username: 'user',
+                password: 'pass'
+            });
+        });
+        it('should handle IPv4 address', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://192.168.1.100:6379');
+            // Assert
+            expect(result).toEqual({
+                host: '192.168.1.100',
+                port: 6379
+            });
+        });
+        it('should handle IPv4 address with auth', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user:pass@192.168.1.100:6379');
+            // Assert
+            expect(result).toEqual({
+                host: '192.168.1.100',
+                port: 6379,
+                username: 'user',
+                password: 'pass'
+            });
+        });
+        it('should return defaults on parsing error and log error', () => {
+            // Arrange - create a scenario that might cause parsing issues
+            // We'll simulate this by mocking parseInt to throw
+            const originalParseInt = global.parseInt;
+            global.parseInt = jest.fn(() => {
+                throw new Error('Parsing error');
+            });
+            try {
+                // Act
+                const result = parseFalkorDBConnectionString('falkordb://host:port');
+                // Assert
+                expect(result).toEqual({
+                    host: 'localhost',
+                    port: 6379
+                });
+                expect(consoleErrorSpy).toHaveBeenCalledWith('Error parsing connection string:', expect.any(Error));
+            }
+            finally {
+                // Cleanup
+                global.parseInt = originalParseInt;
+            }
+        });
+        it('should handle edge case with multiple @ symbols', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user@domain:pass@host:1234');
+            // Assert - after fixing parser to use lastIndexOf('@')
+            expect(result).toEqual({
+                host: 'host',
+                port: 1234,
+                username: 'user@domain',
+                password: 'pass'
+            });
+        });
+        it('should handle edge case with multiple : in auth', () => {
+            // Act
+            const result = parseFalkorDBConnectionString('falkordb://user:pass:extra@host:1234');
+            // Assert - after fixing parser to properly rejoin password with multiple ':'
+            expect(result).toEqual({
+                host: 'host',
+                port: 1234,
+                username: 'user',
+                password: 'pass:extra'
+            });
+        });
+    });
+});

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@falkordb/mcpserver",
+  "version": "1.0.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",
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FalkorDB/FalkorDB-MCPServer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/FalkorDB/FalkorDB-MCPServer/issues"
+  },
+  "homepage": "https://github.com/FalkorDB/FalkorDB-MCPServer#readme",
+  "author": {
+    "name": "Katie Mulliken",
+    "email": "katie@mulliken.net",
+    "url": "https://github.com/SecKatie"
+  },
+  "license": "MIT",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "falkordb",
+    "graph-database",
+    "knowledge-graph",
+    "ai",
+    "claude",
+    "opencypher",
+    "cypher",
+    "redis",
+    "graph",
+    "database",
+    "typescript",
+    "server",
+    "chatbot",
+    "llm",
+    "anthropic",
+    "neo4j",
+    "graph-query"
+  ],
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "bin": {
+    "falkordb-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "nodemon --watch 'src/**/*.ts' --exec 'npm run build && npm start'",
+    "dev:ts": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/index.ts",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --coverage --ci --watchAll=false",
+    "inspect": "npm run build && npx -y @modelcontextprotocol/inspector node $PWD/dist/index.js",
+    "clean": "rm -rf dist coverage",
+    "prepublish": "npm run test:ci && npm run lint && npm run build",
+    "prepublishOnly": "npm run clean && npm run test:ci && npm run lint && npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.14.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.31.0",
+    "jest": "^30.0.5",
+    "nodemon": "^3.1.10",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.17.0",
+    "dotenv": "^17.2.1",
+    "falkordb": "^6.3.0",
+    "platformdirs": "^4.3.8-rc3",
+    "redis": "^4.0.0",
+    "zod": "^3.23.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/SecKatie"
+  }
+}