mongodb-mcp-server 0.1.3 → 0.3.0

package/src/tools/mongodb/read/find.ts

@@ -1,70 +0,0 @@
-import { z } from "zod";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
-import { ToolArgs, OperationType } from "../../tool.js";
-import { SortDirection } from "mongodb";
-import { EJSON } from "bson";
-import { checkIndexUsage } from "../../../helpers/indexCheck.js";
-
-export const FindArgs = {
-    filter: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("The query filter, matching the syntax of the query argument of db.collection.find()"),
-    projection: z
-        .record(z.string(), z.unknown())
-        .optional()
-        .describe("The projection, matching the syntax of the projection argument of db.collection.find()"),
-    limit: z.number().optional().default(10).describe("The maximum number of documents to return"),
-    sort: z
-        .record(z.string(), z.custom<SortDirection>())
-        .optional()
-        .describe("A document, describing the sort order, matching the syntax of the sort argument of cursor.sort()"),
-};
-
-export class FindTool extends MongoDBToolBase {
-    protected name = "find";
-    protected description = "Run a find query against a MongoDB collection";
-    protected argsShape = {
-        ...DbOperationArgs,
-        ...FindArgs,
-    };
-    protected operationType: OperationType = "read";
-
-    protected async execute({
-        database,
-        collection,
-        filter,
-        projection,
-        limit,
-        sort,
-    }: ToolArgs<typeof this.argsShape>): Promise<CallToolResult> {
-        const provider = await this.ensureConnected();
-
-        // Check if find operation uses an index if enabled
-        if (this.config.indexCheck) {
-            await checkIndexUsage(provider, database, collection, "find", async () => {
-                return provider.find(database, collection, filter, { projection, limit, sort }).explain("queryPlanner");
-            });
-        }
-
-        const documents = await provider.find(database, collection, filter, { projection, limit, sort }).toArray();
-
-        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,
-        };
-    }
-}

package/src/types/mongodb-connection-string-url.d.ts

@@ -1,69 +0,0 @@
-declare module "mongodb-connection-string-url" {
-    import { URL } from "whatwg-url";
-    import { redactConnectionString, ConnectionStringRedactionOptions } from "./redact";
-    export { redactConnectionString, ConnectionStringRedactionOptions };
-    declare class CaseInsensitiveMap<K extends string = string> extends Map<K, string> {
-        delete(name: K): boolean;
-        get(name: K): string | undefined;
-        has(name: K): boolean;
-        set(name: K, value: any): this;
-        _normalizeKey(name: any): K;
-    }
-    declare abstract class URLWithoutHost extends URL {
-        abstract get host(): never;
-        abstract set host(value: never);
-        abstract get hostname(): never;
-        abstract set hostname(value: never);
-        abstract get port(): never;
-        abstract set port(value: never);
-        abstract get href(): string;
-        abstract set href(value: string);
-    }
-    export interface ConnectionStringParsingOptions {
-        looseValidation?: boolean;
-    }
-    export declare class ConnectionString extends URLWithoutHost {
-        _hosts: string[];
-        constructor(uri: string, options?: ConnectionStringParsingOptions);
-        get host(): never;
-        set host(_ignored: never);
-        get hostname(): never;
-        set hostname(_ignored: never);
-        get port(): never;
-        set port(_ignored: never);
-        get href(): string;
-        set href(_ignored: string);
-        get isSRV(): boolean;
-        get hosts(): string[];
-        set hosts(list: string[]);
-        toString(): string;
-        clone(): ConnectionString;
-        redact(options?: ConnectionStringRedactionOptions): ConnectionString;
-        typedSearchParams<T extends {}>(): {
-            append(name: keyof T & string, value: any): void;
-            delete(name: keyof T & string): void;
-            get(name: keyof T & string): string | null;
-            getAll(name: keyof T & string): string[];
-            has(name: keyof T & string): boolean;
-            set(name: keyof T & string, value: any): void;
-            keys(): IterableIterator<keyof T & string>;
-            values(): IterableIterator<string>;
-            entries(): IterableIterator<[keyof T & string, string]>;
-            _normalizeKey(name: keyof T & string): string;
-            [Symbol.iterator](): IterableIterator<[keyof T & string, string]>;
-            sort(): void;
-            forEach<THIS_ARG = void>(
-                callback: (this: THIS_ARG, value: string, name: string, searchParams: any) => void,
-                thisArg?: THIS_ARG | undefined
-            ): void;
-            readonly [Symbol.toStringTag]: "URLSearchParams";
-        };
-    }
-    export declare class CommaAndColonSeparatedRecord<
-        K extends {} = Record<string, unknown>,
-    > extends CaseInsensitiveMap<keyof K & string> {
-        constructor(from?: string | null);
-        toString(): string;
-    }
-    export default ConnectionString;
-}

