Merge branch 'main' into fmenezes/atlas_connect_tool

fmenezes · fmenezes · commit 197b800d11c3 · 2025-04-28T16:57:08.000+01:00
diff --git a/.github/workflows/code_health.yaml b/.github/workflows/code_health.yaml
@@ -63,7 +63,7 @@ jobs:
           path: coverage/lcov.info
 
   coverage:
-    name: Run MongoDB tests
+    name: Report Coverage
     if: always() && github.event.pull_request.user.login != 'dependabot[bot]' && github.event.pull_request.head.repo.full_name == github.repository
     runs-on: ubuntu-latest
     needs: [run-tests, run-atlas-tests]
diff --git a/src/common/atlas/apiClient.ts b/src/common/atlas/apiClient.ts
@@ -15,7 +15,7 @@ export interface ApiClientCredentials {
 
 export interface ApiClientOptions {
     credentials?: ApiClientCredentials;
-    baseUrl?: string;
+    baseUrl: string;
     userAgent?: string;
 }
 
@@ -63,12 +63,11 @@ export class ApiClient {
         },
     };
 
-    constructor(options?: ApiClientOptions) {
+    constructor(options: ApiClientOptions) {
         this.options = {
             ...options,
-            baseUrl: options?.baseUrl || "https://cloud.mongodb.com/",
             userAgent:
-                options?.userAgent ||
+                options.userAgent ||
                 `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
         };
 
diff --git a/src/config.ts b/src/config.ts
@@ -4,26 +4,29 @@ import argv from "yargs-parser";
 
 import { ReadConcernLevel, ReadPreferenceMode, W } from "mongodb";
 
+export interface ConnectOptions {
+    readConcern: ReadConcernLevel;
+    readPreference: ReadPreferenceMode;
+    writeConcern: W;
+    timeoutMS: number;
+}
+
 // If we decide to support non-string config options, we'll need to extend the mechanism for parsing
 // env variables.
 export interface UserConfig {
-    apiBaseUrl?: string;
+    apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
     telemetry?: "enabled" | "disabled";
     logPath: string;
     connectionString?: string;
-    connectOptions: {
-        readConcern: ReadConcernLevel;
-        readPreference: ReadPreferenceMode;
-        writeConcern: W;
-        timeoutMS: number;
-    };
+    connectOptions: ConnectOptions;
     disabledTools: Array<string>;
     readOnly?: boolean;
 }
 
 const defaults: UserConfig = {
+    apiBaseUrl: "https://cloud.mongodb.com/",
     logPath: getLogPath(),
     connectOptions: {
         readConcern: "local",
diff --git a/src/index.ts b/src/index.ts
@@ -18,6 +18,7 @@ try {
         name: packageInfo.mcpServerName,
         version: packageInfo.version,
     });
+
     const server = new Server({
         mcpServer,
         session,
diff --git a/src/server.ts b/src/server.ts
@@ -33,7 +33,7 @@ export class Server {
         this.userConfig = userConfig;
     }
 
-    async connect(transport: Transport) {
+    async connect(transport: Transport): Promise<void> {
         this.mcpServer.server.registerCapabilities({ logging: {} });
 
         this.registerTools();
@@ -88,6 +88,8 @@ export class Server {
             const closeTime = Date.now();
             this.emitServerEvent("stop", Date.now() - closeTime, error);
         };
+
+        await this.validateConfig();
     }
 
     async close(): Promise<void> {
@@ -183,4 +185,29 @@ export class Server {
             );
         }
     }
+
+    private async validateConfig(): Promise<void> {
+        const isAtlasConfigured = this.userConfig.apiClientId && this.userConfig.apiClientSecret;
+        const isMongoDbConfigured = this.userConfig.connectionString;
+        if (!isAtlasConfigured && !isMongoDbConfigured) {
+            console.error(
+                "Either Atlas Client Id or a MongoDB connection string must be configured - you can provide them as environment variables or as startup arguments. \n" +
+                    "Provide the Atlas credentials as `MDB_MCP_API_CLIENT_ID` and `MDB_MCP_API_CLIENT_SECRET` environment variables or as `--apiClientId` and `--apiClientSecret` startup arguments. \n" +
+                    "Provide the MongoDB connection string as `MDB_MCP_CONNECTION_STRING` environment variable or as `--connectionString` startup argument."
+            );
+            throw new Error("Either Atlas Client Id or a MongoDB connection string must be configured");
+        }
+
+        if (this.userConfig.connectionString) {
+            try {
+                await this.session.connectToMongoDB(this.userConfig.connectionString, this.userConfig.connectOptions);
+            } catch (error) {
+                console.error(
+                    "Failed to connect to MongoDB instance using the connection string from the config: ",
+                    error
+                );
+                throw new Error("Failed to connect to MongoDB instance using the connection string from the config");
+            }
+        }
+    }
 }
diff --git a/src/session.ts b/src/session.ts
@@ -3,9 +3,10 @@ import { ApiClient, ApiClientCredentials } from "./common/atlas/apiClient.js";
 import { Implementation } from "@modelcontextprotocol/sdk/types.js";
 import logger, { LogId } from "./logger.js";
 import EventEmitter from "events";
+import { ConnectOptions } from "./config.js";
 
 export interface SessionOptions {
-    apiBaseUrl?: string;
+    apiBaseUrl: string;
     apiClientId?: string;
     apiClientSecret?: string;
 }
@@ -28,7 +29,7 @@ export class Session extends EventEmitter<{
         expiryDate: Date;
     };
 
-    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions = {}) {
+    constructor({ apiBaseUrl, apiClientId, apiClientSecret }: SessionOptions) {
         super();
 
         const credentials: ApiClientCredentials | undefined =
@@ -96,4 +97,21 @@ export class Session extends EventEmitter<{
         await this.disconnect();
         this.emit("close");
     }
+
+    async connectToMongoDB(connectionString: string, connectOptions: ConnectOptions): Promise<void> {
+        const provider = await NodeDriverServiceProvider.connect(connectionString, {
+            productDocsLink: "https://docs.mongodb.com/todo-mcp",
+            productName: "MongoDB MCP",
+            readConcern: {
+                level: connectOptions.readConcern,
+            },
+            readPreference: connectOptions.readPreference,
+            writeConcern: {
+                w: connectOptions.writeConcern,
+            },
+            timeoutMS: connectOptions.timeoutMS,
+        });
+
+        this.serviceProvider = provider;
+    }
 }
diff --git a/src/tools/atlas/metadata/connectCluster.ts b/src/tools/atlas/metadata/connectCluster.ts
@@ -100,7 +100,7 @@ export class ConnectClusterTool extends AtlasToolBase {
         cn.searchParams.set("authSource", "admin");
         const connectionString = cn.toString();
 
-        await this.connectToMongoDB(connectionString);
+        await this.session.connectToMongoDB(connectionString, this.config.connectOptions);
 
         return {
             content: [
diff --git a/src/tools/mongodb/create/insertMany.ts b/src/tools/mongodb/create/insertMany.ts
@@ -9,7 +9,7 @@ export class InsertManyTool extends MongoDBToolBase {
     protected argsShape = {
         ...DbOperationArgs,
         documents: z
-            .array(z.object({}).passthrough().describe("An individual MongoDB document"))
+            .array(z.record(z.string(), z.unknown()).describe("An individual MongoDB document"))
             .describe(
                 "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()"
             ),
diff --git a/src/tools/mongodb/delete/deleteMany.ts b/src/tools/mongodb/delete/deleteMany.ts
@@ -9,8 +9,7 @@ export class DeleteManyTool extends MongoDBToolBase {
     protected argsShape = {
         ...DbOperationArgs,
         filter: z
-            .object({})
-            .passthrough()
+            .record(z.string(), z.unknown())
             .optional()
             .describe(
                 "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()"
diff --git a/src/tools/mongodb/mongodbTool.ts b/src/tools/mongodb/mongodbTool.ts
@@ -69,4 +69,8 @@ export abstract class MongoDBToolBase extends ToolBase {
 
         return super.handleError(error, args);
     }
+
+    protected connectToMongoDB(connectionString: string): Promise<void> {
+        return this.session.connectToMongoDB(connectionString, this.config.connectOptions);
+    }
 }
diff --git a/src/tools/mongodb/read/aggregate.ts b/src/tools/mongodb/read/aggregate.ts
@@ -5,7 +5,7 @@ import { ToolArgs, OperationType } from "../../tool.js";
 import { EJSON } from "bson";
 
 export const AggregateArgs = {
-    pipeline: z.array(z.object({}).passthrough()).describe("An array of aggregation stages to execute"),
+    pipeline: z.array(z.record(z.string(), z.unknown())).describe("An array of aggregation stages to execute"),
 };
 
 export class AggregateTool extends MongoDBToolBase {
diff --git a/src/tools/mongodb/read/count.ts b/src/tools/mongodb/read/count.ts
@@ -5,8 +5,7 @@ import { z } from "zod";
 
 export const CountArgs = {
     query: z
-        .object({})
-        .passthrough()
+        .record(z.string(), z.unknown())
         .optional()
         .describe(
             "The query filter to count documents. Matches the syntax of the filter argument of db.collection.count()"
diff --git a/src/tools/mongodb/read/find.ts b/src/tools/mongodb/read/find.ts
@@ -7,13 +7,11 @@ import { EJSON } from "bson";
 
 export const FindArgs = {
     filter: z
-        .object({})
-        .passthrough()
+        .record(z.string(), z.unknown())
         .optional()
         .describe("The query filter, matching the syntax of the query argument of db.collection.find()"),
     projection: z
-        .object({})
-        .passthrough()
+        .record(z.string(), z.unknown())
         .optional()
         .describe("The projection, matching the syntax of the projection argument of db.collection.find()"),
     limit: z.number().optional().default(10).describe("The maximum number of documents to return"),
diff --git a/src/tools/mongodb/tools.ts b/src/tools/mongodb/tools.ts
@@ -1,4 +1,5 @@
-import { ConnectTool } from "./metadata/connect.js";
+// 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 { ListCollectionsTool } from "./metadata/listCollections.js";
 import { CollectionIndexesTool } from "./read/collectionIndexes.js";
 import { ListDatabasesTool } from "./metadata/listDatabases.js";
@@ -20,7 +21,8 @@ import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
 
 export const MongoDbTools = [
-    ConnectTool,
+    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+    // ConnectTool,
     ListCollectionsTool,
     ListDatabasesTool,
     CollectionIndexesTool,
diff --git a/src/tools/mongodb/update/updateMany.ts b/src/tools/mongodb/update/updateMany.ts
@@ -9,15 +9,13 @@ export class UpdateManyTool extends MongoDBToolBase {
     protected argsShape = {
         ...DbOperationArgs,
         filter: z
-            .object({})
-            .passthrough()
+            .record(z.string(), z.unknown())
             .optional()
             .describe(
                 "The selection criteria for the update, matching the syntax of the filter argument of db.collection.updateOne()"
             ),
         update: z
-            .object({})
-            .passthrough()
+            .record(z.string(), z.unknown())
             .describe("An update document describing the modifications to apply using update operator expressions"),
         upsert: z
             .boolean()
diff --git a/src/tools/tool.ts b/src/tools/tool.ts
@@ -6,7 +6,6 @@ import logger, { LogId } from "../logger.js";
 import { Telemetry } from "../telemetry/telemetry.js";
 import { type ToolEvent } from "../telemetry/types.js";
 import { UserConfig } from "../config.js";
-import { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 
 export type ToolArgs<Args extends ZodRawShape> = z.objectOutputType<Args, ZodNever>;
 
@@ -151,21 +150,4 @@ export abstract class ToolBase {
             ],
         };
     }
-
-    protected async connectToMongoDB(connectionString: string): Promise<void> {
-        const provider = await NodeDriverServiceProvider.connect(connectionString, {
-            productDocsLink: "https://docs.mongodb.com/todo-mcp",
-            productName: "MongoDB MCP",
-            readConcern: {
-                level: this.config.connectOptions.readConcern,
-            },
-            readPreference: this.config.connectOptions.readPreference,
-            writeConcern: {
-                w: this.config.connectOptions.writeConcern,
-            },
-            timeoutMS: this.config.connectOptions.timeoutMS,
-        });
-
-        this.session.serviceProvider = provider;
-    }
 }
diff --git a/tests/integration/helpers.ts b/tests/integration/helpers.ts
@@ -1,7 +1,7 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "./inMemoryTransport.js";
 import { Server } from "../../src/server.js";
-import { config, UserConfig } from "../../src/config.js";
+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";
@@ -20,7 +20,7 @@ export interface IntegrationTest {
     mcpServer: () => Server;
 }
 
-export function setupIntegrationTest(getUserConfig: () => UserConfig = () => config): IntegrationTest {
+export function setupIntegrationTest(getUserConfig: () => UserConfig): IntegrationTest {
     let mcpClient: Client | undefined;
     let mcpServer: Server | undefined;
 
diff --git a/tests/integration/server.test.ts b/tests/integration/server.test.ts
@@ -1,23 +1,27 @@
 import { expectDefined, setupIntegrationTest } from "./helpers.js";
 import { config } from "../../src/config.js";
+import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
 
 describe("Server integration test", () => {
-    describe("without atlas", () => {
-        const integration = setupIntegrationTest(() => ({
+    describeWithMongoDB(
+        "without atlas",
+        (integration) => {
+            it("should return positive number of tools and have no atlas tools", async () => {
+                const tools = await integration.mcpClient().listTools();
+                expectDefined(tools);
+                expect(tools.tools.length).toBeGreaterThan(0);
+
+                const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
+                expect(atlasTools.length).toBeLessThanOrEqual(0);
+            });
+        },
+        () => ({
             ...config,
             apiClientId: undefined,
             apiClientSecret: undefined,
-        }));
+        })
+    );
 
-        it("should return positive number of tools and have no atlas tools", async () => {
-            const tools = await integration.mcpClient().listTools();
-            expectDefined(tools);
-            expect(tools.tools.length).toBeGreaterThan(0);
-
-            const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
-            expect(atlasTools.length).toBeLessThanOrEqual(0);
-        });
-    });
     describe("with atlas", () => {
         const integration = setupIntegrationTest(() => ({
             ...config,
diff --git a/tests/integration/tools/atlas/atlasHelpers.ts b/tests/integration/tools/atlas/atlasHelpers.ts
@@ -2,12 +2,18 @@ import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
 import { setupIntegrationTest, IntegrationTest } from "../../helpers.js";
+import { config } from "../../../../src/config.js";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
 export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     const testDefinition = () => {
-        const integration = setupIntegrationTest();
+        const integration = setupIntegrationTest(() => ({
+            ...config,
+            apiClientId: process.env.MDB_MCP_API_CLIENT_ID,
+            apiClientSecret: process.env.MDB_MCP_API_CLIENT_SECRET,
+        }));
+
         describe(name, () => {
             fn(integration);
         });
diff --git a/tests/integration/tools/mongodb/metadata/connect.test.ts b/tests/integration/tools/mongodb/metadata/connect.test.ts
diff --git a/tests/integration/tools/mongodb/mongodbHelpers.ts b/tests/integration/tools/mongodb/mongodbHelpers.ts
diff --git a/tests/unit/telemetry.test.ts b/tests/unit/telemetry.test.ts

Original file line number	Diff line number	Diff line change
`@@ -69,4 +69,8 @@ export abstract class MongoDBToolBase extends ToolBase {`
`69`	`69`
`70`	`70`	`return super.handleError(error, args);`
`71`	`71`	`}`
	`72`	`+`
	`73`	`+ protected connectToMongoDB(connectionString: string): Promise<void> {`
	`74`	`+ return this.session.connectToMongoDB(connectionString, this.config.connectOptions);`
	`75`	`+ }`
`72`	`76`	`}`