16876636630

Committed 11 Aug 2025 09:51AM UTC coverage: 81.999% (+0.6%) from 81.362%

Build # 16876636630

Build Type

Pull #424

github

Committed by

web-flow

Commit Message

Merge 602f1c199 into 7572ec5d6

Pull Request Pull Request #424: feat: adds an export tool and exported-data resource MCP-16

Run Details

784 of 1003 branches covered (78.17%)

Branch coverage included in aggregate %.

592 of 659 new or added lines in 13 files covered. (89.83%)

18 existing lines in 3 files now uncovered.

4072 of 4919 relevant lines covered (82.78%)

66.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.43

/src/tools/mongodb/read/export.ts

import z from "zod";
import { ObjectId } from "bson";
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/exportsManager.js";

export class ExportTool extends MongoDBToolBase {
    public name = "export";
    protected description = "Export a collection data or query results in the specified EJSON format.";
    protected argsShape = {
        exportTitle: z.string().describe("A short description to uniquely identify the export."),
        ...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 EJSON 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,
        exportTitle,
    }: 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}.${new ObjectId().toString()}.json`;

        const { exportURI, exportPath } = await this.session.exportsManager.createJSONExport({
            input: findCursor,
            exportName,
            exportTitle:
                exportTitle ||
                `Export for namespace ${database}.${collection} requested on ${new Date().toLocaleString()}`,
            jsonExportFormat,
        });
        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: `Data for namespace ${database}.${collection} is being exported and will be made available under resource URI - "${exportURI}".`,
            },
            {
                type: "resource_link",
                name: exportName,
                uri: exportURI,
                description: "Resource URI for fetching exported data once it is ready.",
                mimeType: "application/json",
            },
        ];

        // This special case is to make it easier to work with exported data for
        // clients that still cannot reference resources (Cursor).
        // More information here: https://jira.mongodb.org/browse/MCP-104
        if (this.isServerRunningLocally()) {
            toolCallContent.push({
                type: "text",
                text: `Optionally, when the export is finished, the exported data can also be accessed under path - "${exportPath}"`,
            });
        }

        return {
            content: toolCallContent,
        };
    }

    private isServerRunningLocally(): boolean {
        return this.config.transport === "stdio" || ["127.0.0.1", "localhost"].includes(this.config.httpHost);
    }
}

1	import z from "zod";	2✔
2	import { ObjectId } from "bson";	2✔
3	import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
4	import { OperationType, ToolArgs } from "../../tool.js";
5	import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";	2✔
6	import { FindArgs } from "./find.js";	2✔
7	import { jsonExportFormat } from "../../../common/exportsManager.js";	2✔
8
9	export class ExportTool extends MongoDBToolBase {	2✔
10	public name = "export";	74✔
11	protected description = "Export a collection data or query results in the specified EJSON format.";	74✔
12	protected argsShape = {	74✔
13	exportTitle: z.string().describe("A short description to uniquely identify the export."),	74✔
14	...DbOperationArgs,	74✔
15	...FindArgs,	74✔
16	limit: z.number().optional().describe("The maximum number of documents to return"),	74✔
17	jsonExportFormat: jsonExportFormat	74✔
18	.default("relaxed")	74✔
19	.describe(	74✔
20	[	74✔
21	"The format to be used when exporting collection data as EJSON with default being relaxed.",	74✔
22	"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.",	74✔
23	"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.",	74✔
24	].join("\n")	74✔
25	),	74✔
26	};	74✔
27	public operationType: OperationType = "read";	74✔
28
29	protected async execute({	2✔
30	database,	38✔
31	collection,	38✔
32	jsonExportFormat,	38✔
33	filter,	38✔
34	projection,	38✔
35	sort,	38✔
36	limit,	38✔
37	exportTitle,	38✔
38	}: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {	38✔
39	const provider = await this.ensureConnected();	38✔
40	const findCursor = provider.find(database, collection, filter ?? {}, {	38✔
41	projection,	38✔
42	sort,	38✔
43	limit,	38✔
44	promoteValues: false,	38✔
45	bsonRegExp: true,	38✔
46	});	38✔
47	const exportName = `${database}.${collection}.${new ObjectId().toString()}.json`;	38✔
48
49	const { exportURI, exportPath } = await this.session.exportsManager.createJSONExport({	38✔
50	input: findCursor,	38✔
51	exportName,	38✔
52	exportTitle:	38✔
53	exportTitle \|\|	38!
NEW 54	`Export for namespace ${database}.${collection} requested on ${new Date().toLocaleString()}`,	×
55	jsonExportFormat,	38✔
56	});	38✔
57	const toolCallContent: CallToolResult["content"] = [	38✔
58	// Not all the clients as of this commit understands how to
59	// parse a resource_link so we provide a text result for them to
60	// understand what to do with the result.
61	{	38✔
62	type: "text",	38✔
63	text: `Data for namespace ${database}.${collection} is being exported and will be made available under resource URI - "${exportURI}".`,	38✔
64	},	38✔
65	{	38✔
66	type: "resource_link",	38✔
67	name: exportName,	38✔
68	uri: exportURI,	38✔
69	description: "Resource URI for fetching exported data once it is ready.",	38✔
70	mimeType: "application/json",	38✔
71	},	38✔
72	];	38✔
73
74	// This special case is to make it easier to work with exported data for
75	// clients that still cannot reference resources (Cursor).
76	// More information here: https://jira.mongodb.org/browse/MCP-104
77	if (this.isServerRunningLocally()) {	38✔
78	toolCallContent.push({	38✔
79	type: "text",	38✔
80	text: `Optionally, when the export is finished, the exported data can also be accessed under path - "${exportPath}"`,	38✔
81	});	38✔
82	}	38✔
83
84	return {	38✔
85	content: toolCallContent,	38✔
86	};	38✔
87	}	38✔
88
89	private isServerRunningLocally(): boolean {	2✔
90	return this.config.transport === "stdio" \|\| ["127.0.0.1", "localhost"].includes(this.config.httpHost);	38!
91	}	38✔
92	}	2✔

mongodb-js / mongodb-mcp-server / 16876636630

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous