mongodb-mcp-server 0.2.0 → 0.3.0

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

@@ -1,155 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-import { describe, expect, it } from "vitest";
-
-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 { expect, it } from "vitest";
-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,81 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-import { expect, it } from "vitest";
-
-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");
-        }
-    );
-});

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

@@ -1,155 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseElements,
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseCollectionInvalidArgs,
-} from "../../../helpers.js";
-import { Document } from "bson";
-import { OptionalId } from "mongodb";
-import { SimplifiedSchema } from "mongodb-schema";
-import { describe, expect, it } from "vitest";
-
-describeWithMongoDB("collectionSchema tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "collection-schema",
-        "Describe the schema for a collection",
-        databaseCollectionParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "collection-schema", databaseCollectionInvalidArgs);
-
-    describe("with non-existent database", () => {
-        it("returns empty schema", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "collection-schema",
-                arguments: { database: "non-existent", collection: "foo" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Could not deduce the schema for "non-existent.foo". This may be because it doesn't exist or is empty.`
-            );
-        });
-    });
-
-    describe("with existing database", () => {
-        const testCases: Array<{
-            insertionData: OptionalId<Document>[];
-            name: string;
-            expectedSchema: SimplifiedSchema;
-        }> = [
-            {
-                name: "homogenous schema",
-                insertionData: [
-                    { name: "Alice", age: 30 },
-                    { name: "Bob", age: 25 },
-                ],
-                expectedSchema: {
-                    _id: {
-                        types: [{ bsonType: "ObjectId" }],
-                    },
-                    name: {
-                        types: [{ bsonType: "String" }],
-                    },
-                    age: {
-                        //@ts-expect-error This is a workaround
-                        types: [{ bsonType: "Number" }],
-                    },
-                },
-            },
-            {
-                name: "heterogenous schema",
-                insertionData: [
-                    { name: "Alice", age: 30 },
-                    { name: "Bob", age: "25", country: "UK" },
-                    { name: "Charlie", country: "USA" },
-                    { name: "Mims", age: 25, country: false },
-                ],
-                expectedSchema: {
-                    _id: {
-                        types: [{ bsonType: "ObjectId" }],
-                    },
-                    name: {
-                        types: [{ bsonType: "String" }],
-                    },
-                    age: {
-                        // @ts-expect-error This is a workaround
-                        types: [{ bsonType: "Number" }, { bsonType: "String" }],
-                    },
-                    country: {
-                        types: [{ bsonType: "String" }, { bsonType: "Boolean" }],
-                    },
-                },
-            },
-            {
-                name: "schema with nested documents",
-                insertionData: [
-                    { name: "Alice", address: { city: "New York", zip: "10001" }, ageRange: [18, 30] },
-                    { name: "Bob", address: { city: "Los Angeles" }, ageRange: "25-30" },
-                    { name: "Charlie", address: { city: "Chicago", zip: "60601" }, ageRange: [20, 35] },
-                ],
-                expectedSchema: {
-                    _id: {
-                        types: [{ bsonType: "ObjectId" }],
-                    },
-                    name: {
-                        types: [{ bsonType: "String" }],
-                    },
-                    address: {
-                        types: [
-                            {
-                                bsonType: "Document",
-                                fields: {
-                                    city: { types: [{ bsonType: "String" }] },
-                                    zip: { types: [{ bsonType: "String" }] },
-                                },
-                            },
-                        ],
-                    },
-                    ageRange: {
-                        // @ts-expect-error This is a workaround
-                        types: [{ bsonType: "Array", types: [{ bsonType: "Number" }] }, { bsonType: "String" }],
-                    },
-                },
-            },
-        ];
-
-        for (const testCase of testCases) {
-            it(`returns ${testCase.name}`, async () => {
-                const mongoClient = integration.mongoClient();
-                await mongoClient.db(integration.randomDbName()).collection("foo").insertMany(testCase.insertionData);
-
-                await integration.connectMcpClient();
-                const response = await integration.mcpClient().callTool({
-                    name: "collection-schema",
-                    arguments: { database: integration.randomDbName(), collection: "foo" },
-                });
-                const items = getResponseElements(response.content);
-                expect(items).toHaveLength(2);
-
-                // Expect to find _id, name, age
-                expect(items[0]?.text).toEqual(
-                    `Found ${Object.entries(testCase.expectedSchema).length} fields in the schema for "${integration.randomDbName()}.foo"`
-                );
-
-                const schema = JSON.parse(items[1]?.text ?? "{}") as SimplifiedSchema;
-                expect(schema).toEqual(testCase.expectedSchema);
-            });
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "collection-schema", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "new-collection",
-            },
-            expectedResponse: `Could not deduce the schema for "${integration.randomDbName()}.new-collection". This may be because it doesn't exist or is empty.`,
-        };
-    });
-});

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

