mongodb-mcp-server 0.0.4 → 0.0.6

package/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";
@@ -17,9 +18,11 @@ import { DropDatabaseTool } from "./delete/dropDatabase.js";
 import { DropCollectionTool } from "./delete/dropCollection.js";
 import { ExplainTool } from "./metadata/explain.js";
 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,
@@ -38,4 +41,5 @@ export const MongoDbTools = [
     DropCollectionTool,
     ExplainTool,
     CreateCollectionTool,
+    LogsTool,
 ];

package/src/tools/mongodb/update/renameCollection.ts

@@ -1,14 +1,13 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { MongoDBToolBase } from "../mongodbTool.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class RenameCollectionTool extends MongoDBToolBase {
     protected name = "rename-collection";
     protected description = "Renames a collection in a MongoDB database";
     protected argsShape = {
-        collection: z.string().describe("Collection name"),
-        database: z.string().describe("Database name"),
+        ...DbOperationArgs,
         newName: z.string().describe("The new name for the collection"),
         dropTarget: z.boolean().optional().default(false).describe("If true, drops the target collection if it exists"),
     };
@@ -28,10 +27,40 @@ export class RenameCollectionTool extends MongoDBToolBase {
         return {
             content: [
                 {
-                    text: `Collection \`${collection}\` renamed to \`${result.collectionName}\` in database \`${database}\`.`,
+                    text: `Collection "${collection}" renamed to "${result.collectionName}" in database "${database}".`,
                     type: "text",
                 },
             ],
         };
     }
+
+    protected handleError(
+        error: unknown,
+        args: ToolArgs<typeof this.argsShape>
+    ): Promise<CallToolResult> | CallToolResult {
+        if (error instanceof Error && "codeName" in error) {
+            switch (error.codeName) {
+                case "NamespaceNotFound":
+                    return {
+                        content: [
+                            {
+                                text: `Cannot rename "${args.database}.${args.collection}" because it doesn't exist.`,
+                                type: "text",
+                            },
+                        ],
+                    };
+                case "NamespaceExists":
+                    return {
+                        content: [
+                            {
+                                text: `Cannot rename "${args.database}.${args.collection}" to "${args.newName}" because the target collection already exists. If you want to overwrite it, set the "dropTarget" argument to true.`,
+                                type: "text",
+                            },
+                        ],
+                    };
+            }
+        }
+
+        return super.handleError(error, args);
+    }
 }

package/src/tools/mongodb/update/updateMany.ts