package/src/types/mongodb-redact.d.ts

@@ -1,4 +0,0 @@
-declare module "mongodb-redact" {
-    function redact<T>(message: T): T;
-    export default redact;
-}

package/tests/integration/helpers.ts

@@ -1,265 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { InMemoryTransport } from "./inMemoryTransport.js";
-import { Server } from "../../src/server.js";
-import { UserConfig } from "../../src/config.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { Session } from "../../src/session.js";
-import { Telemetry } from "../../src/telemetry/telemetry.js";
-import { config } from "../../src/config.js";
-import { jest } from "@jest/globals";
-
-interface ParameterInfo {
-    name: string;
-    type: string;
-    description: string;
-    required: boolean;
-}
-
-type ToolInfo = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
-
-export interface IntegrationTest {
-    mcpClient: () => Client;
-    mcpServer: () => Server;
-}
-export const defaultTestConfig: UserConfig = {
-    ...config,
-    telemetry: "disabled",
-};
-
-export function setupIntegrationTest(getUserConfig: () => UserConfig): IntegrationTest {
-    let mcpClient: Client | undefined;
-    let mcpServer: Server | undefined;
-
-    beforeAll(async () => {
-        const userConfig = getUserConfig();
-        const clientTransport = new InMemoryTransport();
-        const serverTransport = new InMemoryTransport();
-
-        await serverTransport.start();
-        await clientTransport.start();
-
-        void clientTransport.output.pipeTo(serverTransport.input);
-        void serverTransport.output.pipeTo(clientTransport.input);
-
-        mcpClient = new Client(
-            {
-                name: "test-client",
-                version: "1.2.3",
-            },
-            {
-                capabilities: {},
-            }
-        );
-
-        const session = new Session({
-            apiBaseUrl: userConfig.apiBaseUrl,
-            apiClientId: userConfig.apiClientId,
-            apiClientSecret: userConfig.apiClientSecret,
-        });
-
-        // Mock hasValidAccessToken for tests
-        if (userConfig.apiClientId && userConfig.apiClientSecret) {
-            const mockFn = jest.fn<() => Promise<boolean>>().mockResolvedValue(true);
-            // @ts-expect-error accessing private property for testing
-            session.apiClient.validateAccessToken = mockFn;
-        }
-
-        userConfig.telemetry = "disabled";
-
-        const telemetry = Telemetry.create(session, userConfig);
-
-        mcpServer = new Server({
-            session,
-            userConfig,
-            telemetry,
-            mcpServer: new McpServer({
-                name: "test-server",
-                version: "5.2.3",
-            }),
-        });
-
-        await mcpServer.connect(serverTransport);
-        await mcpClient.connect(clientTransport);
-    });
-
-    afterEach(async () => {
-        if (mcpServer) {
-            await mcpServer.session.close();
-        }
-    });
-
-    afterAll(async () => {
-        await mcpClient?.close();
-        mcpClient = undefined;
-
-        await mcpServer?.close();
-        mcpServer = undefined;
-    });
-
-    const getMcpClient = () => {
-        if (!mcpClient) {
-            throw new Error("beforeEach() hook not ran yet");
-        }
-
-        return mcpClient;
-    };
-
-    const getMcpServer = () => {
-        if (!mcpServer) {
-            throw new Error("beforeEach() hook not ran yet");
-        }
-
-        return mcpServer;
-    };
-
-    return {
-        mcpClient: getMcpClient,
-        mcpServer: getMcpServer,
-    };
-}
-
-// 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");
-}
-
-// 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(content).toBeArray();
-
-    const response = content as { type: string; text: string }[];
-    for (const item of response) {
-        expect(item).toHaveProperty("type");
-        expect(item).toHaveProperty("text");
-        expect(item.type).toBe("text");
-    }
-
-    return response;
-}
-
-export async function connect(client: Client, connectionString: string): Promise<void> {
-    await client.callTool({
-        name: "connect",
-        arguments: { connectionStringOrClusterName: connectionString },
-    });
-}
-
-export function getParameters(tool: ToolInfo): ParameterInfo[] {
-    expect(tool.inputSchema.type).toBe("object");
-    expectDefined(tool.inputSchema.properties);
-
-    return Object.entries(tool.inputSchema.properties)
-        .sort((a, b) => a[0].localeCompare(b[0]))
-        .map(([key, value]) => {
-            expect(value).toHaveProperty("type");
-            expect(value).toHaveProperty("description");
-
-            const typedValue = value as { type: string; description: string };
-            expect(typeof typedValue.type).toBe("string");
-            expect(typeof typedValue.description).toBe("string");
-            return {
-                name: key,
-                type: typedValue.type,
-                description: typedValue.description,
-                required: (tool.inputSchema.required as string[])?.includes(key) ?? false,
-            };
-        });
-}
-
-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 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);
-
-        validateToolAnnotations(tool, name, description);
-        const toolParameters = getParameters(tool);
-        expect(toolParameters).toHaveLength(parameters.length);
-        expect(toolParameters).toIncludeAllMembers(parameters);
-    });
-}
-
-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 | null> {
-    expect(arg).toBeDefined();
-    expect(arg).not.toBeNull();
-}
-
-function validateToolAnnotations(tool: ToolInfo, name: string, description: string): void {
-    expectDefined(tool.annotations);
-    expect(tool.annotations.title).toBe(name);
-    expect(tool.annotations.description).toBe(description);
-
-    switch (tool.operationType) {
-        case "read":
-        case "metadata":
-            expect(tool.annotations.readOnlyHint).toBe(true);
-            expect(tool.annotations.destructiveHint).toBe(false);
-            break;
-        case "delete":
-            expect(tool.annotations.readOnlyHint).toBe(false);
-            expect(tool.annotations.destructiveHint).toBe(true);
-            break;
-        case "create":
-        case "update":
-            expect(tool.annotations.readOnlyHint).toBe(false);
-            expect(tool.annotations.destructiveHint).toBe(false);
-    }
-}

