mongodb-mcp-server 0.1.3 → 0.3.0

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

@@ -1,95 +0,0 @@
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-
-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,210 +0,0 @@
-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()",
-            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":',
-        };
-    });
-});

package/tests/integration/tools/mongodb/update/renameCollection.test.ts

@@ -1,194 +0,0 @@
-import {
-    getResponseContent,
-    databaseCollectionParameters,
-    validateToolMetadata,
-    validateThrowsForInvalidArguments,
-} from "../../../helpers.js";
-import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
-
-describeWithMongoDB("renameCollection tool", (integration) => {
-    validateToolMetadata(integration, "rename-collection", "Renames a collection in a MongoDB database", [
-        ...databaseCollectionParameters,
-
-        {
-            name: "newName",
-            description: "The new name for the collection",
-            type: "string",
-            required: true,
-        },
-        {
-            name: "dropTarget",
-            description: "If true, drops the target collection if it exists",
-            type: "boolean",
-            required: false,
-        },
-    ]);
-
-    validateThrowsForInvalidArguments(integration, "rename-collection", [
-        {},
-        { database: 123, collection: "bar" },
-        { database: "test", collection: [], newName: "foo" },
-        { database: "test", collection: "bar", newName: 10 },
-        { database: "test", collection: "bar", newName: "foo", dropTarget: "true" },
-        { database: "test", collection: "bar", newName: "foo", dropTarget: 1 },
-    ]);
-
-    describe("with non-existing database", () => {
-        it("returns an error", async () => {
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: "non-existent", collection: "foos", newName: "bar" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(`Cannot rename "non-existent.foos" because it doesn't exist.`);
-        });
-    });
-
-    describe("with non-existing collection", () => {
-        it("returns an error", async () => {
-            await integration.mongoClient().db(integration.randomDbName()).collection("bar").insertOne({});
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "non-existent", newName: "foo" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Cannot rename "${integration.randomDbName()}.non-existent" because it doesn't exist.`
-            );
-        });
-    });
-
-    describe("with existing collection", () => {
-        it("renames to non-existing collection", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
-            );
-
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(0);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(42);
-        });
-
-        it("returns an error when renaming to an existing collection", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Cannot rename "${integration.randomDbName()}.before" to "after" because the target collection already exists. If you want to overwrite it, set the "dropTarget" argument to true.`
-            );
-
-            // Ensure no data was lost
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(1);
-            expect(docsInBefore[0]?.value).toEqual(42);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(84);
-        });
-
-        it("renames to existing collection with dropTarget", async () => {
-            await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .insertOne({ value: 42 });
-            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
-
-            await integration.connectMcpClient();
-            const response = await integration.mcpClient().callTool({
-                name: "rename-collection",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "before",
-                    newName: "after",
-                    dropTarget: true,
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
-            );
-
-            // Ensure the data was moved
-            const docsInBefore = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("before")
-                .find({})
-                .toArray();
-            expect(docsInBefore).toHaveLength(0);
-
-            const docsInAfter = await integration
-                .mongoClient()
-                .db(integration.randomDbName())
-                .collection("after")
-                .find({})
-                .toArray();
-            expect(docsInAfter).toHaveLength(1);
-            expect(docsInAfter[0]?.value).toEqual(42);
-        });
-    });
-
-    validateAutoConnectBehavior(
-        integration,
-        "rename-collection",
-        () => {
-            return {
-                args: { database: integration.randomDbName(), collection: "coll1", newName: "coll2" },
-                expectedResponse: `Collection "coll1" renamed to "coll2" in database "${integration.randomDbName()}".`,
-            };
-        },
-        async () => {
-            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
-        }
-    );
-});