mongodb-mcp-server 0.1.3 → 0.3.0

package/scripts/apply.ts

@@ -1,135 +0,0 @@
-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: Record<string, unknown> = openapi;
-    while (true) {
-        const part = paramParts.shift();
-        if (!part) {
-            break;
-        }
-
-        foundObj = foundObj[part] as Record<string, unknown>;
-    }
-    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 as string, "utf8");
-
-    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]) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            const operation = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
-
-            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) as OpenAPIV3_1.ResponseObject;
-                        if (responseObject && 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}"]>) {
-    const { ${hasResponseBody ? `data, ` : ``}error, response } = await this.client.${method}("${path}", options);
-    if (error) {
-        throw ApiClientError.fromError(response, error);
-    }
-    ${
-        hasResponseBody
-            ? `return data;
-`
-            : ``
-    }}
-`;
-        })
-        .join("\n");
-
-    const templateFile = await fs.readFile(file as string, "utf8");
-    const templateLines = templateFile.split("\n");
-    const 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 as string, output, "utf8");
-}
-
-main().catch((error) => {
-    console.error("Error:", error);
-    process.exit(1);
-});

package/scripts/filter.ts

@@ -1,76 +0,0 @@
-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) => {
-            // eslint-disable-next-line @typescript-eslint/restrict-plus-operands
-            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",
-        "listFlexClusters",
-        "getCluster",
-        "getFlexCluster",
-        "createCluster",
-        "createFlexCluster",
-        "deleteCluster",
-        "deleteFlexCluster",
-        "listClustersForAllProjects",
-        "createDatabaseUser",
-        "deleteDatabaseUser",
-        "listDatabaseUsers",
-        "listProjectIpAccessLists",
-        "createProjectIpAccessList",
-        "deleteProjectIpAccessList",
-        "listOrganizationProjects",
-        "listAlerts",
-    ];
-
-    const filteredPaths = {};
-
-    for (const path in openapi.paths) {
-        const filteredMethods = {} as OpenAPIV3_1.PathItemObject;
-        for (const method in openapi.paths[path]) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            if (allowedOperations.includes((openapi.paths[path][method] as { operationId: string }).operationId)) {
-                // @ts-expect-error This is a workaround for the OpenAPI types
-                filteredMethods[method] = openapi.paths[path][method] as OpenAPIV3_1.OperationObject;
-            }
-        }
-        if (Object.keys(filteredMethods).length > 0) {
-            // @ts-expect-error This is a workaround for the OpenAPI types
-            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

@@ -1,11 +0,0 @@
-#!/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

@@ -1,387 +0,0 @@
-import createClient, { Client, Middleware } from "openapi-fetch";
-import type { FetchOptions } from "openapi-fetch";
-import { AccessToken, ClientCredentials } from "simple-oauth2";
-import { ApiClientError } from "./apiClientError.js";
-import { paths, operations } from "./openapi.js";
-import { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
-import { packageInfo } from "../../helpers/packageInfo.js";
-
-const ATLAS_API_VERSION = "2025-03-12";
-
-export interface ApiClientCredentials {
-    clientId: string;
-    clientSecret: string;
-}
-
-export interface ApiClientOptions {
-    credentials?: ApiClientCredentials;
-    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({
-                agent: this.options.userAgent,
-            });
-        }
-        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
-            }
-        },
-    };
-
-    constructor(options: ApiClientOptions) {
-        this.options = {
-            ...options,
-            userAgent:
-                options.userAgent ||
-                `AtlasMCP/${packageInfo.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);
-        }
-    }
-
-    public hasCredentials(): boolean {
-        return !!(this.oauth2Client && this.accessToken);
-    }
-
-    public async validateAccessToken(): Promise<void> {
-        await this.getAccessToken();
-    }
-
-    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;
-        }>;
-    }
-
-    public async sendEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {
-        if (!this.options.credentials) {
-            await this.sendUnauthEvents(events);
-            return;
-        }
-
-        try {
-            await this.sendAuthEvents(events);
-        } catch (error) {
-            if (error instanceof ApiClientError) {
-                if (error.response.status !== 401) {
-                    throw error;
-                }
-            }
-
-            // send unauth events if any of the following are true:
-            // 1: the token is not valid (not ApiClientError)
-            // 2: if the api responded with 401 (ApiClientError with status 401)
-            await this.sendUnauthEvents(events);
-        }
-    }
-
-    private async sendAuthEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {
-        const accessToken = await this.getAccessToken();
-        if (!accessToken) {
-            throw new Error("No access token available");
-        }
-        const authUrl = new URL("api/private/v1.0/telemetry/events", this.options.baseUrl);
-        const response = await fetch(authUrl, {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
-                "User-Agent": this.options.userAgent,
-                Authorization: `Bearer ${accessToken}`,
-            },
-            body: JSON.stringify(events),
-        });
-
-        if (!response.ok) {
-            throw await ApiClientError.fromResponse(response);
-        }
-    }
-
-    private async sendUnauthEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {
-        const headers: Record<string, string> = {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-            "User-Agent": this.options.userAgent,
-        };
-
-        const unauthUrl = new URL("api/private/unauth/telemetry/events", this.options.baseUrl);
-        const response = await fetch(unauthUrl, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(events),
-        });
-
-        if (!response.ok) {
-            throw await ApiClientError.fromResponse(response);
-        }
-    }
-
-    // DO NOT EDIT. This is auto-generated code.
-    async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listProjects(options?: FetchOptions<operations["listProjects"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async createProject(options: FetchOptions<operations["createProject"]>) {
-        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async deleteProject(options: FetchOptions<operations["deleteProject"]>) {
-        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-    }
-
-    async getProject(options: FetchOptions<operations["getProject"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listProjectIpAccessLists(options: FetchOptions<operations["listProjectIpAccessLists"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async createProjectIpAccessList(options: FetchOptions<operations["createProjectIpAccessList"]>) {
-        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async deleteProjectIpAccessList(options: FetchOptions<operations["deleteProjectIpAccessList"]>) {
-        const { error, response } = await this.client.DELETE(
-            "/api/atlas/v2/groups/{groupId}/accessList/{entryValue}",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-    }
-
-    async listAlerts(options: FetchOptions<operations["listAlerts"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/alerts", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listClusters(options: FetchOptions<operations["listClusters"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async createCluster(options: FetchOptions<operations["createCluster"]>) {
-        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async deleteCluster(options: FetchOptions<operations["deleteCluster"]>) {
-        const { error, response } = await this.client.DELETE(
-            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-    }
-
-    async getCluster(options: FetchOptions<operations["getCluster"]>) {
-        const { data, error, response } = await this.client.GET(
-            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}",
-            options
-        );
-
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listDatabaseUsers(options: FetchOptions<operations["listDatabaseUsers"]>) {
-        const { data, error, response } = await this.client.GET(
-            "/api/atlas/v2/groups/{groupId}/databaseUsers",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async createDatabaseUser(options: FetchOptions<operations["createDatabaseUser"]>) {
-        const { data, error, response } = await this.client.POST(
-            "/api/atlas/v2/groups/{groupId}/databaseUsers",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async deleteDatabaseUser(options: FetchOptions<operations["deleteDatabaseUser"]>) {
-        const { error, response } = await this.client.DELETE(
-            "/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-    }
-
-    async listFlexClusters(options: FetchOptions<operations["listFlexClusters"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async createFlexCluster(options: FetchOptions<operations["createFlexCluster"]>) {
-        const { data, error, response } = await this.client.POST(
-            "/api/atlas/v2/groups/{groupId}/flexClusters",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async deleteFlexCluster(options: FetchOptions<operations["deleteFlexCluster"]>) {
-        const { error, response } = await this.client.DELETE(
-            "/api/atlas/v2/groups/{groupId}/flexClusters/{name}",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-    }
-
-    async getFlexCluster(options: FetchOptions<operations["getFlexCluster"]>) {
-        const { data, error, response } = await this.client.GET(
-            "/api/atlas/v2/groups/{groupId}/flexClusters/{name}",
-            options
-        );
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listOrganizations(options?: FetchOptions<operations["listOrganizations"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    async listOrganizationProjects(options: FetchOptions<operations["listOrganizationProjects"]>) {
-        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);
-        if (error) {
-            throw ApiClientError.fromError(response, error);
-        }
-        return data;
-    }
-
-    // DO NOT EDIT. This is auto-generated code.
-}