mongodb-mcp-server 0.2.0 → 0.3.0

package/tests/integration/tools/atlas/projects.test.ts

@@ -1,79 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { ObjectId } from "mongodb";
-import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
-import { expectDefined } from "../../helpers.js";
-import { afterAll, describe, expect, it } from "vitest";
-
-const randomId = new ObjectId().toString();
-
-describeWithAtlas("projects", (integration) => {
-    const projName = "testProj-" + randomId;
-
-    afterAll(async () => {
-        const session = integration.mcpServer().session;
-
-        const projects = await session.apiClient.listProjects();
-        for (const project of projects?.results || []) {
-            if (project.name === projName) {
-                await session.apiClient.deleteProject({
-                    params: {
-                        path: {
-                            groupId: project.id || "",
-                        },
-                    },
-                });
-                break;
-            }
-        }
-    });
-
-    describe("atlas-create-project", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const createProject = tools.find((tool) => tool.name === "atlas-create-project");
-            expectDefined(createProject);
-            expect(createProject.inputSchema.type).toBe("object");
-            expectDefined(createProject.inputSchema.properties);
-            expect(createProject.inputSchema.properties).toHaveProperty("projectName");
-            expect(createProject.inputSchema.properties).toHaveProperty("organizationId");
-        });
-        it("should create a project", async () => {
-            const response = (await integration.mcpClient().callTool({
-                name: "atlas-create-project",
-                arguments: { projectName: projName },
-            })) as CallToolResult;
-            expect(response.content).toBeInstanceOf(Array);
-            expect(response.content).toHaveLength(1);
-            expect(response.content[0]?.text).toContain(projName);
-        });
-    });
-    describe("atlas-list-projects", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const listProjects = tools.find((tool) => tool.name === "atlas-list-projects");
-            expectDefined(listProjects);
-            expect(listProjects.inputSchema.type).toBe("object");
-            expectDefined(listProjects.inputSchema.properties);
-            expect(listProjects.inputSchema.properties).toHaveProperty("orgId");
-        });
-
-        it("returns project names", async () => {
-            const response = (await integration
-                .mcpClient()
-                .callTool({ name: "atlas-list-projects", arguments: {} })) as CallToolResult;
-            expect(response.content).toBeInstanceOf(Array);
-            expect(response.content).toHaveLength(1);
-            expect(response.content[0]?.text).toContain(projName);
-            const data = parseTable(response.content[0]?.text as string);
-            expect(data).toBeInstanceOf(Array);
-            expect(data.length).toBeGreaterThan(0);
-            let found = false;
-            for (const project of data) {
-                if (project["Project Name"] === projName) {
-                    found = true;
-                }
-            }
-            expect(found).toBe(true);
-        });
-    });
-});

package/tests/integration/tools/mongodb/connect/connect.test.ts

