mongodb-mcp-server 0.0.8 → 0.1.1

package/tests/unit/apiClient.test.ts

@@ -0,0 +1,193 @@
+import { jest } from "@jest/globals";
+import { ApiClient } from "../../src/common/atlas/apiClient.js";
+import { CommonProperties, TelemetryEvent, TelemetryResult } from "../../src/telemetry/types.js";
+
+describe("ApiClient", () => {
+    let apiClient: ApiClient;
+
+    const mockEvents: TelemetryEvent<CommonProperties>[] = [
+        {
+            timestamp: new Date().toISOString(),
+            source: "mdbmcp",
+            properties: {
+                mcp_client_version: "1.0.0",
+                mcp_client_name: "test-client",
+                mcp_server_version: "1.0.0",
+                mcp_server_name: "test-server",
+                platform: "test-platform",
+                arch: "test-arch",
+                os_type: "test-os",
+                component: "test-component",
+                duration_ms: 100,
+                result: "success" as TelemetryResult,
+                category: "test-category",
+            },
+        },
+    ];
+
+    beforeEach(() => {
+        apiClient = new ApiClient({
+            baseUrl: "https://api.test.com",
+            credentials: {
+                clientId: "test-client-id",
+                clientSecret: "test-client-secret",
+            },
+            userAgent: "test-user-agent",
+        });
+
+        // @ts-expect-error accessing private property for testing
+        apiClient.getAccessToken = jest.fn().mockResolvedValue("mockToken");
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe("constructor", () => {
+        it("should create a client with the correct configuration", () => {
+            expect(apiClient).toBeDefined();
+            expect(apiClient.hasCredentials()).toBeDefined();
+        });
+    });
+
+    describe("listProjects", () => {
+        it("should return a list of projects", async () => {
+            const mockProjects = {
+                results: [
+                    { id: "1", name: "Project 1" },
+                    { id: "2", name: "Project 2" },
+                ],
+                totalCount: 2,
+            };
+
+            const mockGet = jest.fn().mockImplementation(() => ({
+                data: mockProjects,
+                error: null,
+                response: new Response(),
+            }));
+
+            // @ts-expect-error accessing private property for testing
+            apiClient.client.GET = mockGet;
+
+            const result = await apiClient.listProjects();
+
+            expect(mockGet).toHaveBeenCalledWith("/api/atlas/v2/groups", undefined);
+            expect(result).toEqual(mockProjects);
+        });
+
+        it("should throw an error when the API call fails", async () => {
+            const mockError = {
+                reason: "Test error",
+                detail: "Something went wrong",
+            };
+
+            const mockGet = jest.fn().mockImplementation(() => ({
+                data: null,
+                error: mockError,
+                response: new Response(),
+            }));
+
+            // @ts-expect-error accessing private property for testing
+            apiClient.client.GET = mockGet;
+
+            await expect(apiClient.listProjects()).rejects.toThrow();
+        });
+    });
+
+    describe("sendEvents", () => {
+        it("should send events to authenticated endpoint when token is available and valid", async () => {
+            const mockFetch = jest.spyOn(global, "fetch");
+            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+            await apiClient.sendEvents(mockEvents);
+
+            const url = new URL("api/private/v1.0/telemetry/events", "https://api.test.com");
+            expect(mockFetch).toHaveBeenCalledWith(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Bearer mockToken",
+                    Accept: "application/json",
+                    "User-Agent": "test-user-agent",
+                },
+                body: JSON.stringify(mockEvents),
+            });
+        });
+
+        it("should fall back to unauthenticated endpoint when token is not available via exception", async () => {
+            const mockFetch = jest.spyOn(global, "fetch");
+            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+            // @ts-expect-error accessing private property for testing
+            apiClient.getAccessToken = jest.fn().mockRejectedValue(new Error("No access token available"));
+
+            await apiClient.sendEvents(mockEvents);
+
+            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
+            expect(mockFetch).toHaveBeenCalledWith(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    "User-Agent": "test-user-agent",
+                },
+                body: JSON.stringify(mockEvents),
+            });
+        });
+
+        it("should fall back to unauthenticated endpoint when token is undefined", async () => {
+            const mockFetch = jest.spyOn(global, "fetch");
+            mockFetch.mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+            // @ts-expect-error accessing private property for testing
+            apiClient.getAccessToken = jest.fn().mockReturnValueOnce(undefined);
+
+            await apiClient.sendEvents(mockEvents);
+
+            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
+            expect(mockFetch).toHaveBeenCalledWith(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    "User-Agent": "test-user-agent",
+                },
+                body: JSON.stringify(mockEvents),
+            });
+        });
+
+        it("should fall back to unauthenticated endpoint on 401 error", async () => {
+            const mockFetch = jest.spyOn(global, "fetch");
+            mockFetch
+                .mockResolvedValueOnce(new Response(null, { status: 401 }))
+                .mockResolvedValueOnce(new Response(null, { status: 200 }));
+
+            await apiClient.sendEvents(mockEvents);
+
+            const url = new URL("api/private/unauth/telemetry/events", "https://api.test.com");
+            expect(mockFetch).toHaveBeenCalledTimes(2);
+            expect(mockFetch).toHaveBeenLastCalledWith(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    "User-Agent": "test-user-agent",
+                },
+                body: JSON.stringify(mockEvents),
+            });
+        });
+
+        it("should throw error when both authenticated and unauthenticated requests fail", async () => {
+            const mockFetch = jest.spyOn(global, "fetch");
+            mockFetch
+                .mockResolvedValueOnce(new Response(null, { status: 401 }))
+                .mockResolvedValueOnce(new Response(null, { status: 500 }));
+
+            const mockToken = "test-token";
+            // @ts-expect-error accessing private property for testing
+            apiClient.getAccessToken = jest.fn().mockResolvedValue(mockToken);
+
+            await expect(apiClient.sendEvents(mockEvents)).rejects.toThrow();
+        });
+    });
+});