@@ -1,87 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    databaseCollectionInvalidArgs,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-import * as crypto from "crypto";
-import { describe, expect, it } from "vitest";
-
-describeWithMongoDB("collectionStorageSize tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "collection-storage-size",
-        "Gets the size of the collection",
-        databaseCollectionParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "collection-storage-size", databaseCollectionInvalidArgs);
-
-    describe("with non-existent database", () => {
-        it("returns an error", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "collection-storage-size",
-                arguments: { database: integration.randomDbName(), collection: "foo" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `The size of "${integration.randomDbName()}.foo" cannot be determined because the collection does not exist.`
-            );
-        });
-    });
-
-    describe("with existing database", () => {
-        const testCases = [
-            {
-                expectedScale: "bytes",
-                bytesToInsert: 1,
-            },
-            {
-                expectedScale: "KB",
-                bytesToInsert: 1024,
-            },
-            {
-                expectedScale: "MB",
-                bytesToInsert: 1024 * 1024,
-            },
-        ];
-        for (const test of testCases) {
-            it(`returns the size of the collection in ${test.expectedScale}`, async () => {
-                await integration
-                    .mongoClient()
-                    .db(integration.randomDbName())
-                    .collection("foo")
-                    .insertOne({ data: crypto.randomBytes(test.bytesToInsert) });
-
-                await integration.connectMcpClient();
-                const response = await integration.mcpClient().callTool({
-                    name: "collection-storage-size",
-                    arguments: { database: integration.randomDbName(), collection: "foo" },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain(`The size of "${integration.randomDbName()}.foo" is`);
-                const size = /is `(\d+\.\d+) ([a-zA-Z]*)`/.exec(content);
-
-                expectDefined(size?.[1]);
-                expectDefined(size?.[2]);
-                expect(parseFloat(size?.[1] || "")).toBeGreaterThan(0);
-                expect(size?.[2]).toBe(test.expectedScale);
-            });
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "collection-storage-size", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "foo",
-            },
-            expectedResponse: `The size of "${integration.randomDbName()}.foo" cannot be determined because the collection does not exist.`,
-        };
-    });
-});

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

@@ -1,105 +0,0 @@
-import { ObjectId } from "bson";
-import {
-    databaseParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseInvalidArgs,
-    getResponseElements,
-} from "../../../helpers.js";
-import * as crypto from "crypto";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-import { describe, expect, it } from "vitest";
-
-describeWithMongoDB("dbStats tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "db-stats",
-        "Returns statistics that reflect the use state of a single database",
-        databaseParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "db-stats", databaseInvalidArgs);
-
-    describe("with non-existent database", () => {
-        it("returns an error", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "db-stats",
-                arguments: { database: integration.randomDbName() },
-            });
-            const elements = getResponseElements(response.content);
-            expect(elements).toHaveLength(2);
-            expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
-
-            const stats = JSON.parse(elements[1]?.text ?? "{}") as {
-                db: string;
-                collections: number;
-                storageSize: number;
-            };
-            expect(stats.db).toBe(integration.randomDbName());
-            expect(stats.collections).toBe(0);
-            expect(stats.storageSize).toBe(0);
-        });
-    });
-
-    describe("with existing database", () => {
-        const testCases = [
-            {
-                collections: {
-                    foos: 3,
-                },
-                name: "single collection",
-            },
-            {
-                collections: {
-                    foos: 2,
-                    bars: 5,
-                },
-                name: "multiple collections",
-            },
-        ];
-        for (const test of testCases) {
-            it(`returns correct stats for ${test.name}`, async () => {
-                for (const [name, count] of Object.entries(test.collections)) {
-                    const objects = Array(count)
-                        .fill(0)
-                        .map(() => {
-                            return { data: crypto.randomBytes(1024), _id: new ObjectId() };
-                        });
-                    await integration.mongoClient().db(integration.randomDbName()).collection(name).insertMany(objects);
-                }
-
-                await integration.connectMcpClient();
-                const response = await integration.mcpClient().callTool({
-                    name: "db-stats",
-                    arguments: { database: integration.randomDbName() },
-                });
-                const elements = getResponseElements(response.content);
-                expect(elements).toHaveLength(2);
-                expect(elements[0]?.text).toBe(`Statistics for database ${integration.randomDbName()}`);
-
-                const stats = JSON.parse(elements[1]?.text ?? "{}") as {
-                    db: string;
-                    collections: unknown;
-                    storageSize: unknown;
-                    objects: unknown;
-                };
-                expect(stats.db).toBe(integration.randomDbName());
-                expect(stats.collections).toBe(Object.entries(test.collections).length);
-                expect(stats.storageSize).toBeGreaterThan(1024);
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                expect(stats.objects).toBe(Object.values(test.collections).reduce((a, b) => a + b, 0));
-            });
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "db-stats", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "foo",
-            },
-            expectedResponse: `Statistics for database ${integration.randomDbName()}`,
-        };
-    });
-});