mongodb-mcp-server 0.0.4

package/tests/integration/tools/mongodb/delete/dropCollection.test.ts

@@ -0,0 +1,118 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import config from "../../../../../src/config.js";
+
+describe("dropCollection tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const dropCollection = tools.find((tool) => tool.name === "drop-collection")!;
+        expect(dropCollection).toBeDefined();
+        expect(dropCollection.description).toBe(
+            "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection."
+        );
+
+        validateParameters(dropCollection, [...dbOperationParameters]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { database: 123, collection: "bar" },
+            { foo: "bar", database: "test", collection: "bar" },
+            { collection: [], database: "test" },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "drop-collection", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool drop-collection");
+                }
+            });
+        }
+    });
+
+    it("can drop non-existing collection", async () => {
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "drop-collection",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+            },
+        });
+
+        const content = getResponseContent(response.content);
+        expect(content).toContain(
+            `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`
+        );
+
+        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
+        expect(collections).toHaveLength(0);
+    });
+
+    it("removes the collection if it exists", async () => {
+        await integration.connectMcpClient();
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("coll2");
+        const response = await integration.mcpClient().callTool({
+            name: "drop-collection",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+            },
+        });
+        const content = getResponseContent(response.content);
+        expect(content).toContain(
+            `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`
+        );
+        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
+        expect(collections).toHaveLength(1);
+        expect(collections[0].name).toBe("coll2");
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            await integration.connectMcpClient();
+            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
+
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({
+                name: "drop-collection",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain(
+                `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`
+            );
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "drop-collection",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});

package/tests/integration/tools/mongodb/delete/dropDatabase.test.ts

@@ -0,0 +1,114 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import config from "../../../../../src/config.js";
+
+describe("dropDatabase tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const dropDatabase = tools.find((tool) => tool.name === "drop-database")!;
+        expect(dropDatabase).toBeDefined();
+        expect(dropDatabase.description).toBe("Removes the specified database, deleting the associated data files");
+
+        validateParameters(dropDatabase, [dbOperationParameters.find((d) => d.name === "database")!]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [{}, { database: 123 }, { foo: "bar", database: "test" }];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "drop-database", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool drop-database");
+                }
+            });
+        }
+    });
+
+    it("can drop non-existing database", async () => {
+        let { databases } = await integration.mongoClient().db("").admin().listDatabases();
+
+        const preDropLength = databases.length;
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "drop-database",
+            arguments: {
+                database: integration.randomDbName(),
+            },
+        });
+
+        const content = getResponseContent(response.content);
+        expect(content).toContain(`Successfully dropped database "${integration.randomDbName()}"`);
+
+        ({ databases } = await integration.mongoClient().db("").admin().listDatabases());
+
+        expect(databases).toHaveLength(preDropLength);
+        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
+    });
+
+    it("removes the database along with its collections", async () => {
+        await integration.connectMcpClient();
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("coll2");
+
+        let { databases } = await integration.mongoClient().db("").admin().listDatabases();
+        expect(databases.find((db) => db.name === integration.randomDbName())).toBeDefined();
+
+        const response = await integration.mcpClient().callTool({
+            name: "drop-database",
+            arguments: {
+                database: integration.randomDbName(),
+            },
+        });
+        const content = getResponseContent(response.content);
+        expect(content).toContain(`Successfully dropped database "${integration.randomDbName()}"`);
+
+        ({ databases } = await integration.mongoClient().db("").admin().listDatabases());
+        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
+
+        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
+        expect(collections).toHaveLength(0);
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            await integration.connectMcpClient();
+            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
+
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({
+                name: "drop-database",
+                arguments: {
+                    database: integration.randomDbName(),
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain(`Successfully dropped database "${integration.randomDbName()}"`);
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "drop-database",
+                arguments: {
+                    database: integration.randomDbName(),
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});

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

@@ -0,0 +1,137 @@
+import { getResponseContent, validateParameters, setupIntegrationTest } from "../../../helpers.js";
+
+import config from "../../../../../src/config.js";
+
+describe("Connect tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const connectTool = tools.find((tool) => tool.name === "connect")!;
+        expect(connectTool).toBeDefined();
+        expect(connectTool.description).toBe("Connect to a MongoDB instance");
+
+        validateParameters(connectTool, [
+            {
+                name: "options",
+                description:
+                    "Options for connecting to MongoDB. If not provided, the connection string from the config://connection-string resource will be used. If the user hasn't specified Atlas cluster name or a connection string explicitly and the `config://connection-string` resource is present, always invoke this with no arguments.",
+                type: "array",
+                required: false,
+            },
+        ]);
+    });
+
+    describe("with default config", () => {
+        describe("without connection string", () => {
+            it("prompts for connection string", async () => {
+                const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
+                const content = getResponseContent(response.content);
+                expect(content).toContain("No connection details provided");
+            });
+        });
+
+        describe("with connection string", () => {
+            it("connects to the database", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: {
+                        options: [
+                            {
+                                connectionString: integration.connectionString(),
+                            },
+                        ],
+                    },
+                });
+                const content = getResponseContent(response.content);
+                expect(content).toContain("Successfully connected");
+                expect(content).toContain(integration.connectionString());
+            });
+        });
+
+        describe("with invalid connection string", () => {
+            it("returns error message", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: { options: [{ 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");
+            });
+        });
+    });
+
+    describe("with connection string in config", () => {
+        beforeEach(async () => {
+            config.connectionString = integration.connectionString();
+        });
+
+        it("uses the connection string from config", async () => {
+            const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("Successfully connected");
+            expect(content).toContain(integration.connectionString());
+        });
+
+        it("prefers connection string from arguments", async () => {
+            const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
+            const response = await integration.mcpClient().callTool({
+                name: "connect",
+                arguments: {
+                    options: [
+                        {
+                            connectionString: newConnectionString,
+                        },
+                    ],
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("Successfully connected");
+            expect(content).toContain(newConnectionString);
+        });
+
+        describe("when the arugment connection string is invalid", () => {
+            it("suggests the config connection string if set", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: {
+                        options: [
+                            {
+                                connectionString: "mongodb://localhost:12345",
+                            },
+                        ],
+                    },
+                });
+                const content = getResponseContent(response.content);
+                expect(content).toContain("Failed to connect to MongoDB at 'mongodb://localhost:12345'");
+                expect(content).toContain(
+                    `Your config lists a different connection string: '${config.connectionString}' - do you want to try connecting to it instead?`
+                );
+            });
+
+            it("returns error message if the config connection string matches the argument", async () => {
+                config.connectionString = "mongodb://localhost:12345";
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: {
+                        options: [
+                            {
+                                connectionString: "mongodb://localhost:12345",
+                            },
+                        ],
+                    },
+                });
+
+                const content = getResponseContent(response.content);
+
+                // Should be handled by default error handler and not suggest the config connection string
+                // because it matches the argument connection string
+                expect(content).toContain("Error running connect");
+                expect(content).not.toContain("Your config lists a different connection string");
+            });
+        });
+    });
+});

