mongodb-mcp-server 0.0.4

package/scripts/apply.ts

@@ -0,0 +1,129 @@
+import fs from "fs/promises";
+import { OpenAPIV3_1 } from "openapi-types";
+import argv from "yargs-parser";
+
+function findObjectFromRef<T>(obj: T | OpenAPIV3_1.ReferenceObject, openapi: OpenAPIV3_1.Document): T {
+    const ref = (obj as OpenAPIV3_1.ReferenceObject).$ref;
+    if (ref === undefined) {
+        return obj as T;
+    }
+    const paramParts = ref.split("/");
+    paramParts.shift(); // Remove the first part which is always '#'
+    let foundObj: any = openapi; // eslint-disable-line @typescript-eslint/no-explicit-any
+    while (true) {
+        const part = paramParts.shift();
+        if (!part) {
+            break;
+        }
+        foundObj = foundObj[part];
+    }
+    return foundObj as T;
+}
+
+async function main() {
+    const { spec, file } = argv(process.argv.slice(2));
+
+    if (!spec || !file) {
+        console.error("Please provide both --spec and --file arguments.");
+        process.exit(1);
+    }
+
+    const specFile = (await fs.readFile(spec, "utf8")) as string;
+
+    const operations: {
+        path: string;
+        method: string;
+        operationId: string;
+        requiredParams: boolean;
+        tag: string;
+        hasResponseBody: boolean;
+    }[] = [];
+
+    const openapi = JSON.parse(specFile) as OpenAPIV3_1.Document;
+    for (const path in openapi.paths) {
+        for (const method in openapi.paths[path]) {
+            const operation: OpenAPIV3_1.OperationObject = openapi.paths[path][method];
+
+            if (!operation.operationId || !operation.tags?.length) {
+                continue;
+            }
+
+            let requiredParams = !!operation.requestBody;
+            let hasResponseBody = false;
+            for (const code in operation.responses) {
+                try {
+                    const httpCode = parseInt(code, 10);
+                    if (httpCode >= 200 && httpCode < 300) {
+                        const response = operation.responses[code];
+                        const responseObject = findObjectFromRef(response, openapi);
+                        if (responseObject.content) {
+                            for (const contentType in responseObject.content) {
+                                const content = responseObject.content[contentType];
+                                hasResponseBody = !!content.schema;
+                            }
+                        }
+                    }
+                } catch {
+                    continue;
+                }
+            }
+
+            for (const param of operation.parameters || []) {
+                const paramObject = findObjectFromRef(param, openapi);
+                if (paramObject.in === "path") {
+                    requiredParams = true;
+                }
+            }
+
+            operations.push({
+                path,
+                method: method.toUpperCase(),
+                operationId: operation.operationId || "",
+                requiredParams,
+                hasResponseBody,
+                tag: operation.tags[0],
+            });
+        }
+    }
+
+    const operationOutput = operations
+        .map((operation) => {
+            const { operationId, method, path, requiredParams, hasResponseBody } = operation;
+            return `async ${operationId}(options${requiredParams ? "" : "?"}: FetchOptions<operations["${operationId}"]>) {
+    ${hasResponseBody ? `const { data } = ` : ``}await this.client.${method}("${path}", options);
+    ${
+        hasResponseBody
+            ? `return data;
+`
+            : ``
+    }}
+`;
+        })
+        .join("\n");
+
+    const templateFile = (await fs.readFile(file, "utf8")) as string;
+    const templateLines = templateFile.split("\n");
+    let outputLines: string[] = [];
+    let addLines = true;
+    for (const line of templateLines) {
+        if (line.includes("DO NOT EDIT. This is auto-generated code.")) {
+            addLines = !addLines;
+            outputLines.push(line);
+            if (!addLines) {
+                outputLines.push(operationOutput);
+            }
+            continue;
+        }
+        if (addLines) {
+            outputLines.push(line);
+        }
+    }
+    const output = outputLines.join("\n");
+
+    await fs.writeFile(file, output, "utf8");
+}
+
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});

package/scripts/filter.ts