@@ -1,159 +0,0 @@
-import { describeWithMongoDB } from "../mongodbHelpers.js";
-import {
-    getResponseContent,
-    getResponseElements,
-    validateThrowsForInvalidArguments,
-    validateToolMetadata,
-} from "../../../helpers.js";
-import { config } from "../../../../../src/common/config.js";
-import { defaultTestConfig, setupIntegrationTest } from "../../../helpers.js";
-import { beforeEach, describe, expect, it } from "vitest";
-
-describeWithMongoDB(
-    "SwitchConnection tool",
-    (integration) => {
-        beforeEach(() => {
-            integration.mcpServer().userConfig.connectionString = integration.connectionString();
-        });
-
-        validateToolMetadata(
-            integration,
-            "switch-connection",
-            "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.",
-            [
-                {
-                    name: "connectionString",
-                    description: "MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)",
-                    type: "string",
-                    required: false,
-                },
-            ]
-        );
-
-        validateThrowsForInvalidArguments(integration, "switch-connection", [{ connectionString: 123 }]);
-
-        describe("without arguments", () => {
-            it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({ name: "switch-connection" });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Successfully connected");
-            });
-        });
-
-        it("doesn't have the connect tool registered", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const tool = tools.find((tool) => tool.name === "connect");
-            expect(tool).toBeUndefined();
-        });
-
-        it("defaults to the connection string from config", async () => {
-            const response = await integration.mcpClient().callTool({ name: "switch-connection", arguments: {} });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-        });
-
-        it("switches to the connection string from the arguments", async () => {
-            const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
-            const response = await integration.mcpClient().callTool({
-                name: "switch-connection",
-                arguments: {
-                    connectionString: newConnectionString,
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-        });
-
-        describe("when the arugment connection string is invalid", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "switch-connection",
-                    arguments: {
-                        connectionString: "mongodb://localhost:12345",
-                    },
-                });
-
-                const content = getResponseContent(response.content);
-
-                expect(content).toContain("Error running switch-connection");
-            });
-        });
-    },
-    (mdbIntegration) => ({
-        ...config,
-        connectionString: mdbIntegration.connectionString(),
-    })
-);
-
-describeWithMongoDB(
-    "Connect tool",
-    (integration) => {
-        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
-            {
-                name: "connectionString",
-                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
-                type: "string",
-                required: true,
-            },
-        ]);
-
-        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
-
-        it("doesn't have the switch-connection tool registered", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const tool = tools.find((tool) => tool.name === "switch-connection");
-            expect(tool).toBeUndefined();
-        });
-
-        describe("with connection string", () => {
-            it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: {
-                        connectionString: integration.connectionString(),
-                    },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Successfully connected");
-            });
-        });
-
-        describe("with invalid connection string", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: { connectionString: "mongodb://localhost:12345" },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Error running connect");
-
-                // Should not suggest using the config connection string (because we don't have one)
-                expect(content).not.toContain("Your config lists a different connection string");
-            });
-        });
-    },
-    () => config
-);
-
-describe("Connect tool when disabled", () => {
-    const integration = setupIntegrationTest(() => ({
-        ...defaultTestConfig,
-        disabledTools: ["connect"],
-    }));
-
-    it("is not suggested when querying MongoDB disconnected", async () => {
-        const response = await integration.mcpClient().callTool({
-            name: "find",
-            arguments: { database: "some-db", collection: "some-collection" },
-        });
-
-        const elements = getResponseElements(response);
-        expect(elements).toHaveLength(2);
-        expect(elements[0]?.text).toContain(
-            "You need to connect to a MongoDB instance before you can access its data."
-        );
-        expect(elements[1]?.text).toContain(
-            "There are no tools available to connect. Please update the configuration to include a connection string and restart the server."
-        );
-    });
-});

package/tests/integration/tools/mongodb/create/createCollection.test.ts

