mongodb-mcp-server 0.0.8 → 0.1.1

package/src/tools/atlas/read/listClusters.ts

@@ -2,7 +2,13 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { AtlasToolBase } from "../atlasTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { PaginatedClusterDescription20240805, PaginatedOrgGroupView, Group } from "../../../common/atlas/openapi.js";
+import {
+    PaginatedClusterDescription20240805,
+    PaginatedOrgGroupView,
+    Group,
+    PaginatedFlexClusters20241113,
+} from "../../../common/atlas/openapi.js";
+import { formatCluster, formatFlexCluster } from "../../../common/atlas/cluster.js";
 
 export class ListClustersTool extends AtlasToolBase {
     protected name = "atlas-list-clusters";
@@ -73,43 +79,20 @@ ${rows}`,
         };
     }
 
-    private formatClustersTable(project: Group, clusters?: PaginatedClusterDescription20240805): CallToolResult {
-        if (!clusters?.results?.length) {
+    private formatClustersTable(
+        project: Group,
+        clusters?: PaginatedClusterDescription20240805,
+        flexClusters?: PaginatedFlexClusters20241113
+    ): CallToolResult {
+        // Check if both traditional clusters and flex clusters are absent
+        if (!clusters?.results?.length && !flexClusters?.results?.length) {
             throw new Error("No clusters found.");
         }
-        const rows = clusters.results
-            .map((cluster) => {
-                const connectionString =
-                    cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard || "N/A";
-                const mongoDBVersion = cluster.mongoDBVersion || "N/A";
-                const regionConfigs = (cluster.replicationSpecs || [])
-                    .map(
-                        (replicationSpec) =>
-                            (replicationSpec.regionConfigs || []) as {
-                                providerName: string;
-                                electableSpecs?: {
-                                    instanceSize: string;
-                                };
-                                readOnlySpecs?: {
-                                    instanceSize: string;
-                                };
-                            }[]
-                    )
-                    .flat()
-                    .map((regionConfig) => {
-                        return {
-                            providerName: regionConfig.providerName,
-                            instanceSize:
-                                regionConfig.electableSpecs?.instanceSize || regionConfig.readOnlySpecs?.instanceSize,
-                        };
-                    });
-
-                const instanceSize =
-                    (regionConfigs.length <= 0 ? undefined : regionConfigs[0].instanceSize) || "UNKNOWN";
-
-                const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
-
-                return `${cluster.name} | ${clusterInstanceType} | ${clusterInstanceType == "DEDICATED" ? instanceSize : "N/A"} | ${cluster.stateName} | ${mongoDBVersion} | ${connectionString}`;
+        const formattedClusters = clusters?.results?.map((cluster) => formatCluster(cluster)) || [];
+        const formattedFlexClusters = flexClusters?.results?.map((cluster) => formatFlexCluster(cluster)) || [];
+        const rows = [...formattedClusters, ...formattedFlexClusters]
+            .map((formattedCluster) => {
+                return `${formattedCluster.name || "Unknown"} | ${formattedCluster.instanceType} | ${formattedCluster.instanceSize || "N/A"} | ${formattedCluster.state || "UNKNOWN"} | ${formattedCluster.mongoDBVersion || "N/A"} | ${formattedCluster.connectionString || "N/A"}`;
             })
             .join("\n");
         return {

package/src/tools/mongodb/tools.ts

@@ -1,5 +1,4 @@
-// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-// import { ConnectTool } from "./metadata/connect.js";
+import { ConnectTool } from "./metadata/connect.js";
 import { ListCollectionsTool } from "./metadata/listCollections.js";
 import { CollectionIndexesTool } from "./read/collectionIndexes.js";
 import { ListDatabasesTool } from "./metadata/listDatabases.js";
@@ -21,8 +20,7 @@ import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
 
 export const MongoDbTools = [
-    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-    // ConnectTool,
+    ConnectTool,
     ListCollectionsTool,
     ListDatabasesTool,
     CollectionIndexesTool,

package/src/types/mongodb-connection-string-url.d.ts

@@ -0,0 +1,69 @@
+declare module "mongodb-connection-string-url" {
+    import { URL } from "whatwg-url";
+    import { redactConnectionString, ConnectionStringRedactionOptions } from "./redact";
+    export { redactConnectionString, ConnectionStringRedactionOptions };
+    declare class CaseInsensitiveMap<K extends string = string> extends Map<K, string> {
+        delete(name: K): boolean;
+        get(name: K): string | undefined;
+        has(name: K): boolean;
+        set(name: K, value: any): this;
+        _normalizeKey(name: any): K;
+    }
+    declare abstract class URLWithoutHost extends URL {
+        abstract get host(): never;
+        abstract set host(value: never);
+        abstract get hostname(): never;
+        abstract set hostname(value: never);
+        abstract get port(): never;
+        abstract set port(value: never);
+        abstract get href(): string;
+        abstract set href(value: string);
+    }
+    export interface ConnectionStringParsingOptions {
+        looseValidation?: boolean;
+    }
+    export declare class ConnectionString extends URLWithoutHost {
+        _hosts: string[];
+        constructor(uri: string, options?: ConnectionStringParsingOptions);
+        get host(): never;
+        set host(_ignored: never);
+        get hostname(): never;
+        set hostname(_ignored: never);
+        get port(): never;
+        set port(_ignored: never);
+        get href(): string;
+        set href(_ignored: string);
+        get isSRV(): boolean;
+        get hosts(): string[];
+        set hosts(list: string[]);
+        toString(): string;
+        clone(): ConnectionString;
+        redact(options?: ConnectionStringRedactionOptions): ConnectionString;
+        typedSearchParams<T extends {}>(): {
+            append(name: keyof T & string, value: any): void;
+            delete(name: keyof T & string): void;
+            get(name: keyof T & string): string | null;
+            getAll(name: keyof T & string): string[];
+            has(name: keyof T & string): boolean;
+            set(name: keyof T & string, value: any): void;
+            keys(): IterableIterator<keyof T & string>;
+            values(): IterableIterator<string>;
+            entries(): IterableIterator<[keyof T & string, string]>;
+            _normalizeKey(name: keyof T & string): string;
+            [Symbol.iterator](): IterableIterator<[keyof T & string, string]>;
+            sort(): void;
+            forEach<THIS_ARG = void>(
+                callback: (this: THIS_ARG, value: string, name: string, searchParams: any) => void,
+                thisArg?: THIS_ARG | undefined
+            ): void;
+            readonly [Symbol.toStringTag]: "URLSearchParams";
+        };
+    }
+    export declare class CommaAndColonSeparatedRecord<
+        K extends {} = Record<string, unknown>,
+    > extends CaseInsensitiveMap<keyof K & string> {
+        constructor(from?: string | null);
+        toString(): string;
+    }
+    export default ConnectionString;
+}

package/tests/integration/helpers.ts

@@ -5,7 +5,9 @@ import { UserConfig } from "../../src/config.js";
 import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Session } from "../../src/session.js";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
 import { config } from "../../src/config.js";
+import { jest } from "@jest/globals";
 
 interface ParameterInfo {
     name: string;
@@ -56,14 +58,27 @@ export function setupIntegrationTest(getUserConfig: () => UserConfig): Integrati
             apiClientSecret: userConfig.apiClientSecret,
         });
 
+        // Mock hasValidAccessToken for tests
+        if (userConfig.apiClientId && userConfig.apiClientSecret) {
+            const mockFn = jest.fn<() => Promise<boolean>>().mockResolvedValue(true);
+            // @ts-expect-error accessing private property for testing
+            session.apiClient.validateAccessToken = mockFn;
+        }
+
+        userConfig.telemetry = "disabled";
+
+        const telemetry = Telemetry.create(session, userConfig);
+
         mcpServer = new Server({
             session,
             userConfig,
+            telemetry,
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "5.2.3",
             }),
         });
+
         await mcpServer.connect(serverTransport);
         await mcpClient.connect(clientTransport);
     });
@@ -117,7 +132,7 @@ export function getResponseElements(content: unknown | { content: unknown }): {
         content = (content as { content: unknown }).content;
     }
 
-    expect(Array.isArray(content)).toBe(true);
+    expect(content).toBeArray();
 
     const response = content as { type: string; text: string }[];
     for (const item of response) {
@@ -221,6 +236,7 @@ export function validateThrowsForInvalidArguments(
 }
 
 /** Expects the argument being defined and asserts it */
-export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined> {
+export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined | null> {
     expect(arg).toBeDefined();
+    expect(arg).not.toBeNull();
 }

package/tests/integration/telemetry.test.ts

@@ -0,0 +1,28 @@
+import { createHmac } from "crypto";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
+import { Session } from "../../src/session.js";
+import { config } from "../../src/config.js";
+import nodeMachineId from "node-machine-id";
+
+describe("Telemetry", () => {
+    it("should resolve the actual machine ID", async () => {
+        const actualId: string = await nodeMachineId.machineId(true);
+
+        const actualHashedId = createHmac("sha256", actualId.toUpperCase()).update("atlascli").digest("hex");
+
+        const telemetry = Telemetry.create(
+            new Session({
+                apiBaseUrl: "",
+            }),
+            config
+        );
+
+        expect(telemetry.getCommonProperties().device_id).toBe(undefined);
+        expect(telemetry["isBufferingEvents"]).toBe(true);
+
+        await telemetry.deviceIdPromise;
+
+        expect(telemetry.getCommonProperties().device_id).toBe(actualHashedId);
+        expect(telemetry["isBufferingEvents"]).toBe(false);
+    });
+});

package/tests/integration/tools/atlas/dbUsers.test.ts

@@ -1,24 +1,49 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { Session } from "../../../../src/session.js";
 import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { expectDefined } from "../../helpers.js";
+import { expectDefined, getResponseElements } from "../../helpers.js";
+import { ApiClientError } from "../../../../src/common/atlas/apiClientError.js";
 
 describeWithAtlas("db users", (integration) => {
-    const userName = "testuser-" + randomId;
     withProject(integration, ({ getProjectId }) => {
-        afterAll(async () => {
-            const projectId = getProjectId();
+        let userName: string;
+        beforeEach(() => {
+            userName = "testuser-" + randomId;
+        });
 
-            const session: Session = integration.mcpServer().session;
-            await session.apiClient.deleteDatabaseUser({
-                params: {
-                    path: {
-                        groupId: projectId,
-                        username: userName,
-                        databaseName: "admin",
-                    },
+        const createUserWithMCP = async (password?: string): Promise<unknown> => {
+            return await integration.mcpClient().callTool({
+                name: "atlas-create-db-user",
+                arguments: {
+                    projectId: getProjectId(),
+                    username: userName,
+                    password,
+                    roles: [
+                        {
+                            roleName: "readWrite",
+                            databaseName: "admin",
+                        },
+                    ],
                 },
             });
+        };
+
+        afterEach(async () => {
+            try {
+                await integration.mcpServer().session.apiClient.deleteDatabaseUser({
+                    params: {
+                        path: {
+                            groupId: getProjectId(),
+                            username: userName,
+                            databaseName: "admin",
+                        },
+                    },
+                });
+            } catch (error) {
+                // Ignore 404 errors when deleting the user
+                if (!(error instanceof ApiClientError) || error.response?.status !== 404) {
+                    throw error;
+                }
+            }
         });
 
         describe("atlas-create-db-user", () => {
@@ -34,26 +59,24 @@ describeWithAtlas("db users", (integration) => {
                 expect(createDbUser.inputSchema.properties).toHaveProperty("roles");
                 expect(createDbUser.inputSchema.properties).toHaveProperty("clusters");
             });
-            it("should create a database user", async () => {
-                const projectId = getProjectId();
 
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-create-db-user",
-                    arguments: {
-                        projectId,
-                        username: userName,
-                        password: "testpassword",
-                        roles: [
-                            {
-                                roleName: "readWrite",
-                                databaseName: "admin",
-                            },
-                        ],
-                    },
-                })) as CallToolResult;
-                expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0].text).toContain("created sucessfully");
+            it("should create a database user with supplied password", async () => {
+                const response = await createUserWithMCP("testpassword");
+
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(1);
+                expect(elements[0].text).toContain("created successfully");
+                expect(elements[0].text).toContain(userName);
+                expect(elements[0].text).not.toContain("testpassword");
+            });
+
+            it("should create a database user with generated password", async () => {
+                const response = await createUserWithMCP();
+                const elements = getResponseElements(response);
+                expect(elements).toHaveLength(1);
+                expect(elements[0].text).toContain("created successfully");
+                expect(elements[0].text).toContain(userName);
+                expect(elements[0].text).toContain("with password: `");
             });
         });
         describe("atlas-list-db-users", () => {
@@ -68,6 +91,8 @@ describeWithAtlas("db users", (integration) => {
             it("returns database users by project", async () => {
                 const projectId = getProjectId();
 
+                await createUserWithMCP();
+
                 const response = (await integration
                     .mcpClient()
                     .callTool({ name: "atlas-list-db-users", arguments: { projectId } })) as CallToolResult;

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

@@ -2,8 +2,6 @@ import { describeWithMongoDB } from "../mongodbHelpers.js";
 import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
 import { config } from "../../../../../src/config.js";
 
-// These tests are temporarily skipped because the connect tool is disabled for the initial release.
-// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
 describeWithMongoDB(
     "switchConnection tool",
     (integration) => {
@@ -77,8 +75,7 @@ describeWithMongoDB(
     (mdbIntegration) => ({
         ...config,
         connectionString: mdbIntegration.connectionString(),
-    }),
-    describe.skip
+    })
 );
 describeWithMongoDB(
     "Connect tool",
@@ -127,6 +124,5 @@ describeWithMongoDB(
             });
         });
     },
-    () => config,
-    describe.skip
+    () => config
 );

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

@@ -17,42 +17,32 @@ interface MongoDBIntegrationTest {
 export function describeWithMongoDB(
     name: string,
     fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
-    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig,
-    describeFn = describe
+    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => defaultTestConfig
 ) {
-    describeFn(name, () => {
+    describe(name, () => {
         const mdbIntegration = setupMongoDBIntegrationTest();
         const integration = setupIntegrationTest(() => ({
             ...getUserConfig(mdbIntegration),
-            connectionString: mdbIntegration.connectionString(),
         }));
 
-        beforeEach(() => {
-            integration.mcpServer().userConfig.connectionString = mdbIntegration.connectionString();
-        });
-
         fn({
             ...integration,
             ...mdbIntegration,
             connectMcpClient: async () => {
-                // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when
-                // the connect tool is reenabled
-                // await integration.mcpClient().callTool({
-                //     name: "connect",
-                //     arguments: { connectionString: mdbIntegration.connectionString() },
-                // });
+                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: // TODO: Fix this type once mongodb-runner is updated.
-    | {
-              connectionString: string;
-              close: () => Promise<void>;
-          }
-        | undefined;
+    let mongoCluster: MongoCluster | undefined;
     let mongoClient: MongoClient | undefined;
     let randomDbName: string;
 
@@ -76,8 +66,6 @@ export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
         let dbsDir = path.join(tmpDir, "mongodb-runner", "dbs");
         for (let i = 0; i < 10; i++) {
             try {
-                // TODO: Fix this type once mongodb-runner is updated.
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
                 mongoCluster = await MongoCluster.start({
                     tmpDir: dbsDir,
                     logDir: path.join(tmpDir, "mongodb-runner", "logs"),
@@ -141,12 +129,15 @@ export function validateAutoConnectBehavior(
     },
     beforeEachImpl?: () => Promise<void>
 ): void {
-    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
-    describe.skip("when not connected", () => {
+    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();
 

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

@@ -4,6 +4,7 @@ import {
     validateToolMetadata,
     validateThrowsForInvalidArguments,
     getResponseElements,
+    expectDefined,
 } from "../../../helpers.js";
 import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
 
@@ -171,6 +172,33 @@ describeWithMongoDB("find tool", (integration) => {
                 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", () => {

package/tests/unit/EJsonTransport.test.ts

@@ -0,0 +1,71 @@
+import { Decimal128, MaxKey, MinKey, ObjectId, Timestamp, UUID } from "bson";
+import { createEJsonTransport, EJsonReadBuffer } from "../../src/helpers/EJsonTransport.js";
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import { AuthInfo } from "@modelcontextprotocol/sdk/server/auth/types.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Readable } from "stream";
+import { ReadBuffer } from "@modelcontextprotocol/sdk/shared/stdio.js";
+
+describe("EJsonTransport", () => {
+    let transport: StdioServerTransport;
+    beforeEach(async () => {
+        transport = createEJsonTransport();
+        await transport.start();
+    });
+
+    afterEach(async () => {
+        await transport.close();
+    });
+
+    it("ejson deserializes messages", () => {
+        const messages: { message: JSONRPCMessage; extra?: { authInfo?: AuthInfo } }[] = [];
+        transport.onmessage = (
+            message,
+            extra?: {
+                authInfo?: AuthInfo;
+            }
+        ) => {
+            messages.push({ message, extra });
+        };
+
+        (transport["_stdin"] as Readable).emit(
+            "data",
+            Buffer.from(
+                '{"jsonrpc":"2.0","id":1,"method":"testMethod","params":{"oid":{"$oid":"681b741f13aa74a0687b5110"},"uuid":{"$uuid":"f81d4fae-7dec-11d0-a765-00a0c91e6bf6"},"date":{"$date":"2025-05-07T14:54:23.973Z"},"decimal":{"$numberDecimal":"1234567890987654321"},"int32":123,"maxKey":{"$maxKey":1},"minKey":{"$minKey":1},"timestamp":{"$timestamp":{"t":123,"i":456}}}}\n',
+                "utf-8"
+            )
+        );
+
+        expect(messages.length).toBe(1);
+        const message = messages[0].message;
+
+        expect(message).toEqual({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "testMethod",
+            params: {
+                oid: new ObjectId("681b741f13aa74a0687b5110"),
+                uuid: new UUID("f81d4fae-7dec-11d0-a765-00a0c91e6bf6"),
+                date: new Date(Date.parse("2025-05-07T14:54:23.973Z")),
+                decimal: new Decimal128("1234567890987654321"),
+                int32: 123,
+                maxKey: new MaxKey(),
+                minKey: new MinKey(),
+                timestamp: new Timestamp({ t: 123, i: 456 }),
+            },
+        });
+    });
+
+    it("has _readBuffer field of type EJsonReadBuffer", () => {
+        expect(transport["_readBuffer"]).toBeDefined();
+        expect(transport["_readBuffer"]).toBeInstanceOf(EJsonReadBuffer);
+    });
+
+    describe("standard StdioServerTransport", () => {
+        it("has a _readBuffer field", () => {
+            const standardTransport = new StdioServerTransport();
+            expect(standardTransport["_readBuffer"]).toBeDefined();
+            expect(standardTransport["_readBuffer"]).toBeInstanceOf(ReadBuffer);
+        });
+    });
+});