mongodb-mcp-server 0.1.3 → 0.3.0

package/tests/integration/tools/mongodb/update/updateMany.test.ts

@@ -1,238 +0,0 @@
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseContent,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("updateMany tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "update-many",
-        "Updates all documents that match the specified filter for a collection",
-        [
-            ...databaseCollectionParameters,
-
-            {
-                name: "filter",
-                description:
-                    "The selection criteria for the update, matching the syntax of the filter argument of db.collection.updateOne()",
-                type: "object",
-                required: false,
-            },
-            {
-                name: "update",
-                description:
-                    "An update document describing the modifications to apply using update operator expressions",
-                type: "object",
-                required: true,
-            },
-            {
-                name: "upsert",
-                description: "Controls whether to insert a new document if no documents match the filter",
-                type: "boolean",
-                required: false,
-            },
-        ]
-    );
-
-    validateThrowsForInvalidArguments(integration, "update-many", [
-        {},
-        { database: 123, collection: "bar", update: {} },
-        { database: [], collection: "bar", update: {} },
-        { database: "test", collection: "bar", update: [] },
-        { database: "test", collection: "bar", update: {}, filter: 123 },
-        { database: "test", collection: "bar", update: {}, upsert: "true" },
-        { database: "test", collection: "bar", update: {}, filter: {}, upsert: "true" },
-        { database: "test", collection: "bar", update: {}, filter: "TRUEPREDICATE", upsert: false },
-    ]);
-
-    describe("with non-existent database", () => {
-        it("doesn't update any documents", async () => {
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: "non-existent-db",
-                    collection: "coll1",
-                    update: { $set: { name: "new-name" } },
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toEqual("No documents matched the filter.");
-        });
-    });
-
-    describe("with non-existent collection", () => {
-        it("doesn't update any documents", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .insertOne({ name: "old-name" });
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "non-existent",
-                    update: { $set: { name: "new-name" } },
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toEqual("No documents matched the filter.");
-        });
-    });
-
-    describe("with existing collection", () => {
-        beforeEach(async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .insertMany([
-                    { name: "old-name", value: 1 },
-                    { name: "old-name", value: 2 },
-                    { name: "old-name", value: 3 },
-                ]);
-        });
-        it("updates all documents without filter", async () => {
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    update: { $set: { name: "new-name" } },
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toEqual("Matched 3 document(s). Modified 3 document(s).");
-
-            const docs = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .find({})
-                .toArray();
-
-            expect(docs).toHaveLength(3);
-            for (const doc of docs) {
-                expect(doc.name).toEqual("new-name");
-            }
-        });
-
-        it("updates all documents that match the filter", async () => {
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    update: { $set: { name: "new-name" } },
-                    filter: { value: { $gt: 1 } },
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toEqual("Matched 2 document(s). Modified 2 document(s).");
-
-            const docs = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .find({})
-                .toArray();
-            expect(docs).toHaveLength(3);
-            for (const doc of docs) {
-                if (doc.value > 1) {
-                    expect(doc.name).toEqual("new-name");
-                } else {
-                    expect(doc.name).toEqual("old-name");
-                }
-            }
-        });
-
-        it("upserts a new document if no documents match the filter", async () => {
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    update: { $set: { name: "new-name" } },
-                    filter: { value: 4 },
-                    upsert: true,
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Matched 0 document(s). Upserted 1 document with id:");
-
-            const docs = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .find({})
-                .toArray();
-
-            expect(docs).toHaveLength(4);
-            for (const doc of docs) {
-                if (doc.value === 4) {
-                    expect(doc.name).toEqual("new-name");
-                } else {
-                    expect(doc.name).toEqual("old-name");
-                }
-            }
-        });
-
-        it("doesn't upsert a new document if no documents match the filter and upsert is false", async () => {
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({
-                name: "update-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    update: { $set: { name: "new-name" } },
-                    filter: { value: 4 },
-                },
-            });
-
-            const content = getResponseContent(response.content);
-            expect(content).toContain("No documents matched the filter.");
-
-            const docs = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("coll1")
-                .find({})
-                .toArray();
-
-            expect(docs).toHaveLength(3);
-            for (const doc of docs) {
-                expect(doc.name).toEqual("old-name");
-            }
-        });
-    });
-
-    validateAutoConnectBehavior(integration, "update-many", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                update: { $set: { name: "new-name" } },
-            },
-            expectedResponse: "No documents matched the filter.",
-        };
-    });
-});

package/tests/unit/EJsonTransport.test.ts

@@ -1,71 +0,0 @@
-import { Decimal128, MaxKey, MinKey, ObjectId, Timestamp, UUID } from "bson";
-import { createEJsonTransport, EJsonReadBuffer } from "../../src/helpers/EJsonTransport.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";
-
-describe("EJsonTransport", () => {
-    let transport: StdioServerTransport;
-    beforeEach(async () => {
-        transport = createEJsonTransport();
-        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/unit/apiClient.test.ts

@@ -1,193 +0,0 @@
-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/indexCheck.test.ts

@@ -1,149 +0,0 @@
-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");
-        });
-    });
-});