@@ -1,96 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseCollectionInvalidArgs,
-} from "../../../helpers.js";
-import { describe, expect, it } from "vitest";
-
-describeWithMongoDB("createCollection tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "create-collection",
-        "Creates a new collection in a database. If the database doesn't exist, it will be created automatically.",
-        databaseCollectionParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "create-collection", databaseCollectionInvalidArgs);
-
-    describe("with non-existent database", () => {
-        it("creates a new collection", async () => {
-            const mongoClient = integration.mongoClient();
-            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(0);
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "create-collection",
-                arguments: { database: integration.randomDbName(), collection: "bar" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(`Collection "bar" created in database "${integration.randomDbName()}".`);
-
-            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(1);
-            expect(collections[0]?.name).toEqual("bar");
-        });
-    });
-
-    describe("with existing database", () => {
-        it("creates new collection", async () => {
-            const mongoClient = integration.mongoClient();
-            await mongoClient.db(integration.randomDbName()).createCollection("collection1");
-            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(1);
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "create-collection",
-                arguments: { database: integration.randomDbName(), collection: "collection2" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(`Collection "collection2" created in database "${integration.randomDbName()}".`);
-            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(2);
-            expect(collections.map((c) => c.name)).toIncludeSameMembers(["collection1", "collection2"]);
-        });
-
-        it("does nothing if collection already exists", async () => {
-            const mongoClient = integration.mongoClient();
-            await mongoClient.db(integration.randomDbName()).collection("collection1").insertOne({});
-            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(1);
-            let documents = await mongoClient
-                .db(integration.randomDbName())
-                .collection("collection1")
-                .find({})
-                .toArray();
-            expect(documents).toHaveLength(1);
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "create-collection",
-                arguments: { database: integration.randomDbName(), collection: "collection1" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(`Collection "collection1" created in database "${integration.randomDbName()}".`);
-            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-            expect(collections).toHaveLength(1);
-            expect(collections[0]?.name).toEqual("collection1");
-
-            // Make sure we didn't drop the existing collection
-            documents = await mongoClient.db(integration.randomDbName()).collection("collection1").find({}).toArray();
-            expect(documents).toHaveLength(1);
-        });
-    });
-
-    validateAutoConnectBehavior(integration, "create-collection", () => {
-        return {
-            args: { database: integration.randomDbName(), collection: "new-collection" },
-            expectedResponse: `Collection "new-collection" created in database "${integration.randomDbName()}".`,
-        };
-    });
-});

package/tests/integration/tools/mongodb/create/createIndex.test.ts

@@ -1,204 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-import { IndexDirection } from "mongodb";
-import { expect, it } from "vitest";
-
-describeWithMongoDB("createIndex tool", (integration) => {
-    validateToolMetadata(integration, "create-index", "Create an index for a collection", [
-        ...databaseCollectionParameters,
-        {
-            name: "keys",
-            type: "object",
-            description: "The index definition",
-            required: true,
-        },
-        {
-            name: "name",
-            type: "string",
-            description: "The name of the index",
-            required: false,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "create-index", [
-        {},
-        { collection: "bar", database: 123, keys: { foo: 1 } },
-        { collection: [], database: "test", keys: { foo: 1 } },
-        { collection: "bar", database: "test", keys: { foo: 1 }, name: 123 },
-        { collection: "bar", database: "test", keys: "foo", name: "my-index" },
-    ]);
-
-    const validateIndex = async (collection: string, expected: { name: string; key: object }[]) => {
-        const mongoClient = integration.mongoClient();
-        const collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
-        expect(collections).toHaveLength(1);
-        expect(collections[0]?.name).toEqual("coll1");
-        const indexes = await mongoClient.db(integration.randomDbName()).collection(collection).indexes();
-        expect(indexes).toHaveLength(expected.length + 1);
-        expect(indexes[0]?.name).toEqual("_id_");
-        for (const index of expected) {
-            const foundIndex = indexes.find((i) => i.name === index.name);
-            expectDefined(foundIndex);
-            expect(foundIndex.key).toEqual(index.key);
-        }
-    };
-
-    it("creates the namespace if necessary", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                keys: { prop1: 1 },
-                name: "my-index",
-            },
-        });
-
-        const content = getResponseContent(response.content);
-        expect(content).toEqual(
-            `Created the index "my-index" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        await validateIndex("coll1", [{ name: "my-index", key: { prop1: 1 } }]);
-    });
-
-    it("generates a name if not provided", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: 1 } },
-        });
-
-        const content = getResponseContent(response.content);
-        expect(content).toEqual(
-            `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-        await validateIndex("coll1", [{ name: "prop1_1", key: { prop1: 1 } }]);
-    });
-
-    it("can create multiple indexes in the same collection", async () => {
-        await integration.connectMcpClient();
-        let response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: 1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop2: -1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop2_-1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        await validateIndex("coll1", [
-            { name: "prop1_1", key: { prop1: 1 } },
-            { name: "prop2_-1", key: { prop2: -1 } },
-        ]);
-    });
-
-    it("can create multiple indexes on the same property", async () => {
-        await integration.connectMcpClient();
-        let response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: 1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: -1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop1_-1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        await validateIndex("coll1", [
-            { name: "prop1_1", key: { prop1: 1 } },
-            { name: "prop1_-1", key: { prop1: -1 } },
-        ]);
-    });
-
-    it("doesn't duplicate indexes", async () => {
-        await integration.connectMcpClient();
-        let response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: 1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        response = await integration.mcpClient().callTool({
-            name: "create-index",
-            arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: 1 } },
-        });
-
-        expect(getResponseContent(response.content)).toEqual(
-            `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-        );
-
-        await validateIndex("coll1", [{ name: "prop1_1", key: { prop1: 1 } }]);
-    });
-
-    const testCases: { name: string; direction: IndexDirection }[] = [
-        { name: "descending", direction: -1 },
-        { name: "ascending", direction: 1 },
-        { name: "hashed", direction: "hashed" },
-        { name: "text", direction: "text" },
-        { name: "geoHaystack", direction: "2dsphere" },
-        { name: "geo2d", direction: "2d" },
-    ];
-
-    for (const { name, direction } of testCases) {
-        it(`creates ${name} index`, async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "create-index",
-                arguments: { database: integration.randomDbName(), collection: "coll1", keys: { prop1: direction } },
-            });
-
-            expect(getResponseContent(response.content)).toEqual(
-                `Created the index "prop1_${direction}" on collection "coll1" in database "${integration.randomDbName()}"`
-            );
-
-            let expectedKey: object = { prop1: direction };
-            if (direction === "text") {
-                expectedKey = {
-                    _fts: "text",
-                    _ftsx: 1,
-                };
-            }
-            await validateIndex("coll1", [{ name: `prop1_${direction}`, key: expectedKey }]);
-        });
-    }
-
-    validateAutoConnectBehavior(integration, "create-index", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                keys: { prop1: 1 },
-            },
-            expectedResponse: `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`,
-        };
-    });
-});

package/tests/integration/tools/mongodb/create/insertMany.test.ts

@@ -1,99 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-import { expect, it } from "vitest";
-
-describeWithMongoDB("insertMany tool", (integration) => {
-    validateToolMetadata(integration, "insert-many", "Insert an array of documents into a MongoDB collection", [
-        ...databaseCollectionParameters,
-        {
-            name: "documents",
-            type: "array",
-            description:
-                "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()",
-            required: true,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "insert-many", [
-        {},
-        { collection: "bar", database: 123, documents: [] },
-        { collection: [], database: "test", documents: [] },
-        { collection: "bar", database: "test", documents: "my-document" },
-        { collection: "bar", database: "test", documents: { name: "Peter" } },
-    ]);
-
-    const validateDocuments = async (collection: string, expectedDocuments: object[]) => {
-        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
-        expectDefined(collections.find((c) => c.name === collection));
-
-        const docs = await integration
-            .mongoClient()
-            .db(integration.randomDbName())
-            .collection(collection)
-            .find()
-            .toArray();
-
-        expect(docs).toHaveLength(expectedDocuments.length);
-        for (const expectedDocument of expectedDocuments) {
-            expect(docs).toContainEqual(expect.objectContaining(expectedDocument));
-        }
-    };
-
-    it("creates the namespace if necessary", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "insert-many",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                documents: [{ prop1: "value1" }],
-            },
-        });
-
-        const content = getResponseContent(response.content);
-        expect(content).toContain('Inserted `1` document(s) into collection "coll1"');
-
-        await validateDocuments("coll1", [{ prop1: "value1" }]);
-    });
-
-    it("returns an error when inserting duplicates", async () => {
-        const { insertedIds } = await integration
-            .mongoClient()
-            .db(integration.randomDbName())
-            .collection("coll1")
-            .insertMany([{ prop1: "value1" }]);
-
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "insert-many",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                documents: [{ prop1: "value1", _id: insertedIds[0] }],
-            },
-        });
-
-        const content = getResponseContent(response.content);
-        expect(content).toContain("Error running insert-many");
-        expect(content).toContain("duplicate key error");
-        expect(content).toContain(insertedIds[0]?.toString());
-    });
-
-    validateAutoConnectBehavior(integration, "insert-many", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                documents: [{ prop1: "value1" }],
-            },
-            expectedResponse: 'Inserted `1` document(s) into collection "coll1"',
-        };
-    });
-});