package/tests/unit/session.test.ts

@@ -0,0 +1,65 @@
+import { jest } from "@jest/globals";
+import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
+import { Session } from "../../src/session.js";
+import { config } from "../../src/config.js";
+
+jest.mock("@mongosh/service-provider-node-driver");
+const MockNodeDriverServiceProvider = NodeDriverServiceProvider as jest.MockedClass<typeof NodeDriverServiceProvider>;
+
+describe("Session", () => {
+    let session: Session;
+    beforeEach(() => {
+        session = new Session({
+            apiClientId: "test-client-id",
+            apiBaseUrl: "https://api.test.com",
+        });
+
+        MockNodeDriverServiceProvider.connect = jest.fn(() =>
+            Promise.resolve({} 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();
+
+                // eslint-disable-next-line @typescript-eslint/unbound-method
+                const connectMock = MockNodeDriverServiceProvider.connect as jest.Mock<
+                    typeof NodeDriverServiceProvider.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/telemetry.test.ts

@@ -1,10 +1,12 @@
 import { ApiClient } from "../../src/common/atlas/apiClient.js";
 import { Session } from "../../src/session.js";
-import { Telemetry } from "../../src/telemetry/telemetry.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/config.js";
 import { jest } from "@jest/globals";
+import logger, { LogId } from "../../src/logger.js";
+import { createHmac } from "crypto";
 
 // Mock the ApiClient to avoid real API calls
 jest.mock("../../src/common/atlas/apiClient.js");
@@ -15,6 +17,9 @@ jest.mock("../../src/telemetry/eventCache.js");
 const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
 
 describe("Telemetry", () => {
+    const machineId = "test-machine-id";
+    const hashedMachineId = createHmac("sha256", machineId.toUpperCase()).update("atlascli").digest("hex");
+
     let mockApiClient: jest.Mocked<ApiClient>;
     let mockEventCache: jest.Mocked<EventCache>;
     let session: Session;
@@ -120,109 +125,198 @@ describe("Telemetry", () => {
             setAgentRunner: jest.fn().mockResolvedValue(undefined),
         } as unknown as Session;
 
-        // Create the telemetry instance with mocked dependencies
-        telemetry = new Telemetry(session, config, mockEventCache);
+        telemetry = Telemetry.create(session, config, {
+            eventCache: mockEventCache,
+            getRawMachineId: () => Promise.resolve(machineId),
+        });
+
         config.telemetry = "enabled";
     });
 
-    describe("when telemetry is enabled", () => {
-        it("should send events successfully", async () => {
-            const testEvent = createTestEvent();
+    describe("sending events", () => {
+        describe("when telemetry is enabled", () => {
+            it("should send events successfully", async () => {
+                const testEvent = createTestEvent();
 
-            await telemetry.emitEvents([testEvent]);
+                await telemetry.emitEvents([testEvent]);
 
-            verifyMockCalls({
-                sendEventsCalls: 1,
-                clearEventsCalls: 1,
-                sendEventsCalledWith: [testEvent],
+                verifyMockCalls({
+                    sendEventsCalls: 1,
+                    clearEventsCalls: 1,
+                    sendEventsCalledWith: [testEvent],
+                });
             });
-        });
 
-        it("should cache events when sending fails", async () => {
-            mockApiClient.sendEvents.mockRejectedValueOnce(new Error("API error"));
+            it("should cache events when sending fails", async () => {
+                mockApiClient.sendEvents.mockRejectedValueOnce(new Error("API error"));
 
-            const testEvent = createTestEvent();
+                const testEvent = createTestEvent();
 
-            await telemetry.emitEvents([testEvent]);
+                await telemetry.emitEvents([testEvent]);
 
-            verifyMockCalls({
-                sendEventsCalls: 1,
-                appendEventsCalls: 1,
-                appendEventsCalledWith: [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",
-            });
+            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",
+                const newEvent = createTestEvent({
+                    command: "new-command",
+                    component: "new-component",
+                });
+
+                // Set up mock to return cached events
+                mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
+
+                await telemetry.emitEvents([newEvent]);
+
+                verifyMockCalls({
+                    sendEventsCalls: 1,
+                    clearEventsCalls: 1,
+                    sendEventsCalledWith: [cachedEvent, newEvent],
+                });
             });
 
-            // Set up mock to return cached events
-            mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
+            it("should correctly add common properties to events", () => {
+                const commonProps = telemetry.getCommonProperties();
 
-            await telemetry.emitEvents([newEvent]);
+                // 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,
+                };
 
-            verifyMockCalls({
-                sendEventsCalls: 1,
-                clearEventsCalls: 1,
-                sendEventsCalledWith: [cachedEvent, newEvent],
+                expect(commonProps).toMatchObject(expectedProps);
             });
-        });
-    });
 
-    describe("when telemetry is disabled", () => {
-        beforeEach(() => {
-            config.telemetry = "disabled";
-        });
+            describe("machine ID resolution", () => {
+                beforeEach(() => {
+                    jest.clearAllMocks();
+                    jest.useFakeTimers();
+                });
 
-        it("should not send events", async () => {
-            const testEvent = createTestEvent();
+                afterEach(() => {
+                    jest.clearAllMocks();
+                    jest.useRealTimers();
+                });
 
-            await telemetry.emitEvents([testEvent]);
+                it("should successfully resolve the machine ID", async () => {
+                    telemetry = Telemetry.create(session, config, {
+                        getRawMachineId: () => Promise.resolve(machineId),
+                    });
 
-            verifyMockCalls();
-        });
-    });
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
 
-    it("should correctly add common properties to events", () => {
-        const commonProps = telemetry.getCommonProperties();
+                    await telemetry.deviceIdPromise;
 
-        // 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,
-        };
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe(hashedMachineId);
+                });
 
-        expect(commonProps).toMatchObject(expectedProps);
-    });
+                it("should handle machine ID resolution failure", async () => {
+                    const loggerSpy = jest.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.deviceIdPromise;
+
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+
+                    expect(loggerSpy).toHaveBeenCalledWith(
+                        LogId.telemetryDeviceIdFailure,
+                        "telemetry",
+                        "Error: Failed to get device ID"
+                    );
+                });
 
-    describe("when DO_NOT_TRACK environment variable is set", () => {
-        let originalEnv: string | undefined;
+                it("should timeout if machine ID resolution takes too long", async () => {
+                    const loggerSpy = jest.spyOn(logger, "debug");
 
-        beforeEach(() => {
-            originalEnv = process.env.DO_NOT_TRACK;
-            process.env.DO_NOT_TRACK = "1";
+                    telemetry = Telemetry.create(session, config, { getRawMachineId: () => new Promise(() => {}) });
+
+                    expect(telemetry["isBufferingEvents"]).toBe(true);
+                    expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+
+                    jest.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);
+
+                    jest.advanceTimersByTime(DEVICE_ID_TIMEOUT);
+
+                    await telemetry.deviceIdPromise;
+
+                    expect(telemetry.getCommonProperties().device_id).toBe("unknown");
+                    expect(telemetry["isBufferingEvents"]).toBe(false);
+                    expect(loggerSpy).toHaveBeenCalledWith(
+                        LogId.telemetryDeviceIdTimeout,
+                        "telemetry",
+                        "Device ID retrieval timed out"
+                    );
+                });
+            });
         });
 
-        afterEach(() => {
-            process.env.DO_NOT_TRACK = originalEnv;
+        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();
+            });
         });
 
-        it("should not send events", async () => {
-            const testEvent = createTestEvent();
+        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;
+                }
+            });
 
-            await telemetry.emitEvents([testEvent]);
+            it("should not send events", async () => {
+                const testEvent = createTestEvent();
 
-            verifyMockCalls();
+                await telemetry.emitEvents([testEvent]);
+
+                verifyMockCalls();
+            });
         });
     });
 });

package/tsconfig.build.json

@@ -8,7 +8,7 @@
     "strict": true,
     "strictNullChecks": true,
     "esModuleInterop": true,
-    "types": ["node", "jest"],
+    "types": ["node"],
     "sourceMap": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,

package/dist/packageInfo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"packageInfo.js","sourceRoot":"","sources":["../src/packageInfo.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,iBAAiB,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAEhE,MAAM,CAAC,MAAM,WAAW,GAAG;IACvB,OAAO,EAAE,WAAW,CAAC,OAAO;IAC5B,aAAa,EAAE,oBAAoB;CACtC,CAAC"}

package/dist/telemetry/device-id.js

@@ -1,20 +0,0 @@
-import { createHmac } from "crypto";
-import nodeMachineId from "node-machine-id";
-import logger, { LogId } from "../logger.js";
-export function getDeviceId() {
-    try {
-        const originalId = nodeMachineId.machineIdSync(true);
-        // Create a hashed format from the all uppercase version of the machine ID
-        // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.
-        const hmac = createHmac("sha256", originalId.toUpperCase());
-        /** This matches the message used to create the hashes in Atlas CLI */
-        const DEVICE_ID_HASH_MESSAGE = "atlascli";
-        hmac.update(DEVICE_ID_HASH_MESSAGE);
-        return hmac.digest("hex");
-    }
-    catch (error) {
-        logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
-        return "unknown";
-    }
-}
-//# sourceMappingURL=device-id.js.map

package/dist/telemetry/device-id.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"device-id.js","sourceRoot":"","sources":["../../src/telemetry/device-id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,OAAO,aAAa,MAAM,iBAAiB,CAAC;AAC5C,OAAO,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAE7C,MAAM,UAAU,WAAW;IACvB,IAAI,CAAC;QACD,MAAM,UAAU,GAAG,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACrD,0EAA0E;QAC1E,oFAAoF;QACpF,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QAE5D,sEAAsE;QACtE,MAAM,sBAAsB,GAAG,UAAU,CAAC;QAE1C,IAAI,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,wBAAwB,EAAE,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACzE,OAAO,SAAS,CAAC;IACrB,CAAC;AACL,CAAC"}

package/src/telemetry/device-id.ts

@@ -1,21 +0,0 @@
-import { createHmac } from "crypto";
-import nodeMachineId from "node-machine-id";
-import logger, { LogId } from "../logger.js";
-
-export function getDeviceId(): string {
-    try {
-        const originalId = nodeMachineId.machineIdSync(true);
-        // Create a hashed format from the all uppercase version of the machine ID
-        // to match it exactly with the denisbrodbeck/machineid library that Atlas CLI uses.
-        const hmac = createHmac("sha256", originalId.toUpperCase());
-
-        /** This matches the message used to create the hashes in Atlas CLI */
-        const DEVICE_ID_HASH_MESSAGE = "atlascli";
-
-        hmac.update(DEVICE_ID_HASH_MESSAGE);
-        return hmac.digest("hex");
-    } catch (error) {
-        logger.debug(LogId.telemetryDeviceIdFailure, "telemetry", String(error));
-        return "unknown";
-    }
-}