mongodb-mcp-server 0.1.3 → 0.3.0

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

@@ -1,76 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseElements,
-    getResponseContent,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    databaseInvalidArgs,
-    databaseParameters,
-} from "../../../helpers.js";
-
-describeWithMongoDB("listCollections tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "list-collections",
-        "List all collections for a given database",
-        databaseParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "list-collections", databaseInvalidArgs);
-
-    describe("with non-existent database", () => {
-        it("returns no collections", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "list-collections",
-                arguments: { database: "non-existent" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                'No collections found for database "non-existent". To create a collection, use the "create-collection" tool.'
-            );
-        });
-    });
-
-    describe("with existing database", () => {
-        it("returns collections", async () => {
-            const mongoClient = integration.mongoClient();
-            await mongoClient.db(integration.randomDbName()).createCollection("collection-1");
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "list-collections",
-                arguments: { database: integration.randomDbName() },
-            });
-            const items = getResponseElements(response.content);
-            expect(items).toHaveLength(1);
-            expect(items[0]?.text).toContain('Name: "collection-1"');
-
-            await mongoClient.db(integration.randomDbName()).createCollection("collection-2");
-
-            const response2 = await integration.mcpClient().callTool({
-                name: "list-collections",
-                arguments: { database: integration.randomDbName() },
-            });
-            const items2 = getResponseElements(response2.content);
-            expect(items2).toHaveLength(2);
-            expect(items2.map((item) => item.text)).toIncludeSameMembers([
-                'Name: "collection-1"',
-                'Name: "collection-2"',
-            ]);
-        });
-    });
-
-    validateAutoConnectBehavior(
-        integration,
-        "list-collections",
-
-        () => {
-            return {
-                args: { database: integration.randomDbName() },
-                expectedResponse: `No collections found for database "${integration.randomDbName()}". To create a collection, use the "create-collection" tool.`,
-            };
-        }
-    );
-});

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

@@ -1,77 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-import { getResponseElements, getParameters, expectDefined } from "../../../helpers.js";
-
-describeWithMongoDB("listDatabases tool", (integration) => {
-    const defaultDatabases = ["admin", "config", "local"];
-
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const listDatabases = tools.find((tool) => tool.name === "list-databases");
-        expectDefined(listDatabases);
-        expect(listDatabases.description).toBe("List all databases for a MongoDB connection");
-
-        const parameters = getParameters(listDatabases);
-        expect(parameters).toHaveLength(0);
-    });
-
-    describe("with no preexisting databases", () => {
-        it("returns only the system databases", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
-            const dbNames = getDbNames(response.content);
-
-            expect(defaultDatabases).toIncludeAllMembers(dbNames);
-        });
-    });
-
-    describe("with preexisting databases", () => {
-        it("returns their names and sizes", async () => {
-            const mongoClient = integration.mongoClient();
-            await mongoClient.db("foo").collection("bar").insertOne({ test: "test" });
-            await mongoClient.db("baz").collection("qux").insertOne({ test: "test" });
-
-            await integration.connectMcpClient();
-
-            const response = await integration.mcpClient().callTool({ name: "list-databases", arguments: {} });
-            const dbNames = getDbNames(response.content);
-            expect(dbNames).toIncludeSameMembers([...defaultDatabases, "foo", "baz"]);
-        });
-    });
-
-    validateAutoConnectBehavior(
-        integration,
-        "list-databases",
-        () => {
-            return {
-                args: {},
-                validate: (content) => {
-                    const dbNames = getDbNames(content);
-
-                    expect(defaultDatabases).toIncludeAllMembers(dbNames);
-                },
-            };
-        },
-        async () => {
-            const mongoClient = integration.mongoClient();
-            const { databases } = await mongoClient.db("admin").command({ listDatabases: 1, nameOnly: true });
-            for (const db of databases as { name: string }[]) {
-                if (!defaultDatabases.includes(db.name)) {
-                    await mongoClient.db(db.name).dropDatabase();
-                }
-            }
-        }
-    );
-});
-
-function getDbNames(content: unknown): (string | null)[] {
-    const responseItems = getResponseElements(content);
-    return responseItems
-        .map((item) => {
-            if (item && typeof item.text === "string") {
-                const match = item.text.match(/Name: ([^,]+), Size: \d+ bytes/);
-                return match ? match[1] : null;
-            }
-            return null;
-        })
-        .filter((item): item is string | null => item !== undefined);
-}

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

