mongodb-mcp-server 0.2.0 → 0.3.0

package/tests/unit/common/session.test.ts

@@ -1,60 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
-import { Session } from "../../../src/common/session.js";
-import { config } from "../../../src/common/config.js";
-
-vi.mock("@mongosh/service-provider-node-driver");
-const MockNodeDriverServiceProvider = vi.mocked(NodeDriverServiceProvider);
-
-describe("Session", () => {
-    let session: Session;
-    beforeEach(() => {
-        session = new Session({
-            apiClientId: "test-client-id",
-            apiBaseUrl: "https://api.test.com",
-        });
-
-        MockNodeDriverServiceProvider.connect = vi.fn().mockResolvedValue({} as unknown as NodeDriverServiceProvider);
-    });
-
-    describe("connectToMongoDB", () => {
-        const testCases: {
-            connectionString: string;
-            expectAppName: boolean;
-            name: string;
-        }[] = [
-            {
-                connectionString: "mongodb://localhost:27017",
-                expectAppName: true,
-                name: "db without appName",
-            },
-            {
-                connectionString: "mongodb://localhost:27017?appName=CustomAppName",
-                expectAppName: false,
-                name: "db with custom appName",
-            },
-            {
-                connectionString:
-                    "mongodb+srv://test.mongodb.net/test?retryWrites=true&w=majority&appName=CustomAppName",
-                expectAppName: false,
-                name: "atlas db with custom appName",
-            },
-        ];
-
-        for (const testCase of testCases) {
-            it(`should update connection string for ${testCase.name}`, async () => {
-                await session.connectToMongoDB(testCase.connectionString, config.connectOptions);
-                expect(session.serviceProvider).toBeDefined();
-
-                const connectMock = MockNodeDriverServiceProvider.connect;
-                expect(connectMock).toHaveBeenCalledOnce();
-                const connectionString = connectMock.mock.calls[0]?.[0];
-                if (testCase.expectAppName) {
-                    expect(connectionString).toContain("appName=MongoDB+MCP+Server");
-                } else {
-                    expect(connectionString).not.toContain("appName=MongoDB+MCP+Server");
-                }
-            });
-        }
-    });
-});

package/tests/unit/helpers/indexCheck.test.ts

@@ -1,150 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { usesIndex, getIndexCheckErrorMessage } from "../../../src/helpers/indexCheck.js";
-import { Document } from "mongodb";
-
-describe("indexCheck", () => {
-    describe("usesIndex", () => {
-        it("should return true for IXSCAN", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "IXSCAN",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for COUNT_SCAN", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "COUNT_SCAN",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for IDHACK", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "IDHACK",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for EXPRESS_IXSCAN (MongoDB 8.0+)", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "EXPRESS_IXSCAN",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for EXPRESS_CLUSTERED_IXSCAN (MongoDB 8.0+)", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "EXPRESS_CLUSTERED_IXSCAN",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for EXPRESS_UPDATE (MongoDB 8.0+)", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "EXPRESS_UPDATE",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for EXPRESS_DELETE (MongoDB 8.0+)", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "EXPRESS_DELETE",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return false for COLLSCAN", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "COLLSCAN",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(false);
-        });
-
-        it("should return true for nested IXSCAN in inputStage", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "LIMIT",
-                        inputStage: {
-                            stage: "IXSCAN",
-                        },
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return true for nested EXPRESS_IXSCAN in inputStage", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "SORT",
-                        inputStage: {
-                            stage: "EXPRESS_IXSCAN",
-                        },
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(true);
-        });
-
-        it("should return false for unknown stage types", () => {
-            const explainResult: Document = {
-                queryPlanner: {
-                    winningPlan: {
-                        stage: "UNKNOWN_STAGE",
-                    },
-                },
-            };
-            expect(usesIndex(explainResult)).toBe(false);
-        });
-
-        it("should handle missing queryPlanner", () => {
-            const explainResult: Document = {};
-            expect(usesIndex(explainResult)).toBe(false);
-        });
-    });
-
-    describe("getIndexCheckErrorMessage", () => {
-        it("should generate appropriate error message", () => {
-            const message = getIndexCheckErrorMessage("testdb", "testcoll", "find");
-            expect(message).toContain("Index check failed");
-            expect(message).toContain("testdb.testcoll");
-            expect(message).toContain("find operation");
-            expect(message).toContain("collection scan (COLLSCAN)");
-            expect(message).toContain("MDB_MCP_INDEX_CHECK");
-        });
-    });
-});

package/tests/unit/telemetry.test.ts

