feat: adds an export tool

also makes SessionExportManager available on MongoDBToolBase

Author: himanshusinghs

src/server.ts

@@ -13,25 +13,29 @@ import { type ServerCommand } from "./telemetry/types.js";
 import { CallToolRequestSchema, CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import assert from "assert";
 import { ToolBase } from "./tools/tool.js";
+import { SessionExportsManager } from "./common/sessionExportsManager.js";
 
 export interface ServerOptions {
     session: Session;
+    exportsManager: SessionExportsManager;
     userConfig: UserConfig;
     mcpServer: McpServer;
     telemetry: Telemetry;
 }
 
 export class Server {
     public readonly session: Session;
+    public readonly exportsManager: SessionExportsManager;
     public readonly mcpServer: McpServer;
     private readonly telemetry: Telemetry;
     public readonly userConfig: UserConfig;
     public readonly tools: ToolBase[] = [];
     private readonly startTime: number;
 
-    constructor({ session, mcpServer, userConfig, telemetry }: ServerOptions) {
+    constructor({ session, exportsManager, mcpServer, userConfig, telemetry }: ServerOptions) {
         this.startTime = Date.now();
         this.session = session;
+        this.exportsManager = exportsManager;
         this.telemetry = telemetry;
         this.mcpServer = mcpServer;
         this.userConfig = userConfig;

src/tools/mongodb/mongodbTool.ts

@@ -5,6 +5,7 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { ErrorCodes, MongoDBError } from "../../common/errors.js";
 import logger, { LogId } from "../../common/logger.js";
 import { Server } from "../../server.js";
+import { SessionExportsManager } from "../../common/sessionExportsManager.js";
 
 export const DbOperationArgs = {
     database: z.string().describe("Database name"),
@@ -13,6 +14,7 @@ export const DbOperationArgs = {
 
 export abstract class MongoDBToolBase extends ToolBase {
     private server?: Server;
+    public exportsManager?: SessionExportsManager;
     public category: ToolCategory = "mongodb";
 
     protected async ensureConnected(): Promise<NodeDriverServiceProvider> {
@@ -47,6 +49,7 @@ export abstract class MongoDBToolBase extends ToolBase {
 
     public register(server: Server): boolean {
         this.server = server;
+        this.exportsManager = server.exportsManager;
         return super.register(server);
     }
 

src/tools/mongodb/read/export.ts

@@ -0,0 +1,85 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { OperationType, ToolArgs } from "../../tool.js";
+import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
+import { FindArgs } from "./find.js";
+import { jsonExportFormat } from "../../../common/sessionExportsManager.js";
+import z from "zod";
+
+export class ExportTool extends MongoDBToolBase {
+    public name = "export";
+    protected description = "Export a collection data or query results in the specified json format.";
+    protected argsShape = {
+        ...DbOperationArgs,
+        ...FindArgs,
+        limit: z.number().optional().describe("The maximum number of documents to return"),
+        jsonExportFormat: jsonExportFormat
+            .default("relaxed")
+            .describe(
+                [
+                    "The format to be used when exporting collection data as JSON with default being relaxed.",
+                    "relaxed: A string format that emphasizes readability and interoperability at the expense of type preservation. That is, conversion from relaxed format to BSON can lose type information.",
+                    "canonical: A string format that emphasizes type preservation at the expense of readability and interoperability. That is, conversion from canonical to BSON will generally preserve type information except in certain specific cases.",
+                ].join("\n")
+            ),
+    };
+    public operationType: OperationType = "read";
+
+    protected async execute({
+        database,
+        collection,
+        jsonExportFormat,
+        filter,
+        projection,
+        sort,
+        limit,
+    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
+        const provider = await this.ensureConnected();
+        const findCursor = provider.find(database, collection, filter ?? {}, {
+            projection,
+            sort,
+            limit,
+            promoteValues: false,
+            bsonRegExp: true,
+        });
+        const exportName = `${database}.${collection}.json`;
+        if (!this.exportsManager) {
+            throw new Error("Incorrect server configuration, export not possible!");
+        }
+
+        await this.exportsManager.createJSONExport({ input: findCursor, exportName, jsonExportFormat });
+        const exportedResourceURI = this.exportsManager.exportNameToResourceURI(exportName);
+        const exportedResourcePath = this.exportsManager.exportFilePath(
+            this.exportsManager.exportsDirectoryPath(),
+            exportName
+        );
+        const toolCallContent: CallToolResult["content"] = [
+            // Not all the clients as of this commit understands how to
+            // parse a resource_link so we provide a text result for them to
+            // understand what to do with the result.
+            {
+                type: "text",
+                text: `Exported data for namespace ${database}.${collection} is available under resource URI - "${exportedResourceURI}".`,
+            },
+            {
+                type: "resource_link",
+                name: exportName,
+                uri: exportedResourceURI,
+                description: "Resource URI for fetching exported data.",
+                mimeType: "application/json",
+            },
+        ];
+
+        // This special case is to make it easier to work with exported data for
+        // stdio transport.
+        if (this.config.transport === "stdio") {
+            toolCallContent.push({
+                type: "text",
+                text: `Optionally, the exported data can also be accessed under path - "${exportedResourcePath}"`,
+            });
+        }
+
+        return {
+            content: toolCallContent,
+        };
+    }
+}

src/transports/base.ts

@@ -4,6 +4,7 @@ import { Server } from "../server.js";
 import { Session } from "../common/session.js";
 import { Telemetry } from "../telemetry/telemetry.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SessionExportsManager } from "../common/sessionExportsManager.js";
 
 export abstract class TransportRunnerBase {
     protected setupServer(userConfig: UserConfig): Server {
@@ -13,6 +14,8 @@ export abstract class TransportRunnerBase {
             apiClientSecret: userConfig.apiClientSecret,
         });
 
+        const exportsManager = new SessionExportsManager(session, userConfig);
+
         const telemetry = Telemetry.create(session, userConfig);
 
         const mcpServer = new McpServer({
@@ -23,6 +26,7 @@ export abstract class TransportRunnerBase {
         return new Server({
             mcpServer,
             session,
+            exportsManager,
             telemetry,
             userConfig,
         });