@@ -1,83 +0,0 @@
-import { validateToolMetadata, validateThrowsForInvalidArguments, getResponseElements } from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("logs tool", (integration) => {
-    validateToolMetadata(integration, "mongodb-logs", "Returns the most recent logged mongod events", [
-        {
-            type: "string",
-            name: "type",
-            description:
-                "The type of logs to return. Global returns all recent log entries, while startupWarnings returns only warnings and errors from when the process started.",
-            required: false,
-        },
-        {
-            type: "integer",
-            name: "limit",
-            description: "The maximum number of log entries to return.",
-            required: false,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "mongodb-logs", [
-        { type: 123 },
-        { type: "something" },
-        { limit: 0 },
-        { limit: true },
-        { limit: 1025 },
-    ]);
-
-    it("should return global logs", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "mongodb-logs",
-            arguments: {},
-        });
-
-        const elements = getResponseElements(response);
-
-        // Default limit is 50
-        expect(elements.length).toBeLessThanOrEqual(51);
-        expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
-
-        for (let i = 1; i < elements.length; i++) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const log = JSON.parse(elements[i]?.text ?? "{}");
-            expect(log).toHaveProperty("t");
-            expect(log).toHaveProperty("msg");
-        }
-    });
-
-    it("should return startupWarnings logs", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "mongodb-logs",
-            arguments: {
-                type: "startupWarnings",
-            },
-        });
-
-        const elements = getResponseElements(response);
-        expect(elements.length).toBeLessThanOrEqual(51);
-        for (let i = 1; i < elements.length; i++) {
-            const log = JSON.parse(elements[i]?.text ?? "{}") as { tags: string[] };
-            expect(log).toHaveProperty("t");
-            expect(log).toHaveProperty("msg");
-            expect(log).toHaveProperty("tags");
-            expect(log.tags).toContain("startupWarnings");
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "mongodb-logs", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "foo",
-            },
-            validate: (content) => {
-                const elements = getResponseElements(content);
-                expect(elements.length).toBeLessThanOrEqual(51);
-                expect(elements[0]?.text).toMatch(/Found: \d+ messages/);
-            },
-        };
-    });
-});