@@ -1,332 +0,0 @@
-import { ApiClient } from "../../src/common/atlas/apiClient.js";
-import { Session } from "../../src/common/session.js";
-import { DEVICE_ID_TIMEOUT, Telemetry } from "../../src/telemetry/telemetry.js";
-import { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
-import { EventCache } from "../../src/telemetry/eventCache.js";
-import { config } from "../../src/common/config.js";
-import { afterEach, beforeEach, describe, it, vi, expect } from "vitest";
-import logger, { LogId } from "../../src/common/logger.js";
-import { createHmac } from "crypto";
-import type { MockedFunction } from "vitest";
-
-// Mock the ApiClient to avoid real API calls
-vi.mock("../../src/common/atlas/apiClient.js");
-const MockApiClient = vi.mocked(ApiClient);
-
-// Mock EventCache to control and verify caching behavior
-vi.mock("../../src/telemetry/eventCache.js");
-const MockEventCache = vi.mocked(EventCache);
-
-describe("Telemetry", () => {
-    const machineId = "test-machine-id";
-    const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
-
-    let mockApiClient: {
-        sendEvents: MockedFunction<(events: BaseEvent[]) => Promise<void>>;
-        hasCredentials: MockedFunction<() => boolean>;
-    };
-    let mockEventCache: {
-        getEvents: MockedFunction<() => BaseEvent[]>;
-        clearEvents: MockedFunction<() => Promise<void>>;
-        appendEvents: MockedFunction<(events: BaseEvent[]) => Promise<void>>;
-    };
-    let session: Session;
-    let telemetry: Telemetry;
-
-    // Helper function to create properly typed test events
-    function createTestEvent(options?: {
-        result?: TelemetryResult;
-        component?: string;
-        category?: string;
-        command?: string;
-        duration_ms?: number;
-    }): Omit<BaseEvent, "properties"> & {
-        properties: {
-            component: string;
-            duration_ms: number;
-            result: TelemetryResult;
-            category: string;
-            command: string;
-        };
-    } {
-        return {
-            timestamp: new Date().toISOString(),
-            source: "mdbmcp",
-            properties: {
-                component: options?.component || "test-component",
-                duration_ms: options?.duration_ms || 100,
-                result: options?.result || "success",
-                category: options?.category || "test",
-                command: options?.command || "test-command",
-            },
-        };
-    }
-
-    // Helper function to verify mock calls to reduce duplication
-    function verifyMockCalls({
-        sendEventsCalls = 0,
-        clearEventsCalls = 0,
-        appendEventsCalls = 0,
-        sendEventsCalledWith = undefined,
-        appendEventsCalledWith = undefined,
-    }: {
-        sendEventsCalls?: number;
-        clearEventsCalls?: number;
-        appendEventsCalls?: number;
-        sendEventsCalledWith?: BaseEvent[] | undefined;
-        appendEventsCalledWith?: BaseEvent[] | undefined;
-    } = {}) {
-        const { calls: sendEvents } = mockApiClient.sendEvents.mock;
-        const { calls: clearEvents } = mockEventCache.clearEvents.mock;
-        const { calls: appendEvents } = mockEventCache.appendEvents.mock;
-
-        expect(sendEvents.length).toBe(sendEventsCalls);
-        expect(clearEvents.length).toBe(clearEventsCalls);
-        expect(appendEvents.length).toBe(appendEventsCalls);
-
-        if (sendEventsCalledWith) {
-            expect(sendEvents[0]?.[0]).toEqual(
-                sendEventsCalledWith.map((event) => ({
-                    ...event,
-                    properties: {
-                        ...telemetry.getCommonProperties(),
-                        ...event.properties,
-                    },
-                }))
-            );
-        }
-
-        if (appendEventsCalledWith) {
-            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
-        }
-    }
-
-    beforeEach(() => {
-        // Reset mocks before each test
-        vi.clearAllMocks();
-
-        // Setup mocked API client
-        mockApiClient = vi.mocked(new MockApiClient({ baseUrl: "" }));
-
-        mockApiClient.sendEvents = vi.fn().mockResolvedValue(undefined);
-        mockApiClient.hasCredentials = vi.fn().mockReturnValue(true);
-
-        // Setup mocked EventCache
-        mockEventCache = new MockEventCache() as unknown as typeof mockEventCache;
-        mockEventCache.getEvents = vi.fn().mockReturnValue([]);
-        mockEventCache.clearEvents = vi.fn().mockResolvedValue(undefined);
-        mockEventCache.appendEvents = vi.fn().mockResolvedValue(undefined);
-        MockEventCache.getInstance = vi.fn().mockReturnValue(mockEventCache as unknown as EventCache);
-
-        // Create a simplified session with our mocked API client
-        session = {
-            apiClient: mockApiClient as unknown as ApiClient,
-            sessionId: "test-session-id",
-            agentRunner: { name: "test-agent", version: "1.0.0" } as const,
-            close: vi.fn().mockResolvedValue(undefined),
-            setAgentRunner: vi.fn().mockResolvedValue(undefined),
-        } as unknown as Session;
-
-        telemetry = Telemetry.create(session, config, {
-            eventCache: mockEventCache as unknown as EventCache,
-            getRawMachineId: () => Promise.resolve(machineId),
-        });
-
-        config.telemetry = "enabled";
-    });
-
-    describe("sending events", () => {
-        describe("when telemetry is enabled", () => {
-            it("should send events successfully", async () => {
-                const testEvent = createTestEvent();
-
-                await telemetry.setupPromise;
-
-                await telemetry.emitEvents([testEvent]);
-
-                verifyMockCalls({
-                    sendEventsCalls: 1,
-                    clearEventsCalls: 1,
-                    sendEventsCalledWith: [testEvent],
-                });
-            });
-
-            it("should cache events when sending fails", async () => {
-                mockApiClient.sendEvents.mockRejectedValueOnce(new Error("API error"));
-
-                const testEvent = createTestEvent();
-
-                await telemetry.setupPromise;
-
-                await telemetry.emitEvents([testEvent]);
-
-                verifyMockCalls({
-                    sendEventsCalls: 1,
-                    appendEventsCalls: 1,
-                    appendEventsCalledWith: [testEvent],
-                });
-            });
-
-            it("should include cached events when sending", async () => {
-                const cachedEvent = createTestEvent({
-                    command: "cached-command",
-                    component: "cached-component",
-                });
-
-                const newEvent = createTestEvent({
-                    command: "new-command",
-                    component: "new-component",
-                });
-
-                // Set up mock to return cached events
-                mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
-
-                await telemetry.setupPromise;
-
-                await telemetry.emitEvents([newEvent]);
-
-                verifyMockCalls({
-                    sendEventsCalls: 1,
-                    clearEventsCalls: 1,
-                    sendEventsCalledWith: [cachedEvent, newEvent],
-                });
-            });
-
-            it("should correctly add common properties to events", async () => {
-                await telemetry.setupPromise;
-
-                const commonProps = telemetry.getCommonProperties();
-
-                // Use explicit type assertion
-                const expectedProps: Record<string, string> = {
-                    mcp_client_version: "1.0.0",
-                    mcp_client_name: "test-agent",
-                    session_id: "test-session-id",
-                    config_atlas_auth: "true",
-                    config_connection_string: expect.any(String) as unknown as string,
-                    device_id: hashedMachineId,
-                };
-
-                expect(commonProps).toMatchObject(expectedProps);
-            });
-
-            describe("machine ID resolution", () => {
-                beforeEach(() => {
-                    vi.clearAllMocks();
-                    vi.useFakeTimers();
-                });
-
-                afterEach(() => {
-                    vi.clearAllMocks();
-                    vi.useRealTimers();
-                });
-
-                it("should successfully resolve the machine ID", async () => {
-                    telemetry = Telemetry.create(session, config, {
-                        getRawMachineId: () => Promise.resolve(machineId),
-                    });
-
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-
-                    await telemetry.setupPromise;
-
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
-                });
-
-                it("should handle machine ID resolution failure", async () => {
-                    const loggerSpy = vi.spyOn(logger, "debug");
-
-                    telemetry = Telemetry.create(session, config, {
-                        getRawMachineId: () => Promise.reject(new Error("Failed to get device ID")),
-                    });
-
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-
-                    await telemetry.setupPromise;
-
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
-
-                    expect(loggerSpy).toHaveBeenCalledWith(
-                        LogId.telemetryDeviceIdFailure,
-                        "telemetry",
-                        "Error: Failed to get device ID"
-                    );
-                });
-
-                it("should timeout if machine ID resolution takes too long", async () => {
-                    const loggerSpy = vi.spyOn(logger, "debug");
-
-                    telemetry = Telemetry.create(session, config, { getRawMachineId: () => new Promise(() => {}) });
-
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-
-                    vi.advanceTimersByTime(DEVICE_ID_TIMEOUT / 2);
-
-                    // Make sure the timeout doesn't happen prematurely.
-                    expect(telemetry["isBufferingEvents"]).toBe(true);
-                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-
-                    vi.advanceTimersByTime(DEVICE_ID_TIMEOUT);
-
-                    await telemetry.setupPromise;
-
-                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
-                    expect(telemetry["isBufferingEvents"]).toBe(false);
-                    expect(loggerSpy).toHaveBeenCalledWith(
-                        LogId.telemetryDeviceIdTimeout,
-                        "telemetry",
-                        "Device ID retrieval timed out"
-                    );
-                });
-            });
-        });
-
-        describe("when telemetry is disabled", () => {
-            beforeEach(() => {
-                config.telemetry = "disabled";
-            });
-
-            afterEach(() => {
-                config.telemetry = "enabled";
-            });
-
-            it("should not send events", async () => {
-                const testEvent = createTestEvent();
-
-                await telemetry.emitEvents([testEvent]);
-
-                verifyMockCalls();
-            });
-        });
-
-        describe("when DO_NOT_TRACK environment variable is set", () => {
-            let originalEnv: string | undefined;
-
-            beforeEach(() => {
-                originalEnv = process.env.DO_NOT_TRACK;
-                process.env.DO_NOT_TRACK = "1";
-            });
-
-            afterEach(() => {
-                if (originalEnv) {
-                    process.env.DO_NOT_TRACK = originalEnv;
-                } else {
-                    delete process.env.DO_NOT_TRACK;
-                }
-            });
-
-            it("should not send events", async () => {
-                const testEvent = createTestEvent();
-
-                await telemetry.emitEvents([testEvent]);
-
-                verifyMockCalls();
-            });
-        });
-    });
-});

package/tests/unit/transports/stdio.test.ts

@@ -1,71 +0,0 @@
-import { Decimal128, MaxKey, MinKey, ObjectId, Timestamp, UUID } from "bson";
-import { createStdioTransport, EJsonReadBuffer } from "../../../src/transports/stdio.js";
-import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { Readable } from "stream";
-import { ReadBuffer } from "@modelcontextprotocol/sdk/shared/stdio.js";
-import { describe, expect, it, beforeEach, afterEach } from "vitest";
-describe("stdioTransport", () => {
-    let transport: StdioServerTransport;
-    beforeEach(async () => {
-        transport = createStdioTransport();
-        await transport.start();
-    });
-
-    afterEach(async () => {
-        await transport.close();
-    });
-
-    it("ejson deserializes messages", () => {
-        const messages: { message: JSONRPCMessage; extra?: { authInfo?: AuthInfo } }[] = [];
-        transport.onmessage = (
-            message,
-            extra?: {
-                authInfo?: AuthInfo;
-            }
-        ) => {
-            messages.push({ message, extra });
-        };
-
-        (transport["_stdin"] as Readable).emit(
-            "data",
-            Buffer.from(
-                '{"jsonrpc":"2.0","id":1,"method":"testMethod","params":{"oid":{"$oid":"681b741f13aa74a0687b5110"},"uuid":{"$uuid":"f81d4fae-7dec-11d0-a765-00a0c91e6bf6"},"date":{"$date":"2025-05-07T14:54:23.973Z"},"decimal":{"$numberDecimal":"1234567890987654321"},"int32":123,"maxKey":{"$maxKey":1},"minKey":{"$minKey":1},"timestamp":{"$timestamp":{"t":123,"i":456}}}}\n',
-                "utf-8"
-            )
-        );
-
-        expect(messages.length).toBe(1);
-        const message = messages[0]?.message;
-
-        expect(message).toEqual({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "testMethod",
-            params: {
-                oid: new ObjectId("681b741f13aa74a0687b5110"),
-                uuid: new UUID("f81d4fae-7dec-11d0-a765-00a0c91e6bf6"),
-                date: new Date(Date.parse("2025-05-07T14:54:23.973Z")),
-                decimal: new Decimal128("1234567890987654321"),
-                int32: 123,
-                maxKey: new MaxKey(),
-                minKey: new MinKey(),
-                timestamp: new Timestamp({ t: 123, i: 456 }),
-            },
-        });
-    });
-
-    it("has _readBuffer field of type EJsonReadBuffer", () => {
-        expect(transport["_readBuffer"]).toBeDefined();
-        expect(transport["_readBuffer"]).toBeInstanceOf(EJsonReadBuffer);
-    });
-
-    describe("standard StdioServerTransport", () => {
-        it("has a _readBuffer field", () => {
-            const standardTransport = new StdioServerTransport();
-            expect(standardTransport["_readBuffer"]).toBeDefined();
-            expect(standardTransport["_readBuffer"]).toBeInstanceOf(ReadBuffer);
-        });
-    });
-});

package/tests/vitest.d.ts

@@ -1,11 +0,0 @@
-import "vitest";
-
-declare module "vitest" {
-    interface Assertion<T = unknown> {
-        toIncludeSameMembers<U>(expected: U[]): T;
-    }
-
-    interface AsymmetricMatchersContaining {
-        toIncludeSameMembers<T>(expected: T[]): unknown;
-    }
-}

package/tsconfig.build.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "strict": true,
-    "strictNullChecks": true,
-    "noUncheckedIndexedAccess": true,
-    "esModuleInterop": true,
-    "types": ["node"],
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "typeRoots": ["./node_modules/@types", "./src/types"]
-  },
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.build.json",
-  "compilerOptions": {
-    "rootDir": ".",
-    "skipLibCheck": true
-  },
-  "include": ["**/*"]
-}

package/tsconfig.test.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.build.json",
-  "compilerOptions": {
-    "isolatedModules": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*.ts", "tests/**/*.ts"]
-}