chore: revert changes done to any of the src files

himanshusinghs · himanshusinghs · commit 58bc8a5336b8 · 2025-07-08T23:40:07.000+02:00
diff --git a/src/tools/mongodb/create/insertMany.ts b/src/tools/mongodb/create/insertMany.ts
@@ -3,21 +3,6 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
-export function insertManyResponse(collection: string, insertedCount: number, insertedIds: unknown[]): CallToolResult {
-    return {
-        content: [
-            {
-                text: `Inserted \`${insertedCount}\` document(s) into collection "${collection}"`,
-                type: "text",
-            },
-            {
-                text: `Inserted IDs: ${insertedIds.join(", ")}`,
-                type: "text",
-            },
-        ],
-    };
-}
-
 export class InsertManyTool extends MongoDBToolBase {
     protected name = "insert-many";
     protected description = "Insert an array of documents into a MongoDB collection";
@@ -39,6 +24,17 @@ export class InsertManyTool extends MongoDBToolBase {
         const provider = await this.ensureConnected();
         const result = await provider.insertMany(database, collection, documents);
 
-        return insertManyResponse(collection, result.insertedCount, Object.values(result.insertedIds));
+        return {
+            content: [
+                {
+                    text: `Inserted \`${result.insertedCount}\` document(s) into collection "${collection}"`,
+                    type: "text",
+                },
+                {
+                    text: `Inserted IDs: ${Object.values(result.insertedIds).join(", ")}`,
+                    type: "text",
+                },
+            ],
+        };
     }
 }
diff --git a/src/tools/mongodb/delete/deleteMany.ts b/src/tools/mongodb/delete/deleteMany.ts
@@ -4,17 +4,6 @@ import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 import { checkIndexUsage } from "../../../helpers/indexCheck.js";
 
-export function deleteManyResponse(collection: string, delectedCount: number): CallToolResult {
-    return {
-        content: [
-            {
-                text: `Deleted \`${delectedCount}\` document(s) from collection "${collection}"`,
-                type: "text",
-            },
-        ],
-    };
-}
-
 export class DeleteManyTool extends MongoDBToolBase {
     protected name = "delete-many";
     protected description = "Removes all documents that match the filter from a MongoDB collection";
@@ -56,6 +45,13 @@ export class DeleteManyTool extends MongoDBToolBase {
 
         const result = await provider.deleteMany(database, collection, filter);
 
-        return deleteManyResponse(collection, result.deletedCount);
+        return {
+            content: [
+                {
+                    text: `Deleted \`${result.deletedCount}\` document(s) from collection "${collection}"`,
+                    type: "text",
+                },
+            ],
+        };
     }
 }