@@ -0,0 +1,67 @@
+import { OpenAPIV3_1 } from "openapi-types";
+
+async function readStdin() {
+    return new Promise<string>((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("error", (err) => {
+            reject(err);
+        });
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            resolve(data);
+        });
+    });
+}
+
+function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
+    const allowedOperations = [
+        "listProjects",
+        "listOrganizations",
+        "getProject",
+        "createProject",
+        "deleteProject",
+        "listClusters",
+        "getCluster",
+        "createCluster",
+        "deleteCluster",
+        "listClustersForAllProjects",
+        "createDatabaseUser",
+        "deleteDatabaseUser",
+        "listDatabaseUsers",
+        "listProjectIpAccessLists",
+        "createProjectIpAccessList",
+        "deleteProjectIpAccessList",
+        "listOrganizationProjects",
+    ];
+
+    const filteredPaths = {};
+
+    for (const path in openapi.paths) {
+        const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
+        for (const method in openapi.paths[path]) {
+            if (allowedOperations.includes(openapi.paths[path][method].operationId)) {
+                filteredMethods[method] = openapi.paths[path][method];
+            }
+        }
+        if (Object.keys(filteredMethods).length > 0) {
+            filteredPaths[path] = filteredMethods;
+        }
+    }
+
+    return { ...openapi, paths: filteredPaths };
+}
+
+async function main() {
+    const openapiText = await readStdin();
+    const openapi = JSON.parse(openapiText) as OpenAPIV3_1.Document;
+    const filteredOpenapi = filterOpenapi(openapi);
+    console.log(JSON.stringify(filteredOpenapi));
+}
+
+main().catch((error) => {
+    console.error("Error:", error);
+    process.exit(1);
+});

package/scripts/generate.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -Eeou pipefail
+
+curl -Lo ./scripts/spec.json https://github.com/mongodb/openapi/raw/refs/heads/main/openapi/v2/openapi-2025-03-12.json
+tsx ./scripts/filter.ts > ./scripts/filteredSpec.json < ./scripts/spec.json
+redocly bundle --ext json --remove-unused-components ./scripts/filteredSpec.json --output ./scripts/bundledSpec.json
+openapi-typescript ./scripts/bundledSpec.json --root-types-no-schema-prefix --root-types --output ./src/common/atlas/openapi.d.ts
+tsx ./scripts/apply.ts --spec ./scripts/bundledSpec.json --file ./src/common/atlas/apiClient.ts
+prettier --write ./src/common/atlas/openapi.d.ts ./src/common/atlas/apiClient.ts
+rm -rf ./scripts/bundledSpec.json ./scripts/filteredSpec.json ./scripts/spec.json

package/src/common/atlas/apiClient.ts

