mongodb-mcp-server 0.2.0 → 0.3.0

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

@@ -1,195 +0,0 @@
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-import { describe, expect, it } from "vitest";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("renameCollection tool", (integration) => {
-    validateToolMetadata(integration, "rename-collection", "Renames a collection in a MongoDB database", [
-        ...databaseCollectionParameters,
-
-        {
-            name: "newName",
-            description: "The new name for the collection",
-            type: "string",
-            required: true,
-        },
-        {
-            name: "dropTarget",
-            description: "If true, drops the target collection if it exists",
-            type: "boolean",
-            required: false,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "rename-collection", [
-        {},
-        { database: 123, collection: "bar" },
-        { database: "test", collection: [], newName: "foo" },
-        { database: "test", collection: "bar", newName: 10 },
-        { database: "test", collection: "bar", newName: "foo", dropTarget: "true" },
-        { database: "test", collection: "bar", newName: "foo", dropTarget: 1 },
-    ]);
-
-    describe("with non-existing database", () => {
-        it("returns an error", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: "non-existent", collection: "foos", newName: "bar" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(`Cannot rename "non-existent.foos" because it doesn't exist.`);
-        });
-    });
-
-    describe("with non-existing collection", () => {
-        it("returns an error", async () => {
-            await integration.mongoClient().db(integration.randomDbName()).collection("bar").insertOne({});
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "non-existent", newName: "foo" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Cannot rename "${integration.randomDbName()}.non-existent" because it doesn't exist.`
-            );
-        });
-    });
-
-    describe("with existing collection", () => {
-        it("renames to non-existing collection", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
-            );
-
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(0);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(42);
-        });
-
-        it("returns an error when renaming to an existing collection", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Cannot rename "${integration.randomDbName()}.before" to "after" because the target collection already exists. If you want to overwrite it, set the "dropTarget" argument to true.`
-            );
-
-            // Ensure no data was lost
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(1);
-            expect(docsInBefore[0]?.value).toEqual(42);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(84);
-        });
-
-        it("renames to existing collection with dropTarget", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "before",
-                    newName: "after",
-                    dropTarget: true,
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
-            );
-
-            // Ensure the data was moved
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(0);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(42);
-        });
-    });
-
-    validateAutoConnectBehavior(
-        integration,
-        "rename-collection",
-        () => {
-            return {
-                args: { database: integration.randomDbName(), collection: "coll1", newName: "coll2" },
-                expectedResponse: `Collection "coll1" renamed to "coll2" in database "${integration.randomDbName()}".`,
-            };
-        },
-        async () => {
-            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
-        }
-    );
-});

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

@@ -1,239 +0,0 @@
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseContent,
-} from "../../../helpers.js";
-import { beforeEach, describe, expect, it } from "vitest";
-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/integration/transports/stdio.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it, beforeAll, afterAll } from "vitest";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-
-describe("StdioRunner", () => {
-    describe("client connects successfully", () => {
-        let client: Client;
-        let transport: StdioClientTransport;
-        beforeAll(async () => {
-            transport = new StdioClientTransport({
-                command: "node",
-                args: ["dist/index.js"],
-                env: {
-                    MDB_MCP_TRANSPORT: "stdio",
-                },
-            });
-            client = new Client({
-                name: "test",
-                version: "0.0.0",
-            });
-            await client.connect(transport);
-        });
-
-        afterAll(async () => {
-            await client.close();
-            await transport.close();
-        });
-
-        it("handles requests and sends responses", async () => {
-            const response = await client.listTools();
-            expect(response).toBeDefined();
-            expect(response.tools).toBeDefined();
-            expect(response.tools).toHaveLength(20);
-
-            const sortedTools = response.tools.sort((a, b) => a.name.localeCompare(b.name));
-            expect(sortedTools[0]?.name).toBe("aggregate");
-            expect(sortedTools[0]?.description).toBe("Run an aggregation against a MongoDB collection");
-        });
-    });
-});

package/tests/integration/transports/streamableHttp.test.ts

@@ -1,56 +0,0 @@
-import { StreamableHttpRunner } from "../../../src/transports/streamableHttp.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { describe, expect, it, beforeAll, afterAll } from "vitest";
-import { config } from "../../../src/common/config.js";
-
-describe("StreamableHttpRunner", () => {
-    let runner: StreamableHttpRunner;
-    let oldTelemetry: "enabled" | "disabled";
-    let oldLoggers: ("stderr" | "disk" | "mcp")[];
-
-    beforeAll(async () => {
-        oldTelemetry = config.telemetry;
-        oldLoggers = config.loggers;
-        config.telemetry = "disabled";
-        config.loggers = ["stderr"];
-        runner = new StreamableHttpRunner(config);
-        await runner.start();
-    });
-
-    afterAll(async () => {
-        await runner.close();
-        config.telemetry = oldTelemetry;
-        config.loggers = oldLoggers;
-    });
-
-    describe("client connects successfully", () => {
-        let client: Client;
-        let transport: StreamableHTTPClientTransport;
-        beforeAll(async () => {
-            transport = new StreamableHTTPClientTransport(new URL("http://127.0.0.1:3000/mcp"));
-
-            client = new Client({
-                name: "test",
-                version: "0.0.0",
-            });
-            await client.connect(transport);
-        });
-
-        afterAll(async () => {
-            await client.close();
-            await transport.close();
-        });
-
-        it("handles requests and sends responses", async () => {
-            const response = await client.listTools();
-            expect(response).toBeDefined();
-            expect(response.tools).toBeDefined();
-            expect(response.tools.length).toBeGreaterThan(0);
-
-            const sortedTools = response.tools.sort((a, b) => a.name.localeCompare(b.name));
-            expect(sortedTools[0]?.name).toBe("aggregate");
-            expect(sortedTools[0]?.description).toBe("Run an aggregation against a MongoDB collection");
-        });
-    });
-});

package/tests/matchers/toIncludeSameMembers.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-describe("toIncludeSameMembers matcher", () => {
-    it("should pass when arrays contain the same elements in different order", () => {
-        const array1 = [1, 2, 3];
-        const array2 = [3, 1, 2];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-
-    it("should pass when arrays contain the same elements in same order", () => {
-        const array1 = [1, 2, 3];
-        const array2 = [1, 2, 3];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-
-    it("should fail when arrays have different lengths", () => {
-        const array1 = [1, 2, 3];
-        const array2 = [1, 2];
-
-        expect(() => expect(array1).toIncludeSameMembers(array2)).toThrow();
-    });
-
-    it("should fail when arrays contain different elements", () => {
-        const array1 = [1, 2, 3];
-        const array2 = [4, 5, 6];
-
-        expect(() => expect(array1).toIncludeSameMembers(array2)).toThrow();
-    });
-
-    it("should work with string arrays", () => {
-        const array1 = ["apple", "banana", "cherry"];
-        const array2 = ["cherry", "apple", "banana"];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-
-    it("should work with object arrays", () => {
-        const array1 = [{ name: "Alice" }, { name: "Bob" }];
-        const array2 = [{ name: "Bob" }, { name: "Alice" }];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-
-    it("should work with mixed type arrays", () => {
-        const array1 = [1, "hello", { key: "value" }];
-        const array2 = [{ key: "value" }, 1, "hello"];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-
-    it("should work with empty arrays", () => {
-        const array1: unknown[] = [];
-        const array2: unknown[] = [];
-
-        expect(array1).toIncludeSameMembers(array2);
-    });
-});

package/tests/matchers/toIncludeSameMembers.ts

@@ -1,12 +0,0 @@
-import { expect } from "vitest";
-
-export function toIncludeSameMembers<T>(actual: T[], expected: T[]): { pass: boolean; message: () => string } {
-    expect(actual).toEqual(expect.arrayContaining(expected as unknown[]));
-    expect(expected).toEqual(expect.arrayContaining(actual as unknown[]));
-
-    return {
-        pass: true,
-        message: () =>
-            `Expected arrays to include the same members.\nExpected: ${JSON.stringify(expected)}\nReceived: ${JSON.stringify(actual)}`,
-    };
-}

package/tests/setup.ts

@@ -1,7 +0,0 @@
-import { expect } from "vitest";
-import { toIncludeSameMembers } from "./matchers/toIncludeSameMembers.js";
-
-// Extend vitest's expect with custom matchers
-expect.extend({
-    toIncludeSameMembers,
-});

package/tests/unit/accessListUtils.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { ApiClient } from "../../src/common/atlas/apiClient.js";
-import { ensureCurrentIpInAccessList, DEFAULT_ACCESS_LIST_COMMENT } from "../../src/common/atlas/accessListUtils.js";
-import { ApiClientError } from "../../src/common/atlas/apiClientError.js";
-
-describe("accessListUtils", () => {
-    it("should add the current IP to the access list", async () => {
-        const apiClient = {
-            getIpInfo: vi.fn().mockResolvedValue({ currentIpv4Address: "127.0.0.1" } as never),
-            createProjectIpAccessList: vi.fn().mockResolvedValue(undefined as never),
-        } as unknown as ApiClient;
-        await ensureCurrentIpInAccessList(apiClient, "projectId");
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        expect(apiClient.createProjectIpAccessList).toHaveBeenCalledWith({
-            params: { path: { groupId: "projectId" } },
-            body: [{ groupId: "projectId", ipAddress: "127.0.0.1", comment: DEFAULT_ACCESS_LIST_COMMENT }],
-        });
-    });
-
-    it("should not fail if the current IP is already in the access list", async () => {
-        const apiClient = {
-            getIpInfo: vi.fn().mockResolvedValue({ currentIpv4Address: "127.0.0.1" } as never),
-            createProjectIpAccessList: vi
-                .fn()
-                .mockRejectedValue(
-                    ApiClientError.fromError(
-                        { status: 409, statusText: "Conflict" } as Response,
-                        { message: "Conflict" } as never
-                    ) as never
-                ),
-        } as unknown as ApiClient;
-        await ensureCurrentIpInAccessList(apiClient, "projectId");
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        expect(apiClient.createProjectIpAccessList).toHaveBeenCalledWith({
-            params: { path: { groupId: "projectId" } },
-            body: [{ groupId: "projectId", ipAddress: "127.0.0.1", comment: DEFAULT_ACCESS_LIST_COMMENT }],
-        });
-    });
-});