@@ -1,25 +1,21 @@
 import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { MongoDBToolBase } from "../mongodbTool.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
 export class UpdateManyTool extends MongoDBToolBase {
     protected name = "update-many";
     protected description = "Updates all documents that match the specified filter for a collection";
     protected argsShape = {
-        collection: z.string().describe("Collection name"),
-        database: z.string().describe("Database name"),
+        ...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()
-            .optional()
+            .record(z.string(), z.unknown())
             .describe("An update document describing the modifications to apply using update operator expressions"),
         upsert: z
             .boolean()
@@ -41,15 +37,15 @@ export class UpdateManyTool extends MongoDBToolBase {
         });
 
         let message = "";
-        if (result.matchedCount === 0) {
-            message = `No documents matched the filter.`;
+        if (result.matchedCount === 0 && result.modifiedCount === 0 && result.upsertedCount === 0) {
+            message = "No documents matched the filter.";
         } else {
             message = `Matched ${result.matchedCount} document(s).`;
             if (result.modifiedCount > 0) {
                 message += ` Modified ${result.modifiedCount} document(s).`;
             }
             if (result.upsertedCount > 0) {
-                message += ` Upserted ${result.upsertedCount} document(s) (with id: ${result.upsertedId?.toString()}).`;
+                message += ` Upserted ${result.upsertedCount} document with id: ${result.upsertedId?.toString()}.`;
             }
         }
 

package/src/tools/tool.ts

@@ -1,14 +1,15 @@
-import { McpServer, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z, ZodNever, ZodRawShape } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z, type ZodRawShape, type ZodNever, AnyZodObject } from "zod";
+import type { McpServer, RegisteredTool, ToolCallback } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { Session } from "../session.js";
-import logger from "../logger.js";
-import { mongoLogId } from "mongodb-log-writer";
-import config from "../config.js";
+import logger, { LogId } from "../logger.js";
+import { Telemetry } from "../telemetry/telemetry.js";
+import { type ToolEvent } from "../telemetry/types.js";
+import { UserConfig } from "../config.js";
 
 export type ToolArgs<Args extends ZodRawShape> = z.objectOutputType<Args, ZodNever>;
 
-export type OperationType = "metadata" | "read" | "create" | "delete" | "update" | "cluster";
+export type OperationType = "metadata" | "read" | "create" | "delete" | "update";
 export type ToolCategory = "mongodb" | "atlas";
 
 export abstract class ToolBase {
@@ -24,7 +25,34 @@ export abstract class ToolBase {
 
     protected abstract execute(...args: Parameters<ToolCallback<typeof this.argsShape>>): Promise<CallToolResult>;
 
-    protected constructor(protected session: Session) {}
+    constructor(
+        protected readonly session: Session,
+        protected readonly config: UserConfig,
+        protected readonly telemetry: Telemetry
+    ) {}
+
+    /**
+     * Creates and emits a tool telemetry event
+     * @param startTime - Start time in milliseconds
+     * @param result - Whether the command succeeded or failed
+     * @param error - Optional error if the command failed
+     */
+    private async emitToolEvent(startTime: number, result: CallToolResult): Promise<void> {
+        const duration = Date.now() - startTime;
+        const event: ToolEvent = {
+            timestamp: new Date().toISOString(),
+            source: "mdbmcp",
+            properties: {
+                ...this.telemetry.getCommonProperties(),
+                command: this.name,
+                category: this.category,
+                component: "tool",
+                duration_ms: duration,
+                result: result.isError ? "failure" : "success",
+            },
+        };
+        await this.telemetry.emitEvents([event]);
+    }
 
     public register(server: McpServer): void {
         if (!this.verifyAllowed()) {
@@ -32,39 +60,70 @@ export abstract class ToolBase {
         }
 
         const callback: ToolCallback<typeof this.argsShape> = async (...args) => {
+            const startTime = Date.now();
             try {
-                // TODO: add telemetry here
-                logger.debug(
-                    mongoLogId(1_000_006),
-                    "tool",
-                    `Executing ${this.name} with args: ${JSON.stringify(args)}`
-                );
-
-                return await this.execute(...args);
-            } catch (error: unknown) {
-                logger.error(mongoLogId(1_000_000), "tool", `Error executing ${this.name}: ${error as string}`);
+                logger.debug(LogId.toolExecute, "tool", `Executing ${this.name} with args: ${JSON.stringify(args)}`);
 
-                return await this.handleError(error);
+                const result = await this.execute(...args);
+                await this.emitToolEvent(startTime, result);
+                return result;
+            } catch (error: unknown) {
+                logger.error(LogId.toolExecuteFailure, "tool", `Error executing ${this.name}: ${error as string}`);
+                const toolResult = await this.handleError(error, args[0] as ToolArgs<typeof this.argsShape>);
+                await this.emitToolEvent(startTime, toolResult).catch(() => {});
+                return toolResult;
             }
         };
 
         server.tool(this.name, this.description, this.argsShape, callback);
+
+        // This is very similar to RegisteredTool.update, but without the bugs around the name.
+        // In the upstream update method, the name is captured in the closure and not updated when
+        // the tool name changes. This means that you only get one name update before things end up
+        // in a broken state.
+        this.update = (updates: { name?: string; description?: string; inputSchema?: AnyZodObject }) => {
+            const tools = server["_registeredTools"] as { [toolName: string]: RegisteredTool };
+            const existingTool = tools[this.name];
+
+            if (updates.name && updates.name !== this.name) {
+                delete tools[this.name];
+                this.name = updates.name;
+                tools[this.name] = existingTool;
+            }
+
+            if (updates.description) {
+                existingTool.description = updates.description;
+                this.description = updates.description;
+            }
+
+            if (updates.inputSchema) {
+                existingTool.inputSchema = updates.inputSchema;
+            }
+
+            server.sendToolListChanged();
+        };
     }
 
+    protected update?: (updates: { name?: string; description?: string; inputSchema?: AnyZodObject }) => void;
+
     // Checks if a tool is allowed to run based on the config
-    private verifyAllowed(): boolean {
+    protected verifyAllowed(): boolean {
         let errorClarification: string | undefined;
-        if (config.disabledTools.includes(this.category)) {
+
+        // Check read-only mode first
+        if (this.config.readOnly && !["read", "metadata"].includes(this.operationType)) {
+            errorClarification = `read-only mode is enabled, its operation type, \`${this.operationType}\`,`;
+        } else if (this.config.disabledTools.includes(this.category)) {
             errorClarification = `its category, \`${this.category}\`,`;
-        } else if (config.disabledTools.includes(this.operationType)) {
+        } else if (this.config.disabledTools.includes(this.operationType)) {
             errorClarification = `its operation type, \`${this.operationType}\`,`;
-        } else if (config.disabledTools.includes(this.name)) {
+        } else if (this.config.disabledTools.includes(this.name)) {
             errorClarification = `it`;
         }
 
         if (errorClarification) {
             logger.debug(
-                mongoLogId(1_000_010),
+                LogId.toolDisabled,
                 "tool",
                 `Prevented registration of ${this.name} because ${errorClarification} is disabled in the config`
             );
@@ -76,15 +135,19 @@ export abstract class ToolBase {
     }
 
     // This method is intended to be overridden by subclasses to handle errors
-    protected handleError(error: unknown): Promise<CallToolResult> | CallToolResult {
+    protected handleError(
+        error: unknown,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        args: ToolArgs<typeof this.argsShape>
+    ): Promise<CallToolResult> | CallToolResult {
         return {
             content: [
                 {
                     type: "text",
                     text: `Error running ${this.name}: ${error instanceof Error ? error.message : String(error)}`,
+                    isError: true,
                 },
             ],
-            isError: true,
         };
     }
 }

package/tests/integration/helpers.ts

@@ -1,14 +1,10 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "./inMemoryTransport.js";
 import { Server } from "../../src/server.js";
-import runner, { MongoCluster } from "mongodb-runner";
-import path from "path";
-import fs from "fs/promises";
-import { Session } from "../../src/session.js";
+import { UserConfig } from "../../src/config.js";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { MongoClient, ObjectId } from "mongodb";
-import { toIncludeAllMembers } from "jest-extended";
-import config from "../../src/config.js";
+import { Session } from "../../src/session.js";
 
 interface ParameterInfo {
     name: string;
@@ -22,30 +18,22 @@ type ToolInfo = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export interface IntegrationTest {
     mcpClient: () => Client;
     mcpServer: () => Server;
-    mongoClient: () => MongoClient;
-    connectionString: () => string;
-    connectMcpClient: () => Promise<void>;
-    randomDbName: () => string;
 }
 
-export function setupIntegrationTest(): IntegrationTest {
-    let mongoCluster: runner.MongoCluster | undefined;
-    let mongoClient: MongoClient | undefined;
-
+export function setupIntegrationTest(getUserConfig: () => UserConfig): IntegrationTest {
     let mcpClient: Client | undefined;
     let mcpServer: Server | undefined;
 
-    let randomDbName: string;
-
     beforeAll(async () => {
+        const userConfig = getUserConfig();
         const clientTransport = new InMemoryTransport();
         const serverTransport = new InMemoryTransport();
 
         await serverTransport.start();
         await clientTransport.start();
 
-        clientTransport.output.pipeTo(serverTransport.input);
-        serverTransport.output.pipeTo(clientTransport.input);
+        void clientTransport.output.pipeTo(serverTransport.input);
+        void serverTransport.output.pipeTo(clientTransport.input);
 
         mcpClient = new Client(
             {
@@ -57,19 +45,35 @@ export function setupIntegrationTest(): IntegrationTest {
             }
         );
 
+        const session = new Session({
+            apiBaseUrl: userConfig.apiBaseUrl,
+            apiClientId: userConfig.apiClientId,
+            apiClientSecret: userConfig.apiClientSecret,
+        });
+
+        userConfig.telemetry = "disabled";
         mcpServer = new Server({
+            session,
+            userConfig,
             mcpServer: new McpServer({
                 name: "test-server",
                 version: "1.2.3",
             }),
-            session: new Session(),
         });
         await mcpServer.connect(serverTransport);
         await mcpClient.connect(clientTransport);
     });
 
-    beforeEach(async () => {
-        randomDbName = new ObjectId().toString();
+    beforeEach(() => {
+        if (mcpServer) {
+            mcpServer.userConfig.telemetry = "disabled";
+        }
+    });
+
+    afterEach(async () => {
+        if (mcpServer) {
+            await mcpServer.session.close();
+        }
     });
 
     afterAll(async () => {
@@ -80,52 +84,6 @@ export function setupIntegrationTest(): IntegrationTest {
         mcpServer = undefined;
     });
 
-    afterEach(async () => {
-        await mcpServer?.session.close();
-        config.connectionString = 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",
-                });
-
-                return;
-            } catch (err) {
-                if (i < 5) {
-                    // Just wait a little bit and retry
-                    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(
-                        `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 getMcpClient = () => {
         if (!mcpClient) {
             throw new Error("beforeEach() hook not ran yet");
@@ -142,41 +100,25 @@ export function setupIntegrationTest(): IntegrationTest {
         return mcpServer;
     };
 
-    const getConnectionString = () => {
-        if (!mongoCluster) {
-            throw new Error("beforeAll() hook not ran yet");
-        }
-
-        return mongoCluster.connectionString;
-    };
-
     return {
         mcpClient: getMcpClient,
         mcpServer: getMcpServer,
-        mongoClient: () => {
-            if (!mongoClient) {
-                mongoClient = new MongoClient(getConnectionString());
-            }
-            return mongoClient;
-        },
-        connectionString: getConnectionString,
-        connectMcpClient: async () => {
-            await getMcpClient().callTool({
-                name: "connect",
-                arguments: { options: [{ connectionString: getConnectionString() }] },
-            });
-        },
-        randomDbName: () => randomDbName,
     };
 }
 
-export function getResponseContent(content: unknown): string {
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+export function getResponseContent(content: unknown | { content: unknown }): string {
     return getResponseElements(content)
         .map((item) => item.text)
         .join("\n");
 }
 
-export function getResponseElements(content: unknown): { type: string; text: string }[] {
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+export function getResponseElements(content: unknown | { content: unknown }): { type: string; text: string }[] {
+    if (typeof content === "object" && content !== null && "content" in content) {
+        content = (content as { content: unknown }).content;
+    }
+
     expect(Array.isArray(content)).toBe(true);
 
     const response = content as { type: string; text: string }[];
@@ -198,9 +140,9 @@ export async function connect(client: Client, connectionString: string): Promise
 
 export function getParameters(tool: ToolInfo): ParameterInfo[] {
     expect(tool.inputSchema.type).toBe("object");
-    expect(tool.inputSchema.properties).toBeDefined();
+    expectDefined(tool.inputSchema.properties);
 
-    return Object.entries(tool.inputSchema.properties!)
+    return Object.entries(tool.inputSchema.properties)
         .sort((a, b) => a[0].localeCompare(b[0]))
         .map(([key, value]) => {
             expect(value).toHaveProperty("type");
@@ -218,24 +160,69 @@ export function getParameters(tool: ToolInfo): ParameterInfo[] {
         });
 }
 
-export const dbOperationParameters: ParameterInfo[] = [
+export const databaseParameters: ParameterInfo[] = [
     { name: "database", type: "string", description: "Database name", required: true },
+];
+
+export const databaseCollectionParameters: ParameterInfo[] = [
+    ...databaseParameters,
     { name: "collection", type: "string", description: "Collection name", required: true },
 ];
 
-export function validateParameters(tool: ToolInfo, parameters: ParameterInfo[]): void {
-    const toolParameters = getParameters(tool);
-    expect(toolParameters).toHaveLength(parameters.length);
-    expect(toolParameters).toIncludeAllMembers(parameters);
+export const databaseCollectionInvalidArgs = [
+    {},
+    { database: "test" },
+    { collection: "foo" },
+    { database: 123, collection: "foo" },
+    { database: "test", collection: 123 },
+    { database: [], collection: "foo" },
+    { database: "test", collection: [] },
+];
+
+export const databaseInvalidArgs = [{}, { database: 123 }, { database: [] }];
+
+export function validateToolMetadata(
+    integration: IntegrationTest,
+    name: string,
+    description: string,
+    parameters: ParameterInfo[]
+): void {
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const tool = tools.find((tool) => tool.name === name);
+        expectDefined(tool);
+        expect(tool.description).toBe(description);
+
+        const toolParameters = getParameters(tool);
+        expect(toolParameters).toHaveLength(parameters.length);
+        expect(toolParameters).toIncludeAllMembers(parameters);
+    });
 }
 
-export function describeAtlas(name: number | string | Function | jest.FunctionLike, fn: jest.EmptyFunction) {
-    if (!process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length) {
-        return describe.skip("atlas", () => {
-            describe(name, fn);
-        });
-    }
-    return describe("atlas", () => {
-        describe(name, fn);
+export function validateThrowsForInvalidArguments(
+    integration: IntegrationTest,
+    name: string,
+    args: { [x: string]: unknown }[]
+): void {
+    describe("with invalid arguments", () => {
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                try {
+                    await integration.mcpClient().callTool({ name, arguments: arg });
+                    throw new Error("Expected an error to be thrown");
+                } catch (error) {
+                    expect((error as Error).message).not.toEqual("Expected an error to be thrown");
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain(`Invalid arguments for tool ${name}`);
+                }
+            });
+        }
     });
 }
+
+/** Expects the argument being defined and asserts it */
+export function expectDefined<T>(arg: T): asserts arg is Exclude<T, undefined> {
+    expect(arg).toBeDefined();
+}

package/tests/integration/inMemoryTransport.ts

@@ -39,6 +39,7 @@ export class InMemoryTransport implements Transport {
         return Promise.resolve();
     }
 
+    // eslint-disable-next-line @typescript-eslint/require-await
     async close(): Promise<void> {
         this.outputController.close();
         this.onclose?.();
@@ -49,10 +50,10 @@ export class InMemoryTransport implements Transport {
     sessionId?: string | undefined;
 
     private static getPromise(): [Promise<void>, resolve: () => void] {
-        let resolve: () => void;
+        let resolve: () => void = () => {};
         const promise = new Promise<void>((res) => {
             resolve = res;
         });
-        return [promise, resolve!];
+        return [promise, resolve];
     }
 }