mongodb-mcp-server 0.1.3 → 0.3.0

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

@@ -1,154 +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";
-
-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,86 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    databaseCollectionInvalidArgs,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    expectDefined,
-} from "../../../helpers.js";
-import * as crypto from "crypto";
-
-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/connect.test.ts

@@ -1,128 +0,0 @@
-import { describeWithMongoDB } from "../mongodbHelpers.js";
-import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
-import { config } from "../../../../../src/config.js";
-
-describeWithMongoDB(
-    "switchConnection tool",
-    (integration) => {
-        beforeEach(() => {
-            integration.mcpServer().userConfig.connectionString = integration.connectionString();
-        });
-
-        validateToolMetadata(
-            integration,
-            "switch-connection",
-            "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.",
-            [
-                {
-                    name: "connectionString",
-                    description: "MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)",
-                    type: "string",
-                    required: false,
-                },
-            ]
-        );
-
-        validateThrowsForInvalidArguments(integration, "switch-connection", [{ connectionString: 123 }]);
-
-        describe("without arguments", () => {
-            it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({ name: "switch-connection" });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Successfully connected");
-            });
-        });
-
-        it("doesn't have the connect tool registered", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const tool = tools.find((tool) => tool.name === "connect");
-            expect(tool).toBeUndefined();
-        });
-
-        it("defaults to the connection string from config", async () => {
-            const response = await integration.mcpClient().callTool({ name: "switch-connection", arguments: {} });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-        });
-
-        it("switches to the connection string from the arguments", async () => {
-            const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
-            const response = await integration.mcpClient().callTool({
-                name: "switch-connection",
-                arguments: {
-                    connectionString: newConnectionString,
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-        });
-
-        describe("when the arugment connection string is invalid", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "switch-connection",
-                    arguments: {
-                        connectionString: "mongodb://localhost:12345",
-                    },
-                });
-
-                const content = getResponseContent(response.content);
-
-                expect(content).toContain("Error running switch-connection");
-            });
-        });
-    },
-    (mdbIntegration) => ({
-        ...config,
-        connectionString: mdbIntegration.connectionString(),
-    })
-);
-describeWithMongoDB(
-    "Connect tool",
-    (integration) => {
-        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
-            {
-                name: "connectionString",
-                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
-                type: "string",
-                required: true,
-            },
-        ]);
-
-        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
-
-        it("doesn't have the switch-connection tool registered", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const tool = tools.find((tool) => tool.name === "switch-connection");
-            expect(tool).toBeUndefined();
-        });
-
-        describe("with connection string", () => {
-            it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: {
-                        connectionString: integration.connectionString(),
-                    },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Successfully connected");
-            });
-        });
-
-        describe("with invalid connection string", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: { connectionString: "mongodb://localhost:12345" },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Error running connect");
-
-                // Should not suggest using the config connection string (because we don't have one)
-                expect(content).not.toContain("Your config lists a different connection string");
-            });
-        });
-    },
-    () => config
-);

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

@@ -1,104 +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";
-
-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()}`,
-        };
-    });
-});

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

@@ -1,171 +0,0 @@
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("explain tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "explain",
-        "Returns statistics describing the execution of the winning plan chosen by the query optimizer for the evaluated method",
-        [
-            ...databaseCollectionParameters,
-
-            {
-                name: "method",
-                description: "The method and its arguments to run",
-                type: "array",
-                required: true,
-            },
-        ]
-    );
-
-    validateThrowsForInvalidArguments(integration, "explain", [
-        {},
-        { database: 123, collection: "bar", method: [{ name: "find", arguments: {} }] },
-        { database: "test", collection: true, method: [{ name: "find", arguments: {} }] },
-        { database: "test", collection: "bar", method: [{ name: "dnif", arguments: {} }] },
-        { database: "test", collection: "bar", method: "find" },
-        { database: "test", collection: "bar", method: { name: "find", arguments: {} } },
-    ]);
-
-    const testCases = [
-        {
-            method: "aggregate",
-            arguments: { pipeline: [{ $match: { name: "Peter" } }] },
-        },
-        {
-            method: "find",
-            arguments: { filter: { name: "Peter" } },
-        },
-        {
-            method: "count",
-            arguments: {
-                query: { name: "Peter" },
-            },
-        },
-    ];
-
-    for (const testType of ["database", "collection"] as const) {
-        describe(`with non-existing ${testType}`, () => {
-            for (const testCase of testCases) {
-                it(`should return the explain plan for ${testCase.method}`, async () => {
-                    if (testType === "database") {
-                        const { databases } = await integration.mongoClient().db("").admin().listDatabases();
-                        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
-                    } else if (testType === "collection") {
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .createCollection("some-collection");
-
-                        const collections = await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .listCollections()
-                            .toArray();
-
-                        expect(collections.find((collection) => collection.name === "coll1")).toBeUndefined();
-                    }
-
-                    await integration.connectMcpClient();
-
-                    const response = await integration.mcpClient().callTool({
-                        name: "explain",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "coll1",
-                            method: [
-                                {
-                                    name: testCase.method,
-                                    arguments: testCase.arguments,
-                                },
-                            ],
-                        },
-                    });
-
-                    const content = getResponseElements(response.content);
-                    expect(content).toHaveLength(2);
-                    expect(content[0]?.text).toEqual(
-                        `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.coll1". This information can be used to understand how the query was executed and to optimize the query performance.`
-                    );
-
-                    expect(content[1]?.text).toContain("queryPlanner");
-                    expect(content[1]?.text).toContain("winningPlan");
-                });
-            }
-        });
-    }
-
-    describe("with existing database and collection", () => {
-        for (const indexed of [true, false] as const) {
-            describe(`with ${indexed ? "an index" : "no index"}`, () => {
-                beforeEach(async () => {
-                    await integration
-                        .mongoClient()
-                        .db(integration.randomDbName())
-                        .collection("people")
-                        .insertMany([{ name: "Alice" }, { name: "Bob" }, { name: "Charlie" }]);
-
-                    if (indexed) {
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("people")
-                            .createIndex({ name: 1 });
-                    }
-                });
-
-                for (const testCase of testCases) {
-                    it(`should return the explain plan for ${testCase.method}`, async () => {
-                        await integration.connectMcpClient();
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "explain",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "people",
-                                method: [
-                                    {
-                                        name: testCase.method,
-                                        arguments: testCase.arguments,
-                                    },
-                                ],
-                            },
-                        });
-
-                        const content = getResponseElements(response.content);
-                        expect(content).toHaveLength(2);
-                        expect(content[0]?.text).toEqual(
-                            `Here is some information about the winning plan chosen by the query optimizer for running the given \`${testCase.method}\` operation in "${integration.randomDbName()}.people". This information can be used to understand how the query was executed and to optimize the query performance.`
-                        );
-
-                        expect(content[1]?.text).toContain("queryPlanner");
-                        expect(content[1]?.text).toContain("winningPlan");
-
-                        if (indexed) {
-                            if (testCase.method === "count") {
-                                expect(content[1]?.text).toContain("COUNT_SCAN");
-                            } else {
-                                expect(content[1]?.text).toContain("IXSCAN");
-                            }
-                            expect(content[1]?.text).toContain("name_1");
-                        } else {
-                            expect(content[1]?.text).toContain("COLLSCAN");
-                        }
-                    });
-                }
-            });
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "explain", () => {
-        return {
-            args: { database: integration.randomDbName(), collection: "coll1", method: [] },
-            expectedResponse: "No method provided. Expected one of the following: `aggregate`, `find`, or `count`",
-        };
-    });
-});