mongodb-mcp-server 0.2.0 → 0.3.0

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

@@ -1,115 +0,0 @@
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-} from "../../../helpers.js";
-import { expect, it } from "vitest";
-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,100 +0,0 @@
-import { IndexDirection } from "mongodb";
-import {
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-    databaseCollectionInvalidArgs,
-    expectDefined,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-import { expect, it } from "vitest";
-
-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.`,
-        };
-    });
-});

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

@@ -1,96 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-import { beforeEach, describe, expect, it } from "vitest";
-
-describeWithMongoDB("count tool", (integration) => {
-    validateToolMetadata(
-        integration,
-        "count",
-        "Gets the number of documents in a MongoDB collection using db.collection.count() and query as an optional filter parameter",
-        [
-            {
-                name: "query",
-                description:
-                    "A filter/query parameter. Allows users to filter the documents to count. Matches the syntax of the filter argument of db.collection.count().",
-                type: "object",
-                required: false,
-            },
-            ...databaseCollectionParameters,
-        ]
-    );
-
-    validateThrowsForInvalidArguments(integration, "count", [
-        {},
-        { database: 123, collection: "bar" },
-        { collection: [], database: "test" },
-        { collection: "bar", database: "test", query: "{ $gt: { foo: 5 } }" },
-    ]);
-
-    it("returns 0 when database doesn't exist", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "count",
-            arguments: { database: "non-existent", collection: "foos" },
-        });
-        const content = getResponseContent(response.content);
-        expect(content).toEqual('Found 0 documents in the collection "foos"');
-    });
-
-    it("returns 0 when collection doesn't exist", async () => {
-        await integration.connectMcpClient();
-        const mongoClient = integration.mongoClient();
-        await mongoClient.db(integration.randomDbName()).collection("bar").insertOne({});
-        const response = await integration.mcpClient().callTool({
-            name: "count",
-            arguments: { database: integration.randomDbName(), collection: "non-existent" },
-        });
-        const content = getResponseContent(response.content);
-        expect(content).toEqual('Found 0 documents in the collection "non-existent"');
-    });
-
-    describe("with existing database", () => {
-        beforeEach(async () => {
-            const mongoClient = integration.mongoClient();
-            await mongoClient
-                .db(integration.randomDbName())
-                .collection("foo")
-                .insertMany([
-                    { name: "Peter", age: 5 },
-                    { name: "Parker", age: 10 },
-                    { name: "George", age: 15 },
-                ]);
-        });
-
-        const testCases = [
-            { filter: undefined, expectedCount: 3 },
-            { filter: {}, expectedCount: 3 },
-            { filter: { age: { $lt: 15 } }, expectedCount: 2 },
-            { filter: { age: { $gt: 5 }, name: { $regex: "^P" } }, expectedCount: 1 },
-        ];
-        for (const testCase of testCases) {
-            it(`returns ${testCase.expectedCount} documents for filter ${JSON.stringify(testCase.filter)}`, async () => {
-                await integration.connectMcpClient();
-                const response = await integration.mcpClient().callTool({
-                    name: "count",
-                    arguments: { database: integration.randomDbName(), collection: "foo", query: testCase.filter },
-                });
-
-                const content = getResponseContent(response.content);
-                expect(content).toEqual(`Found ${testCase.expectedCount} documents in the collection "foo"`);
-            });
-        }
-    });
-
-    validateAutoConnectBehavior(integration, "count", () => {
-        return {
-            args: { database: integration.randomDbName(), collection: "coll1" },
-            expectedResponse: 'Found 0 documents in the collection "coll1"',
-        };
-    });
-});

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

@@ -1,211 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-    getResponseElements,
-    expectDefined,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("find tool", (integration) => {
-    validateToolMetadata(integration, "find", "Run a find query against a MongoDB collection", [
-        ...databaseCollectionParameters,
-
-        {
-            name: "filter",
-            description: "The query filter, matching the syntax of the query argument of db.collection.find()",
-            type: "object",
-            required: false,
-        },
-        {
-            name: "projection",
-            description: "The projection, matching the syntax of the projection argument of db.collection.find()",
-            type: "object",
-            required: false,
-        },
-        {
-            name: "limit",
-            description: "The maximum number of documents to return",
-            type: "number",
-            required: false,
-        },
-        {
-            name: "sort",
-            description:
-                "A document, describing the sort order, matching the syntax of the sort argument of cursor.sort(). The keys of the object are the fields to sort on, while the values are the sort directions (1 for ascending, -1 for descending).",
-            type: "object",
-            required: false,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "find", [
-        {},
-        { database: 123, collection: "bar" },
-        { database: "test", collection: [] },
-        { database: "test", collection: "bar", filter: "{ $gt: { foo: 5 } }" },
-        { database: "test", collection: "bar", projection: "name" },
-        { database: "test", collection: "bar", limit: "10" },
-        { database: "test", collection: "bar", sort: [], limit: 10 },
-    ]);
-
-    it("returns 0 when database doesn't exist", async () => {
-        await integration.connectMcpClient();
-        const response = await integration.mcpClient().callTool({
-            name: "find",
-            arguments: { database: "non-existent", collection: "foos" },
-        });
-        const content = getResponseContent(response.content);
-        expect(content).toEqual('Found 0 documents in the collection "foos":');
-    });
-
-    it("returns 0 when collection doesn't exist", async () => {
-        await integration.connectMcpClient();
-        const mongoClient = integration.mongoClient();
-        await mongoClient.db(integration.randomDbName()).collection("bar").insertOne({});
-        const response = await integration.mcpClient().callTool({
-            name: "find",
-            arguments: { database: integration.randomDbName(), collection: "non-existent" },
-        });
-        const content = getResponseContent(response.content);
-        expect(content).toEqual('Found 0 documents in the collection "non-existent":');
-    });
-
-    describe("with existing database", () => {
-        beforeEach(async () => {
-            const mongoClient = integration.mongoClient();
-            const items = Array(10)
-                .fill(0)
-                .map((_, index) => ({
-                    value: index,
-                }));
-
-            await mongoClient.db(integration.randomDbName()).collection("foo").insertMany(items);
-        });
-
-        const testCases: {
-            name: string;
-            filter?: unknown;
-            limit?: number;
-            projection?: unknown;
-            sort?: unknown;
-            expected: unknown[];
-        }[] = [
-            {
-                name: "returns all documents when no filter is provided",
-                expected: Array(10)
-                    .fill(0)
-                    .map((_, index) => ({ _id: expect.any(Object) as unknown, value: index })),
-            },
-            {
-                name: "returns documents matching the filter",
-                filter: { value: { $gt: 5 } },
-                expected: Array(4)
-                    .fill(0)
-
-                    .map((_, index) => ({ _id: expect.any(Object) as unknown, value: index + 6 })),
-            },
-            {
-                name: "returns documents matching the filter with projection",
-                filter: { value: { $gt: 5 } },
-                projection: { value: 1, _id: 0 },
-                expected: Array(4)
-                    .fill(0)
-                    .map((_, index) => ({ value: index + 6 })),
-            },
-            {
-                name: "returns documents matching the filter with limit",
-                filter: { value: { $gt: 5 } },
-                limit: 2,
-                expected: [
-                    { _id: expect.any(Object) as unknown, value: 6 },
-                    { _id: expect.any(Object) as unknown, value: 7 },
-                ],
-            },
-            {
-                name: "returns documents matching the filter with sort",
-                filter: {},
-                sort: { value: -1 },
-                expected: Array(10)
-                    .fill(0)
-                    .map((_, index) => ({ _id: expect.any(Object) as unknown, value: index }))
-                    .reverse(),
-            },
-        ];
-
-        for (const { name, filter, limit, projection, sort, expected } of testCases) {
-            it(name, async () => {
-                await integration.connectMcpClient();
-                const response = await integration.mcpClient().callTool({
-                    name: "find",
-                    arguments: {
-                        database: integration.randomDbName(),
-                        collection: "foo",
-                        filter,
-                        limit,
-                        projection,
-                        sort,
-                    },
-                });
-                const elements = getResponseElements(response.content);
-                expect(elements).toHaveLength(expected.length + 1);
-                expect(elements[0]?.text).toEqual(`Found ${expected.length} documents in the collection "foo":`);
-
-                for (let i = 0; i < expected.length; i++) {
-                    expect(JSON.parse(elements[i + 1]?.text ?? "{}")).toEqual(expected[i]);
-                }
-            });
-        }
-
-        it("returns all documents when no filter is provided", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "find",
-                arguments: { database: integration.randomDbName(), collection: "foo" },
-            });
-            const elements = getResponseElements(response.content);
-            expect(elements).toHaveLength(11);
-            expect(elements[0]?.text).toEqual('Found 10 documents in the collection "foo":');
-
-            for (let i = 0; i < 10; i++) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-                expect(JSON.parse(elements[i + 1]?.text ?? "{}").value).toEqual(i);
-            }
-        });
-
-        it("can find objects by $oid", async () => {
-            await integration.connectMcpClient();
-
-            const fooObject = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("foo")
-                .findOne();
-            expectDefined(fooObject);
-
-            const response = await integration.mcpClient().callTool({
-                name: "find",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "foo",
-                    filter: { _id: fooObject._id },
-                },
-            });
-
-            const elements = getResponseElements(response.content);
-            expect(elements).toHaveLength(2);
-            expect(elements[0]?.text).toEqual('Found 1 documents in the collection "foo":');
-
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            expect(JSON.parse(elements[1]?.text ?? "{}").value).toEqual(fooObject.value);
-        });
-    });
-
-    validateAutoConnectBehavior(integration, "find", () => {
-        return {
-            args: { database: integration.randomDbName(), collection: "coll1" },
-            expectedResponse: 'Found 0 documents in the collection "coll1":',
-        };
-    });
-});