diff --git a/src/tools/mongodb/metadata/collectionSchema.ts b/src/tools/mongodb/metadata/collectionSchema.ts
@@ -1,38 +1,7 @@
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
-import { getSimplifiedSchema, SimplifiedSchema } from "mongodb-schema";
-
-export function collectionSchemaResponse(
-    database: string,
-    collection: string,
-    schema: SimplifiedSchema
-): CallToolResult {
-    const fieldsCount = Object.entries(schema).length;
-    if (fieldsCount === 0) {
-        return {
-            content: [
-                {
-                    text: `Could not deduce the schema for "${database}.${collection}". This may be because it doesn't exist or is empty.`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-
-    return {
-        content: [
-            {
-                text: `Found ${fieldsCount} fields in the schema for "${database}.${collection}"`,
-                type: "text",
-            },
-            {
-                text: JSON.stringify(schema),
-                type: "text",
-            },
-        ],
-    };
-}
+import { getSimplifiedSchema } from "mongodb-schema";
 
 export class CollectionSchemaTool extends MongoDBToolBase {
     protected name = "collection-schema";
@@ -45,6 +14,30 @@ export class CollectionSchemaTool extends MongoDBToolBase {
         const provider = await this.ensureConnected();
         const documents = await provider.find(database, collection, {}, { limit: 5 }).toArray();
         const schema = await getSimplifiedSchema(documents);
-        return collectionSchemaResponse(database, collection, schema);
+
+        const fieldsCount = Object.entries(schema).length;
+        if (fieldsCount === 0) {
+            return {
+                content: [
+                    {
+                        text: `Could not deduce the schema for "${database}.${collection}". This may be because it doesn't exist or is empty.`,
+                        type: "text",
+                    },
+                ],
+            };
+        }
+
+        return {
+            content: [
+                {
+                    text: `Found ${fieldsCount} fields in the schema for "${database}.${collection}"`,
+                    type: "text",
+                },
+                {
+                    text: JSON.stringify(schema),
+                    type: "text",
+                },
+            ],
+        };
     }
 }
diff --git a/src/tools/mongodb/metadata/listCollections.ts b/src/tools/mongodb/metadata/listCollections.ts
@@ -2,28 +2,6 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
-export function listCollectionsResponse(database: string, collections: string[]): CallToolResult {
-    if (collections.length === 0) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `No collections found for database "${database}". To create a collection, use the "create-collection" tool.`,
-                },
-            ],
-        };
-    }
-
-    return {
-        content: collections.map((collection) => {
-            return {
-                text: `Name: "${collection}"`,
-                type: "text",
-            };
-        }),
-    };
-}
-
 export class ListCollectionsTool extends MongoDBToolBase {
     protected name = "list-collections";
     protected description = "List all collections for a given database";
@@ -37,9 +15,24 @@ export class ListCollectionsTool extends MongoDBToolBase {
         const provider = await this.ensureConnected();
         const collections = await provider.listCollections(database);
 
-        return listCollectionsResponse(
-            database,
-            collections.map((collection) => `${collection.name}`)
-        );
+        if (collections.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No collections found for database "${database}". To create a collection, use the "create-collection" tool.`,
+                    },
+                ],
+            };
+        }
+
+        return {
+            content: collections.map((collection) => {
+                return {
+                    text: `Name: "${collection.name}"`,
+                    type: "text",
+                };
+            }),
+        };
     }
 }
diff --git a/src/tools/mongodb/metadata/listDatabases.ts b/src/tools/mongodb/metadata/listDatabases.ts
@@ -3,17 +3,6 @@ import { MongoDBToolBase } from "../mongodbTool.js";
 import * as bson from "bson";
 import { OperationType } from "../../tool.js";
 
-export function listDatabasesResponse(databases: { name: string; sizeOnDisk: string }[]): CallToolResult {
-    return {
-        content: databases.map((db) => {
-            return {
-                text: `Name: ${db.name}, Size: ${db.sizeOnDisk} bytes`,
-                type: "text",
-            };
-        }),
-    };
-}
-
 export class ListDatabasesTool extends MongoDBToolBase {
     protected name = "list-databases";
     protected description = "List all databases for a MongoDB connection";
@@ -24,13 +13,13 @@ export class ListDatabasesTool extends MongoDBToolBase {
         const provider = await this.ensureConnected();
         const dbs = (await provider.listDatabases("")).databases as { name: string; sizeOnDisk: bson.Long }[];
 
-        return listDatabasesResponse(
-            dbs.map((db) => {
+        return {
+            content: dbs.map((db) => {
                 return {
-                    name: db.name,
-                    sizeOnDisk: db.sizeOnDisk.toString(),
+                    text: `Name: ${db.name}, Size: ${db.sizeOnDisk.toString()} bytes`,
+                    type: "text",
                 };
-            })
-        );
+            }),
+        };
     }
 }
diff --git a/src/tools/mongodb/read/collectionIndexes.ts b/src/tools/mongodb/read/collectionIndexes.ts
@@ -2,44 +2,6 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
-export function collectionIndexesResponse({
-    database,
-    collection,
-    indexes = [],
-    namespaceNotFound,
-}: {
-    database: string;
-    collection: string;
-    indexes?: { name: string; key: string }[];
-    namespaceNotFound?: boolean;
-}): CallToolResult {
-    if (namespaceNotFound) {
-        return {
-            content: [
-                {
-                    text: `The indexes for "${database}.${collection}" cannot be determined because the collection does not exist.`,
-                    type: "text",
-                },
-            ],
-        };
-    }
-
-    return {
-        content: [
-            {
-                text: `Found ${indexes.length} indexes in the collection "${collection}":`,
-                type: "text",
-            },
-            ...(indexes.map((indexDefinition) => {
-                return {
-                    text: `Name "${indexDefinition.name}", definition: ${JSON.stringify(indexDefinition.key)}`,
-                    type: "text",
-                };
-            }) as { text: string; type: "text" }[]),
-        ],
-    };
-}
-
 export class CollectionIndexesTool extends MongoDBToolBase {
     protected name = "collection-indexes";
     protected description = "Describe the indexes for a collection";
@@ -49,26 +11,36 @@ export class CollectionIndexesTool extends MongoDBToolBase {
     protected async execute({ database, collection }: ToolArgs<typeof DbOperationArgs>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
         const indexes = await provider.getIndexes(database, collection);
-        return collectionIndexesResponse({
-            database,
-            collection,
-            indexes: indexes.map((index) => ({
-                name: `${index.name}`,
-                key: JSON.stringify(index.key),
-            })),
-        });
+
+        return {
+            content: [
+                {
+                    text: `Found ${indexes.length} indexes in the collection "${collection}":`,
+                    type: "text",
+                },
+                ...(indexes.map((indexDefinition) => {
+                    return {
+                        text: `Name "${indexDefinition.name}", definition: ${JSON.stringify(indexDefinition.key)}`,
+                        type: "text",
+                    };
+                }) as { text: string; type: "text" }[]),
+            ],
+        };
     }
 
     protected handleError(
         error: unknown,
         args: ToolArgs<typeof this.argsShape>
     ): Promise<CallToolResult> | CallToolResult {
         if (error instanceof Error && "codeName" in error && error.codeName === "NamespaceNotFound") {
-            return collectionIndexesResponse({
-                database: args.database,
-                collection: args.collection,
-                namespaceNotFound: true,
-            });
+            return {
+                content: [
+                    {
+                        text: `The indexes for "${args.database}.${args.collection}" cannot be determined because the collection does not exist.`,
+                        type: "text",
+                    },
+                ],
+            };
         }
 
         return super.handleError(error, args);
diff --git a/src/tools/mongodb/read/find.ts b/src/tools/mongodb/read/find.ts
@@ -22,23 +22,6 @@ export const FindArgs = {
         .describe("A document, describing the sort order, matching the syntax of the sort argument of cursor.sort()"),
 };
 
-export function findResponse(collection: string, documents: unknown[]): CallToolResult {
-    return {
-        content: [
-            {
-                text: `Found ${documents.length} documents in the collection "${collection}":`,
-                type: "text",
-            },
-            ...documents.map<{ type: "text"; text: string }>((doc) => {
-                return {
-                    text: EJSON.stringify(doc),
-                    type: "text",
-                };
-            }),
-        ],
-    };
-}
-
 export class FindTool extends MongoDBToolBase {
     protected name = "find";
     protected description = "Run a find query against a MongoDB collection";
@@ -67,6 +50,21 @@ export class FindTool extends MongoDBToolBase {
 
         const documents = await provider.find(database, collection, filter, { projection, limit, sort }).toArray();
 
-        return findResponse(collection, documents);
+        const content: Array<{ text: string; type: "text" }> = [
+            {
+                text: `Found ${documents.length} documents in the collection "${collection}":`,
+                type: "text",
+            },
+            ...documents.map((doc) => {
+                return {
+                    text: EJSON.stringify(doc),
+                    type: "text",
+                } as { text: string; type: "text" };
+            }),
+        ];
+
+        return {
+            content,
+        };
     }
 }
