mongodb-mcp-server 0.1.3 → 0.3.0

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

@@ -1,203 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-import { IndexDirection } from "mongodb";
-
-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,98 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-
-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"',
-        };
-    });
-});

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

@@ -1,154 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-
-describeWithMongoDB("deleteMany tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "delete-many",
-        "Removes all documents that match the filter from a MongoDB collection",
-        [
-            ...databaseCollectionParameters,
-            {
-                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", () => {
-        validateThrowsForInvalidArguments(integration, "delete-many", [
-            {},
-            { collection: "bar", database: 123, filter: {} },
-            { collection: [], database: "test", filter: {} },
-            { collection: "bar", database: "test", filter: "my-document" },
-            { collection: "bar", database: "test", filter: [{ name: "Peter" }] },
-        ]);
-    });
-
-    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([]);
-    });
-
-    validateAutoConnectBehavior(integration, "delete-many", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                filter: {},
-            },
-            expectedResponse: 'Deleted `0` document(s) from collection "coll1"',
-        };
-    });
-});

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

@@ -1,69 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseCollectionInvalidArgs,
-} from "../../../helpers.js";
-
-describeWithMongoDB("dropCollection tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "drop-collection",
-        "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.",
-        databaseCollectionParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "drop-collection", databaseCollectionInvalidArgs);
-
-    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");
-    });
-
-    validateAutoConnectBehavior(integration, "drop-collection", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-            },
-            expectedResponse: `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`,
-        };
-    });
-});

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

@@ -1,80 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseParameters,
-    databaseInvalidArgs,
-    expectDefined,
-} from "../../../helpers.js";
-
-describeWithMongoDB("dropDatabase tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "drop-database",
-        "Removes the specified database, deleting the associated data files",
-        databaseParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "drop-database", databaseInvalidArgs);
-
-    it("can drop non-existing database", async () => {
-        let { databases } = await integration.mongoClient().db("").admin().listDatabases();
-
-        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
-
-        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.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();
-        expectDefined(databases.find((db) => db.name === integration.randomDbName()));
-
-        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);
-    });
-
-    validateAutoConnectBehavior(
-        integration,
-        "drop-database",
-        () => {
-            return {
-                args: { database: integration.randomDbName() },
-                expectedResponse: `Successfully dropped database "${integration.randomDbName()}"`,
-            };
-        },
-        async () => {
-            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
-        }
-    );
-});