package/tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -1,171 +0,0 @@
-import { MongoCluster } from "mongodb-runner";
-import path from "path";
-import { fileURLToPath } from "url";
-import fs from "fs/promises";
-import { MongoClient, ObjectId } from "mongodb";
-import { getResponseContent, IntegrationTest, setupIntegrationTest, defaultTestConfig } from "../../helpers.js";
-import { UserConfig } from "../../../../src/config.js";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-interface MongoDBIntegrationTest {
-    mongoClient: () => MongoClient;
-    connectionString: () => string;
-    randomDbName: () => string;
-}
-
-export function describeWithMongoDB(
-    name: string,
-    fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
-    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig
-) {
-    describe(name, () => {
-        const mdbIntegration = setupMongoDBIntegrationTest();
-        const integration = setupIntegrationTest(() => ({
-            ...getUserConfig(mdbIntegration),
-        }));
-
-        fn({
-            ...integration,
-            ...mdbIntegration,
-            connectMcpClient: async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                if (tools.find((tool) => tool.name === "connect")) {
-                    await integration.mcpClient().callTool({
-                        name: "connect",
-                        arguments: { connectionString: mdbIntegration.connectionString() },
-                    });
-                }
-            },
-        });
-    });
-}
-
-export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
-    let mongoCluster: MongoCluster | undefined;
-    let mongoClient: MongoClient | undefined;
-    let randomDbName: string;
-
-    beforeEach(() => {
-        randomDbName = new ObjectId().toString();
-    });
-
-    afterEach(async () => {
-        await mongoClient?.close();
-        mongoClient = undefined;
-    });
-
-    beforeAll(async function () {
-        // Downloading Windows executables in CI takes a long time because
-        // they include debug symbols...
-        const tmpDir = path.join(__dirname, "..", "..", "..", "tmp");
-        await fs.mkdir(tmpDir, { recursive: true });
-
-        // On Windows, we may have a situation where mongod.exe is not fully released by the OS
-        // before we attempt to run it again, so we add a retry.
-        let dbsDir = path.join(tmpDir, "mongodb-runner", "dbs");
-        for (let i = 0; i < 10; i++) {
-            try {
-                mongoCluster = await MongoCluster.start({
-                    tmpDir: dbsDir,
-                    logDir: path.join(tmpDir, "mongodb-runner", "logs"),
-                    topology: "standalone",
-                    version: "8.0.10",
-                });
-
-                return;
-            } catch (err) {
-                if (i < 5) {
-                    // Just wait a little bit and retry
-                    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                    console.error(`Failed to start cluster in ${dbsDir}, attempt ${i}: ${err}`);
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                } else {
-                    // If we still fail after 5 seconds, try another db dir
-                    console.error(
-                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                        `Failed to start cluster in ${dbsDir}, attempt ${i}: ${err}. Retrying with a new db dir.`
-                    );
-                    dbsDir = path.join(tmpDir, "mongodb-runner", `dbs${i - 5}`);
-                }
-            }
-        }
-
-        throw new Error("Failed to start cluster after 10 attempts");
-    }, 120_000);
-
-    afterAll(async function () {
-        await mongoCluster?.close();
-        mongoCluster = undefined;
-    });
-
-    const getConnectionString = () => {
-        if (!mongoCluster) {
-            throw new Error("beforeAll() hook not ran yet");
-        }
-
-        return mongoCluster.connectionString;
-    };
-
-    return {
-        mongoClient: () => {
-            if (!mongoClient) {
-                mongoClient = new MongoClient(getConnectionString());
-            }
-            return mongoClient;
-        },
-        connectionString: getConnectionString,
-
-        randomDbName: () => randomDbName,
-    };
-}
-
-export function validateAutoConnectBehavior(
-    integration: IntegrationTest & MongoDBIntegrationTest,
-    name: string,
-    validation: () => {
-        args: { [x: string]: unknown };
-        expectedResponse?: string;
-        validate?: (content: unknown) => void;
-    },
-    beforeEachImpl?: () => Promise<void>
-): void {
-    describe("when not connected", () => {
-        if (beforeEachImpl) {
-            beforeEach(() => beforeEachImpl());
-        }
-
-        afterEach(() => {
-            integration.mcpServer().userConfig.connectionString = undefined;
-        });
-
-        it("connects automatically if connection string is configured", async () => {
-            integration.mcpServer().userConfig.connectionString = integration.connectionString();
-
-            const validationInfo = validation();
-
-            const response = await integration.mcpClient().callTool({
-                name,
-                arguments: validationInfo.args,
-            });
-
-            if (validationInfo.expectedResponse) {
-                const content = getResponseContent(response.content);
-                expect(content).toContain(validationInfo.expectedResponse);
-            }
-
-            if (validationInfo.validate) {
-                validationInfo.validate(response.content);
-            }
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name,
-                arguments: validation().args,
-            });
-            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/read/aggregate.test.ts

@@ -1,114 +0,0 @@
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("aggregate tool", (integration) => {
-    validateToolMetadata(integration, "aggregate", "Run an aggregation against a MongoDB collection", [
-        ...databaseCollectionParameters,
-        {
-            name: "pipeline",
-            description: "An array of aggregation stages to execute",
-            type: "array",
-            required: true,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "aggregate", [
-        {},
-        { database: "test", collection: "foo" },
-        { database: test, pipeline: [] },
-        { database: "test", collection: "foo", pipeline: {} },
-        { database: "test", collection: [], pipeline: [] },
-        { database: 123, collection: "foo", pipeline: [] },
-    ]);
-
-    it("can run aggragation on non-existent database", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "aggregate",
-            arguments: { database: "non-existent", collection: "people", pipeline: [{ $match: { name: "Peter" } }] },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(1);
-        expect(elements[0]?.text).toEqual('Found 0 documents in the collection "people":');
-    });
-
-    it("can run aggragation on an empty collection", async () => {
-        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
-
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "aggregate",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "people",
-                pipeline: [{ $match: { name: "Peter" } }],
-            },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(1);
-        expect(elements[0]?.text).toEqual('Found 0 documents in the collection "people":');
-    });
-
-    it("can run aggragation on an existing collection", async () => {
-        const mongoClient = integration.mongoClient();
-        await mongoClient
-            .db(integration.randomDbName())
-            .collection("people")
-            .insertMany([
-                { name: "Peter", age: 5 },
-                { name: "Laura", age: 10 },
-                { name: "Søren", age: 15 },
-            ]);
-
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "aggregate",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "people",
-                pipeline: [{ $match: { age: { $gt: 8 } } }, { $sort: { name: -1 } }],
-            },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(3);
-        expect(elements[0]?.text).toEqual('Found 2 documents in the collection "people":');
-        expect(asObject(JSON.parse(elements[1]?.text ?? "{}"))).toEqual(
-            expect.objectContaining({
-                _id: expect.any(Object) as object,
-                name: "Søren",
-                age: 15,
-            })
-        );
-        expect(asObject(JSON.parse(elements[2]?.text ?? "{}"))).toEqual(
-            expect.objectContaining({
-                _id: expect.any(Object) as object,
-                name: "Laura",
-                age: 10,
-            })
-        );
-    });
-
-    validateAutoConnectBehavior(integration, "aggregate", () => {
-        return {
-            args: {
-                database: integration.randomDbName(),
-                collection: "coll1",
-                pipeline: [{ $match: { name: "Liva" } }],
-            },
-            expectedResponse: 'Found 0 documents in the collection "coll1"',
-        };
-    });
-});
-
-function asObject(val: unknown): Record<string, unknown> {
-    if (typeof val === "object" && val !== null) return val as Record<string, unknown>;
-    throw new Error("Expected an object");
-}

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

@@ -1,99 +0,0 @@
-import { IndexDirection } from "mongodb";
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-    databaseCollectionInvalidArgs,
-    expectDefined,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("collectionIndexes tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "collection-indexes",
-        "Describe the indexes for a collection",
-        databaseCollectionParameters
-    );
-
-    validateThrowsForInvalidArguments(integration, "collection-indexes", databaseCollectionInvalidArgs);
-
-    it("can inspect indexes on non-existent database", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "collection-indexes",
-            arguments: { database: "non-existent", collection: "people" },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(1);
-        expect(elements[0]?.text).toEqual(
-            'The indexes for "non-existent.people" cannot be determined because the collection does not exist.'
-        );
-    });
-
-    it("returns the _id index for a new collection", async () => {
-        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
-
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "collection-indexes",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "people",
-            },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(2);
-        expect(elements[0]?.text).toEqual('Found 1 indexes in the collection "people":');
-        expect(elements[1]?.text).toEqual('Name "_id_", definition: {"_id":1}');
-    });
-
-    it("returns all indexes for a collection", async () => {
-        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
-
-        const indexTypes: IndexDirection[] = [-1, 1, "2d", "2dsphere", "text", "hashed"];
-        for (const indexType of indexTypes) {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("people")
-                .createIndex({ [`prop_${indexType}`]: indexType });
-        }
-
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "collection-indexes",
-            arguments: {
-                database: integration.randomDbName(),
-                collection: "people",
-            },
-        });
-
-        const elements = getResponseElements(response.content);
-        expect(elements).toHaveLength(indexTypes.length + 2);
-        expect(elements[0]?.text).toEqual(`Found ${indexTypes.length + 1} indexes in the collection "people":`);
-        expect(elements[1]?.text).toEqual('Name "_id_", definition: {"_id":1}');
-
-        for (const indexType of indexTypes) {
-            const index = elements.find((element) => element.text.includes(`prop_${indexType}`));
-            expectDefined(index);
-
-            let expectedDefinition = JSON.stringify({ [`prop_${indexType}`]: indexType });
-            if (indexType === "text") {
-                expectedDefinition = '{"_fts":"text"';
-            }
-
-            expect(index.text).toContain(`definition: ${expectedDefinition}`);
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "collection-indexes", () => {
-        return {
-            args: { database: integration.randomDbName(), collection: "coll1" },
-            expectedResponse: `The indexes for "${integration.randomDbName()}.coll1" cannot be determined because the collection does not exist.`,
-        };
-    });
-});