feat: introduces drop-index tool for regular index

1. The tool has been marked to require user confirmation before
   execution.
2. Tests are added to confirm the negative and positive behaviour

Author: himanshusinghs

src/common/config.ts

@@ -201,6 +201,7 @@ export const defaultUserConfig: UserConfig = {
         "drop-database",
         "drop-collection",
         "delete-many",
+        "drop-index",
     ],
     transport: "stdio",
     httpPort: 3000,

src/tools/mongodb/delete/dropIndex.ts

@@ -0,0 +1,44 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import type { ToolArgs, OperationType } from "../../tool.js";
+import { CommonArgs } from "../../args.js";
+
+export class DropIndexTool extends MongoDBToolBase {
+    public name = "drop-index";
+    protected description = "Drop an index for the provided database and collection.";
+    protected argsShape = {
+        ...DbOperationArgs,
+        indexName: CommonArgs.string().nonempty().describe("The name of the index to be dropped."),
+    };
+    public operationType: OperationType = "delete";
+
+    protected async execute({
+        database,
+        collection,
+        indexName,
+    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const provider = await this.ensureConnected();
+        const result = await provider.runCommand(database, {
+            dropIndexes: collection,
+            index: indexName,
+        });
+
+        return {
+            content: [
+                {
+                    text: `${result.ok ? "Successfully dropped" : "Failed to drop"} the index with name "${indexName}" from the provided namespace "${database}.${collection}".`,
+                    type: "text",
+                },
+            ],
+            isError: result.ok ? undefined : true,
+        };
+    }
+
+    protected getConfirmationMessage({ database, collection, indexName }: ToolArgs<typeof this.argsShape>): string {
+        return (
+            `You are about to drop the \`${indexName}\` index from the \`${database}.${collection}\` namespace:\n\n` +
+            "This operation will permanently remove the index and might affect the performance of queries relying on this index.\n\n" +
+            "**Do you confirm the execution of the action?**"
+        );
+    }
+}

src/tools/mongodb/tools.ts

@@ -20,12 +20,14 @@ import { CreateCollectionTool } from "./create/createCollection.js";
 import { LogsTool } from "./metadata/logs.js";
 import { ExportTool } from "./read/export.js";
 import { ListSearchIndexesTool } from "./search/listSearchIndexes.js";
+import { DropIndexTool } from "./delete/dropIndex.js";
 
 export const MongoDbTools = [
     ConnectTool,
     ListCollectionsTool,
     ListDatabasesTool,
     CollectionIndexesTool,
+    DropIndexTool,
     CreateIndexTool,
     CollectionSchemaTool,
     FindTool,

tests/integration/tools/mongodb/delete/dropIndex.test.ts

@@ -0,0 +1,143 @@
+import { describe, beforeEach, it, afterEach, expect } from "vitest";
+import type { Collection } from "mongodb";
+import {
+    databaseCollectionInvalidArgs,
+    databaseCollectionParameters,
+    defaultDriverOptions,
+    defaultTestConfig,
+    getResponseContent,
+    setupIntegrationTest,
+    validateThrowsForInvalidArguments,
+    validateToolMetadata,
+} from "../../../helpers.js";
+import { describeWithMongoDB } from "../mongodbHelpers.js";
+import { createMockElicitInput } from "../../../../utils/elicitationMocks.js";
+import { Elicitation } from "../../../../../src/elicitation.js";
+
+describeWithMongoDB("drop-index tool", (integration) => {
+    let moviesCollection: Collection;
+    let indexName: string;
+    beforeEach(async () => {
+        await integration.connectMcpClient();
+        const client = integration.mongoClient();
+        moviesCollection = client.db("mflix").collection("movies");
+        await moviesCollection.insertMany([
+            {
+                name: "Movie1",
+                year: 1994,
+            },
+            {
+                name: "Movie2",
+                year: 2001,
+            },
+        ]);
+        indexName = await moviesCollection.createIndex({ year: 1 });
+    });
+
+    afterEach(async () => {
+        try {
+            await moviesCollection.dropIndex(indexName);
+        } catch (error) {
+            if (error instanceof Error && !error.message.includes("index not found with name")) {
+                throw error;
+            }
+        }
+        await moviesCollection.drop();
+    });
+
+    validateToolMetadata(integration, "drop-index", "Drop an index for the provided database and collection.", [
+        ...databaseCollectionParameters,
+        {
+            name: "indexName",
+            type: "string",
+            description: "The name of the index to be dropped.",
+            required: true,
+        },
+    ]);
+
+    validateThrowsForInvalidArguments(integration, "drop-index", [
+        ...databaseCollectionInvalidArgs,
+        { database: "test", collection: "testColl", indexName: null },
+        { database: "test", collection: "testColl", indexName: undefined },
+        { database: "test", collection: "testColl", indexName: [] },
+        { database: "test", collection: "testColl", indexName: true },
+        { database: "test", collection: "testColl", indexName: false },
+        { database: "test", collection: "testColl", indexName: 0 },
+        { database: "test", collection: "testColl", indexName: 12 },
+        { database: "test", collection: "testColl", indexName: "" },
+    ]);
+
+    describe.each([
+        {
+            database: "mflix",
+            collection: "non-existent",
+        },
+        {
+            database: "non-db",
+            collection: "non-coll",
+        },
+    ])(
+        "when attempting to delete an index from non-existent namespace - $database $collection",
+        ({ database, collection }) => {
+            it("should fail with error", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "drop-index",
+                    arguments: { database, collection, indexName: "non-existent" },
+                });
+                expect(response.isError).toBe(true);
+                const content = getResponseContent(response.content);
+                expect(content).toEqual(`Error running drop-index: ns not found ${database}.${collection}`);
+            });
+        }
+    );
+
+    describe("when attempting to delete an index that does not exist", () => {
+        it("should fail with error", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "drop-index",
+                arguments: { database: "mflix", collection: "movies", indexName: "non-existent" },
+            });
+            expect(response.isError).toBe(true);
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Error running drop-index: index not found with name [non-existent]`);
+        });
+    });
+
+    describe("when attempting to delete an index that exists", () => {
+        it("should succeed", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "drop-index",
+                // The index is created in beforeEach
+                arguments: { database: "mflix", collection: "movies", indexName: indexName },
+            });
+            expect(response.isError).toBe(undefined);
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Successfully dropped the index with name "${indexName}" from the provided namespace "mflix.movies".`
+            );
+        });
+    });
+});
+
+describe("drop-search-index tool - when invoked via an elicitation enabled client", () => {
+    const mockElicitInput = createMockElicitInput();
+    const integration = setupIntegrationTest(
+        () => defaultTestConfig,
+        () => defaultDriverOptions,
+        { elicitInput: mockElicitInput }
+    );
+
+    it("should ask for confirmation before proceeding with tool call", async () => {
+        mockElicitInput.confirmYes();
+        await integration.mcpClient().callTool({
+            name: "drop-index",
+            arguments: { database: "any", collection: "foo", indexName: "default" },
+        });
+        expect(mockElicitInput.mock).toHaveBeenCalledTimes(1);
+        expect(mockElicitInput.mock).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            message: expect.stringContaining("You are about to drop the `default` index from the `any.foo` namespace"),
+            requestedSchema: Elicitation.CONFIRMATION_SCHEMA,
+        });
+    });
+});