package/tests/integration/tools/mongodb/metadata/listCollections.test.ts

@@ -0,0 +1,104 @@
+import { getResponseElements, getResponseContent, validateParameters, setupIntegrationTest } from "../../../helpers.js";
+import { toIncludeSameMembers } from "jest-extended";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import config from "../../../../../src/config.js";
+import { ObjectId } from "bson";
+
+describe("listCollections tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const listCollections = tools.find((tool) => tool.name === "list-collections")!;
+        expect(listCollections).toBeDefined();
+        expect(listCollections.description).toBe("List all collections for a given database");
+
+        validateParameters(listCollections, [
+            { name: "database", description: "Database name", type: "string", required: true },
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [{}, { database: 123 }, { foo: "bar", database: "test" }, { database: [] }];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "list-collections", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool list-collections");
+                    expect(mcpError.message).toContain('"expected": "string"');
+                }
+            });
+        }
+    });
+
+    describe("with non-existent database", () => {
+        it("returns no collections", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "list-collections",
+                arguments: { database: "non-existent" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `No collections found for database "non-existent". To create a collection, use the "create-collection" tool.`
+            );
+        });
+    });
+
+    describe("with existing database", () => {
+        it("returns collections", async () => {
+            const mongoClient = integration.mongoClient();
+            await mongoClient.db(integration.randomDbName()).createCollection("collection-1");
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "list-collections",
+                arguments: { database: integration.randomDbName() },
+            });
+            const items = getResponseElements(response.content);
+            expect(items).toHaveLength(1);
+            expect(items[0].text).toContain('Name: "collection-1"');
+
+            await mongoClient.db(integration.randomDbName()).createCollection("collection-2");
+
+            const response2 = await integration.mcpClient().callTool({
+                name: "list-collections",
+                arguments: { database: integration.randomDbName() },
+            });
+            const items2 = getResponseElements(response2.content);
+            expect(items2).toHaveLength(2);
+            expect(items2.map((item) => item.text)).toIncludeSameMembers([
+                'Name: "collection-1"',
+                'Name: "collection-2"',
+            ]);
+        });
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration
+                .mcpClient()
+                .callTool({ name: "list-collections", arguments: { database: integration.randomDbName() } });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `No collections found for database "${integration.randomDbName()}". To create a collection, use the "create-collection" tool.`
+            );
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration
+                .mcpClient()
+                .callTool({ name: "list-collections", arguments: { database: integration.randomDbName() } });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});

package/tests/integration/tools/mongodb/metadata/listDatabases.test.ts