package/tests/integration/inMemoryTransport.ts

@@ -1,59 +0,0 @@
-import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
-
-export class InMemoryTransport implements Transport {
-    private outputController: ReadableStreamDefaultController<JSONRPCMessage> | undefined;
-
-    private startPromise: Promise<unknown>;
-
-    public output: ReadableStream<JSONRPCMessage>;
-    public input: WritableStream<JSONRPCMessage>;
-
-    constructor() {
-        const [inputReady, inputResolve] = InMemoryTransport.getPromise();
-        const [outputReady, outputResolve] = InMemoryTransport.getPromise();
-
-        this.output = new ReadableStream<JSONRPCMessage>({
-            start: (controller) => {
-                this.outputController = controller;
-                outputResolve();
-            },
-        });
-
-        this.input = new WritableStream<JSONRPCMessage>({
-            write: (message) => this.onmessage?.(message),
-            start: () => {
-                inputResolve();
-            },
-        });
-
-        this.startPromise = Promise.all([inputReady, outputReady]);
-    }
-
-    async start(): Promise<void> {
-        await this.startPromise;
-    }
-
-    send(message: JSONRPCMessage): Promise<void> {
-        this.outputController?.enqueue(message);
-        return Promise.resolve();
-    }
-
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async close(): Promise<void> {
-        this.outputController?.close();
-        this.onclose?.();
-    }
-    onclose?: (() => void) | undefined;
-    onerror?: ((error: Error) => void) | undefined;
-    onmessage?: ((message: JSONRPCMessage) => void) | undefined;
-    sessionId?: string | undefined;
-
-    private static getPromise(): [Promise<void>, resolve: () => void] {
-        let resolve: () => void = () => {};
-        const promise = new Promise<void>((res) => {
-            resolve = res;
-        });
-        return [promise, resolve];
-    }
-}