@@ -0,0 +1,202 @@
+import config from "../../config.js";
+import createClient, { Client, FetchOptions, Middleware } from "openapi-fetch";
+import { AccessToken, ClientCredentials } from "simple-oauth2";
+import { ApiClientError } from "./apiClientError.js";
+import { paths, operations } from "./openapi.js";
+
+const ATLAS_API_VERSION = "2025-03-12";
+
+export interface ApiClientOptions {
+    credentials?: {
+        clientId: string;
+        clientSecret: string;
+    };
+    baseUrl?: string;
+    userAgent?: string;
+}
+
+export class ApiClient {
+    private options: {
+        baseUrl: string;
+        userAgent: string;
+        credentials?: {
+            clientId: string;
+            clientSecret: string;
+        };
+    };
+    private client: Client<paths>;
+    private oauth2Client?: ClientCredentials;
+    private accessToken?: AccessToken;
+
+    private getAccessToken = async () => {
+        if (this.oauth2Client && (!this.accessToken || this.accessToken.expired())) {
+            this.accessToken = await this.oauth2Client.getToken({});
+        }
+        return this.accessToken?.token.access_token as string | undefined;
+    };
+
+    private authMiddleware: Middleware = {
+        onRequest: async ({ request, schemaPath }) => {
+            if (schemaPath.startsWith("/api/private/unauth") || schemaPath.startsWith("/api/oauth")) {
+                return undefined;
+            }
+
+            try {
+                const accessToken = await this.getAccessToken();
+                request.headers.set("Authorization", `Bearer ${accessToken}`);
+                return request;
+            } catch {
+                // ignore not availble tokens, API will return 401
+            }
+        },
+    };
+
+    private readonly errorMiddleware: Middleware = {
+        async onResponse({ response }) {
+            if (!response.ok) {
+                throw await ApiClientError.fromResponse(response);
+            }
+        },
+    };
+
+    constructor(options?: ApiClientOptions) {
+        this.options = {
+            ...options,
+            baseUrl: options?.baseUrl || "https://cloud.mongodb.com/",
+            userAgent:
+                options?.userAgent ||
+                `AtlasMCP/${config.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
+        };
+
+        this.client = createClient<paths>({
+            baseUrl: this.options.baseUrl,
+            headers: {
+                "User-Agent": this.options.userAgent,
+                Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
+            },
+        });
+        if (this.options.credentials?.clientId && this.options.credentials?.clientSecret) {
+            this.oauth2Client = new ClientCredentials({
+                client: {
+                    id: this.options.credentials.clientId,
+                    secret: this.options.credentials.clientSecret,
+                },
+                auth: {
+                    tokenHost: this.options.baseUrl,
+                    tokenPath: "/api/oauth/token",
+                },
+            });
+            this.client.use(this.authMiddleware);
+        }
+        this.client.use(this.errorMiddleware);
+    }
+
+    public async getIpInfo(): Promise<{
+        currentIpv4Address: string;
+    }> {
+        const accessToken = await this.getAccessToken();
+
+        const endpoint = "api/private/ipinfo";
+        const url = new URL(endpoint, this.options.baseUrl);
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${accessToken}`,
+                "User-Agent": this.options.userAgent,
+            },
+        });
+
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+
+        return (await response.json()) as Promise<{
+            currentIpv4Address: string;
+        }>;
+    }
+
+    // DO NOT EDIT. This is auto-generated code.
+    async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/clusters", options);
+        return data;
+    }
+
+    async listProjects(options?: FetchOptions<operations["listProjects"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups", options);
+        return data;
+    }
+
+    async createProject(options: FetchOptions<operations["createProject"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups", options);
+        return data;
+    }
+
+    async deleteProject(options: FetchOptions<operations["deleteProject"]>) {
+        await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);
+    }
+
+    async getProject(options: FetchOptions<operations["getProject"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);
+        return data;
+    }
+
+    async listProjectIpAccessLists(options: FetchOptions<operations["listProjectIpAccessLists"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);
+        return data;
+    }
+
+    async createProjectIpAccessList(options: FetchOptions<operations["createProjectIpAccessList"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);
+        return data;
+    }
+
+    async deleteProjectIpAccessList(options: FetchOptions<operations["deleteProjectIpAccessList"]>) {
+        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/accessList/{entryValue}", options);
+    }
+
+    async listClusters(options: FetchOptions<operations["listClusters"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
+        return data;
+    }
+
+    async createCluster(options: FetchOptions<operations["createCluster"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
+        return data;
+    }
+
+    async deleteCluster(options: FetchOptions<operations["deleteCluster"]>) {
+        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+    }
+
+    async getCluster(options: FetchOptions<operations["getCluster"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+        return data;
+    }
+
+    async listDatabaseUsers(options: FetchOptions<operations["listDatabaseUsers"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        return data;
+    }
+
+    async createDatabaseUser(options: FetchOptions<operations["createDatabaseUser"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        return data;
+    }
+
+    async deleteDatabaseUser(options: FetchOptions<operations["deleteDatabaseUser"]>) {
+        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}", options);
+    }
+
+    async listOrganizations(options?: FetchOptions<operations["listOrganizations"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/orgs", options);
+        return data;
+    }
+
+    async listOrganizationProjects(options: FetchOptions<operations["listOrganizationProjects"]>) {
+        const { data } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);
+        return data;
+    }
+
+    // DO NOT EDIT. This is auto-generated code.
+}

package/src/common/atlas/apiClientError.ts

@@ -0,0 +1,21 @@
+export class ApiClientError extends Error {
+    response?: Response;
+
+    constructor(message: string, response: Response | undefined = undefined) {
+        super(message);
+        this.name = "ApiClientError";
+        this.response = response;
+    }
+
+    static async fromResponse(
+        response: Response,
+        message: string = `error calling Atlas API`
+    ): Promise<ApiClientError> {
+        try {
+            const text = await response.text();
+            return new ApiClientError(`${message}: [${response.status} ${response.statusText}] ${text}`, response);
+        } catch {
+            return new ApiClientError(`${message}: ${response.status} ${response.statusText}`, response);
+        }
+    }
+}