@@ -0,0 +1,67 @@
+import config from "../../../../../src/config.js";
+import { getResponseElements, getParameters, setupIntegrationTest, getResponseContent } from "../../../helpers.js";
+import { toIncludeSameMembers } from "jest-extended";
+
+describe("listDatabases tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const listDatabases = tools.find((tool) => tool.name === "list-databases")!;
+        expect(listDatabases).toBeDefined();
+        expect(listDatabases.description).toBe("List all databases for a MongoDB connection");
+
+        const parameters = getParameters(listDatabases);
+        expect(parameters).toHaveLength(0);
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
+            const dbNames = getDbNames(response.content);
+
+            expect(dbNames).toIncludeSameMembers(["admin", "config", "local"]);
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+
+    describe("with no preexisting databases", () => {
+        it("returns only the system databases", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
+            const dbNames = getDbNames(response.content);
+
+            expect(dbNames).toIncludeSameMembers(["admin", "config", "local"]);
+        });
+    });
+
+    describe("with preexisting databases", () => {
+        it("returns their names and sizes", async () => {
+            const mongoClient = integration.mongoClient();
+            await mongoClient.db("foo").collection("bar").insertOne({ test: "test" });
+            await mongoClient.db("baz").collection("qux").insertOne({ test: "test" });
+
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
+            const dbNames = getDbNames(response.content);
+            expect(dbNames).toIncludeSameMembers(["admin", "config", "local", "foo", "baz"]);
+        });
+    });
+});
+
+function getDbNames(content: unknown): (string | null)[] {
+    const responseItems = getResponseElements(content);
+
+    return responseItems.map((item) => {
+        const match = item.text.match(/Name: (.*), Size: \d+ bytes/);
+        return match ? match[1] : null;
+    });
+}

package/tests/integration/tools/mongodb/read/count.test.ts

@@ -0,0 +1,138 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { toIncludeSameMembers } from "jest-extended";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import { ObjectId } from "mongodb";
+import config from "../../../../../src/config.js";
+
+describe("count tool", () => {
+    const integration = setupIntegrationTest();
+
+    let randomDbName: string;
+    beforeEach(() => {
+        randomDbName = new ObjectId().toString();
+    });
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const listCollections = tools.find((tool) => tool.name === "count")!;
+        expect(listCollections).toBeDefined();
+        expect(listCollections.description).toBe("Gets the number of documents in a MongoDB collection");
+
+        validateParameters(listCollections, [
+            {
+                name: "query",
+                description:
+                    "The query filter to count documents. Matches the syntax of the filter argument of db.collection.count()",
+                type: "object",
+                required: false,
+            },
+            ...dbOperationParameters,
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { database: 123, collection: "bar" },
+            { foo: "bar", database: "test", collection: "bar" },
+            { collection: [], database: "test" },
+            { collection: "bar", database: "test", query: "{ $gt: { foo: 5 } }" },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "count", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool count");
+                }
+            });
+        }
+    });
+
+    it("returns 0 when database doesn't exist", async () => {
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "count",
+            arguments: { database: "non-existent", collection: "foos" },
+        });
+        const content = getResponseContent(response.content);
+        expect(content).toEqual('Found 0 documents in the collection "foos"');
+    });
+
+    it("returns 0 when collection doesn't exist", async () => {
+        await integration.connectMcpClient();
+        const mongoClient = integration.mongoClient();
+        await mongoClient.db(randomDbName).collection("bar").insertOne({});
+        const response = await integration.mcpClient().callTool({
+            name: "count",
+            arguments: { database: randomDbName, collection: "non-existent" },
+        });
+        const content = getResponseContent(response.content);
+        expect(content).toEqual('Found 0 documents in the collection "non-existent"');
+    });
+
+    describe("with existing database", () => {
+        beforeEach(async () => {
+            const mongoClient = integration.mongoClient();
+            await mongoClient
+                .db(randomDbName)
+                .collection("foo")
+                .insertMany([
+                    { name: "Peter", age: 5 },
+                    { name: "Parker", age: 10 },
+                    { name: "George", age: 15 },
+                ]);
+        });
+
+        const testCases = [
+            { filter: undefined, expectedCount: 3 },
+            { filter: {}, expectedCount: 3 },
+            { filter: { age: { $lt: 15 } }, expectedCount: 2 },
+            { filter: { age: { $gt: 5 }, name: { $regex: "^P" } }, expectedCount: 1 },
+        ];
+        for (const testCase of testCases) {
+            it(`returns ${testCase.expectedCount} documents for filter ${JSON.stringify(testCase.filter)}`, async () => {
+                await integration.connectMcpClient();
+                const response = await integration.mcpClient().callTool({
+                    name: "count",
+                    arguments: { database: randomDbName, collection: "foo", query: testCase.filter },
+                });
+
+                const content = getResponseContent(response.content);
+                expect(content).toEqual(`Found ${testCase.expectedCount} documents in the collection "foo"`);
+            });
+        }
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({
+                name: "count",
+                arguments: { database: randomDbName, collection: "coll1" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual('Found 0 documents in the collection "coll1"');
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "count",
+                arguments: { database: randomDbName, collection: "coll1" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});