mongodb-mcp-server 0.0.4

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

@@ -0,0 +1,249 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import { IndexDirection } from "mongodb";
+import config from "../../../../../src/config.js";
+
+describe("createIndex tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const createIndex = tools.find((tool) => tool.name === "create-index")!;
+        expect(createIndex).toBeDefined();
+        expect(createIndex.description).toBe("Create an index for a collection");
+
+        validateParameters(createIndex, [
+            ...dbOperationParameters,
+            {
+                name: "keys",
+                type: "object",
+                description: "The index definition",
+                required: true,
+            },
+            {
+                name: "name",
+                type: "string",
+                description: "The name of the index",
+                required: false,
+            },
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { collection: "bar", database: 123, keys: { foo: 1 } },
+            { collection: "bar", database: "test", keys: { foo: 5 } },
+            { collection: [], database: "test", keys: { foo: 1 } },
+            { collection: "bar", database: "test", keys: { foo: 1 }, name: 123 },
+            { collection: "bar", database: "test", keys: "foo", name: "my-index" },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "create-index", 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 create-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);
+            expect(foundIndex).toBeDefined();
+            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 }]);
+        });
+    }
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            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()}"`
+            );
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            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).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});

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

@@ -0,0 +1,141 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import config from "../../../../../src/config.js";
+
+describe("insertMany tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const insertMany = tools.find((tool) => tool.name === "insert-many")!;
+        expect(insertMany).toBeDefined();
+        expect(insertMany.description).toBe("Insert an array of documents into a MongoDB collection");
+
+        validateParameters(insertMany, [
+            ...dbOperationParameters,
+            {
+                name: "documents",
+                type: "array",
+                description:
+                    "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()",
+                required: true,
+            },
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { collection: "bar", database: 123, documents: [] },
+            { collection: [], database: "test", documents: [] },
+            { collection: "bar", database: "test", documents: "my-document" },
+            { collection: "bar", database: "test", documents: { name: "Peter" } },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "insert-many", 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 insert-many");
+                }
+            });
+        }
+    });
+
+    const validateDocuments = async (collection: string, expectedDocuments: object[]) => {
+        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
+        expect(collections.find((c) => c.name === collection)).toBeDefined();
+
+        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());
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            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"');
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            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("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});

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

@@ -0,0 +1,191 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import config from "../../../../../src/config.js";
+
+describe("deleteMany tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const deleteMany = tools.find((tool) => tool.name === "delete-many")!;
+        expect(deleteMany).toBeDefined();
+        expect(deleteMany.description).toBe("Removes all documents that match the filter from a MongoDB collection");
+
+        validateParameters(deleteMany, [
+            ...dbOperationParameters,
+            {
+                name: "filter",
+                type: "object",
+                description:
+                    "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()",
+                required: false,
+            },
+        ]);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { collection: "bar", database: 123, filter: {} },
+            { collection: [], database: "test", filter: {} },
+            { collection: "bar", database: "test", filter: "my-document" },
+            { collection: "bar", database: "test", filter: [{ name: "Peter" }] },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "delete-many", 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 delete-many");
+                }
+            });
+        }
+    });
+
+    it("doesn't create the collection if it doesn't exist", async () => {
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "delete-many",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                filter: {},
+            },
+        });
+
+        const content = getResponseContent(response.content);
+        expect(content).toContain('Deleted `0` document(s) from collection "coll1"');
+
+        const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
+        expect(collections).toHaveLength(0);
+    });
+
+    const insertDocuments = async () => {
+        await integration
+            .mongoClient()
+            .db(integration.randomDbName())
+            .collection("coll1")
+            .insertMany([
+                { age: 10, name: "Peter" },
+                { age: 20, name: "John" },
+                { age: 30, name: "Mary" },
+                { age: 40, name: "Lucy" },
+            ]);
+    };
+
+    const validateDocuments = async (expected: object[]) => {
+        const documents = await integration
+            .mongoClient()
+            .db(integration.randomDbName())
+            .collection("coll1")
+            .find()
+            .toArray();
+
+        expect(documents).toHaveLength(expected.length);
+        for (const expectedDocument of expected) {
+            expect(documents).toContainEqual(expect.objectContaining(expectedDocument));
+        }
+    };
+
+    it("deletes documents matching the filter", async () => {
+        await insertDocuments();
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "delete-many",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                filter: { age: { $gt: 20 } },
+            },
+        });
+        const content = getResponseContent(response.content);
+        expect(content).toContain('Deleted `2` document(s) from collection "coll1"');
+
+        await validateDocuments([
+            { age: 10, name: "Peter" },
+            { age: 20, name: "John" },
+        ]);
+    });
+
+    it("when filter doesn't match, deletes nothing", async () => {
+        await insertDocuments();
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "delete-many",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                filter: { age: { $gt: 100 } },
+            },
+        });
+
+        const content = getResponseContent(response.content);
+        expect(content).toContain('Deleted `0` document(s) from collection "coll1"');
+
+        await validateDocuments([
+            { age: 10, name: "Peter" },
+            { age: 20, name: "John" },
+            { age: 30, name: "Mary" },
+            { age: 40, name: "Lucy" },
+        ]);
+    });
+
+    it("with empty filter, deletes all documents", async () => {
+        await insertDocuments();
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "delete-many",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                filter: {},
+            },
+        });
+
+        const content = getResponseContent(response.content);
+        expect(content).toContain('Deleted `4` document(s) from collection "coll1"');
+
+        await validateDocuments([]);
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({
+                name: "delete-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    filter: {},
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain('Deleted `0` document(s) from collection "coll1"');
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "delete-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    filter: {},
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});