mongodb-mcp-server 0.1.0 → 0.1.2

package/src/common/atlas/apiClient.ts

@@ -4,7 +4,7 @@ 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 "../../packageInfo.js";
+import { packageInfo } from "../../helpers/packageInfo.js";
 
 const ATLAS_API_VERSION = "2025-03-12";
 
@@ -34,7 +34,9 @@ export class ApiClient {
 
     private getAccessToken = async () => {
         if (this.oauth2Client && (!this.accessToken || this.accessToken.expired())) {
-            this.accessToken = await this.oauth2Client.getToken({});
+            this.accessToken = await this.oauth2Client.getToken({
+                agent: this.options.userAgent,
+            });
         }
         return this.accessToken?.token.access_token as string | undefined;
     };
@@ -55,14 +57,6 @@ export class ApiClient {
         },
     };
 
-    private readonly errorMiddleware: Middleware = {
-        async onResponse({ response }) {
-            if (!response.ok) {
-                throw await ApiClientError.fromResponse(response);
-            }
-        },
-    };
-
     constructor(options: ApiClientOptions) {
         this.options = {
             ...options,
@@ -91,13 +85,16 @@ export class ApiClient {
             });
             this.client.use(this.authMiddleware);
         }
-        this.client.use(this.errorMiddleware);
     }
 
     public hasCredentials(): boolean {
         return !!(this.oauth2Client && this.accessToken);
     }
 
+    public async validateAccessToken(): Promise<void> {
+        await this.getAccessToken();
+    }
+
     public async getIpInfo(): Promise<{
         currentIpv4Address: string;
     }> {
@@ -123,22 +120,59 @@ export class ApiClient {
         }>;
     }
 
-    async sendEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {
-        let endpoint = "api/private/unauth/telemetry/events";
+    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 accessToken = await this.getAccessToken();
-        if (accessToken) {
-            endpoint = "api/private/v1.0/telemetry/events";
-            headers["Authorization"] = `Bearer ${accessToken}`;
-        }
-
-        const url = new URL(endpoint, this.options.baseUrl);
-        const response = await fetch(url, {
+        const unauthUrl = new URL("api/private/unauth/telemetry/events", this.options.baseUrl);
+        const response = await fetch(unauthUrl, {
             method: "POST",
             headers,
             body: JSON.stringify(events),
@@ -151,83 +185,201 @@ export class ApiClient {
 
     // 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);
+        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 } = await this.client.GET("/api/atlas/v2/groups", options);
+        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 } = await this.client.POST("/api/atlas/v2/groups", options);
+        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"]>) {
-        await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);
+        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 } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);
+        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 } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);
+        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 } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);
+        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"]>) {
-        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/accessList/{entryValue}", options);
+        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 } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
+        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 } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
+        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"]>) {
-        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+        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 } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+        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 } = await this.client.GET("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        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 } = await this.client.POST("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        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"]>) {
-        await this.client.DELETE("/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}", options);
+        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 } = await this.client.GET("/api/atlas/v2/orgs", options);
+        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 } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
         return data;
     }
 

package/src/common/atlas/apiClientError.ts

@@ -1,21 +1,72 @@
-export class ApiClientError extends Error {
-    response?: Response;
+import { ApiError } from "./openapi.js";
 
-    constructor(message: string, response: Response | undefined = undefined) {
+export class ApiClientError extends Error {
+    private constructor(
+        message: string,
+        public readonly response: Response,
+        public readonly apiError?: ApiError
+    ) {
         super(message);
         this.name = "ApiClientError";
-        this.response = response;
     }
 
     static async fromResponse(
         response: Response,
         message: string = `error calling Atlas API`
     ): Promise<ApiClientError> {
+        const err = await this.extractError(response);
+
+        return this.fromError(response, err, message);
+    }
+
+    static fromError(
+        response: Response,
+        error?: ApiError | string | Error,
+        message: string = `error calling Atlas API`
+    ): ApiClientError {
+        const errorMessage = this.buildErrorMessage(error);
+
+        const apiError = typeof error === "object" && !(error instanceof Error) ? error : undefined;
+
+        return new ApiClientError(
+            `[${response.status} ${response.statusText}] ${message}: ${errorMessage}`,
+            response,
+            apiError
+        );
+    }
+
+    private static async extractError(response: Response): Promise<ApiError | string | undefined> {
         try {
-            const text = await response.text();
-            return new ApiClientError(`${message}: [${response.status} ${response.statusText}] ${text}`, response);
+            return (await response.json()) as ApiError;
         } catch {
-            return new ApiClientError(`${message}: ${response.status} ${response.statusText}`, response);
+            try {
+                return await response.text();
+            } catch {
+                return undefined;
+            }
         }
     }
+
+    private static buildErrorMessage(error?: string | ApiError | Error): string {
+        let errorMessage: string = "unknown error";
+
+        if (error instanceof Error) {
+            return error.message;
+        }
+
+        //eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (typeof error) {
+            case "object":
+                errorMessage = error.reason || "unknown error";
+                if (error.detail && error.detail.length > 0) {
+                    errorMessage = `${errorMessage}; ${error.detail}`;
+                }
+                break;
+            case "string":
+                errorMessage = error;
+                break;
+        }
+
+        return errorMessage.trim();
+    }
 }

package/src/common/atlas/cluster.ts

@@ -0,0 +1,94 @@
+import { ClusterDescription20240805, FlexClusterDescription20241113 } from "./openapi.js";
+import { ApiClient } from "./apiClient.js";
+import logger, { LogId } from "../../logger.js";
+
+export interface Cluster {
+    name?: string;
+    instanceType: "FREE" | "DEDICATED" | "FLEX";
+    instanceSize?: string;
+    state?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
+    mongoDBVersion?: string;
+    connectionString?: string;
+}
+
+export function formatFlexCluster(cluster: FlexClusterDescription20241113): Cluster {
+    return {
+        name: cluster.name,
+        instanceType: "FLEX",
+        instanceSize: undefined,
+        state: cluster.stateName,
+        mongoDBVersion: cluster.mongoDBVersion,
+        connectionString: cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard,
+    };
+}
+
+export function formatCluster(cluster: ClusterDescription20240805): Cluster {
+    const regionConfigs = (cluster.replicationSpecs || [])
+        .map(
+            (replicationSpec) =>
+                (replicationSpec.regionConfigs || []) as {
+                    providerName: string;
+                    electableSpecs?: {
+                        instanceSize: string;
+                    };
+                    readOnlySpecs?: {
+                        instanceSize: string;
+                    };
+                    analyticsSpecs?: {
+                        instanceSize: string;
+                    };
+                }[]
+        )
+        .flat()
+        .map((regionConfig) => {
+            return {
+                providerName: regionConfig.providerName,
+                instanceSize:
+                    regionConfig.electableSpecs?.instanceSize ||
+                    regionConfig.readOnlySpecs?.instanceSize ||
+                    regionConfig.analyticsSpecs?.instanceSize,
+            };
+        });
+
+    const instanceSize = regionConfigs[0]?.instanceSize ?? "UNKNOWN";
+    const clusterInstanceType = instanceSize == "M0" ? "FREE" : "DEDICATED";
+
+    return {
+        name: cluster.name,
+        instanceType: clusterInstanceType,
+        instanceSize: clusterInstanceType == "DEDICATED" ? instanceSize : undefined,
+        state: cluster.stateName,
+        mongoDBVersion: cluster.mongoDBVersion,
+        connectionString: cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard,
+    };
+}
+
+export async function inspectCluster(apiClient: ApiClient, projectId: string, clusterName: string): Promise<Cluster> {
+    try {
+        const cluster = await apiClient.getCluster({
+            params: {
+                path: {
+                    groupId: projectId,
+                    clusterName,
+                },
+            },
+        });
+        return formatCluster(cluster);
+    } catch (error) {
+        try {
+            const cluster = await apiClient.getFlexCluster({
+                params: {
+                    path: {
+                        groupId: projectId,
+                        name: clusterName,
+                    },
+                },
+            });
+            return formatFlexCluster(cluster);
+        } catch (flexError) {
+            const err = flexError instanceof Error ? flexError : new Error(String(flexError));
+            logger.error(LogId.atlasInspectFailure, "inspect-cluster", `error inspecting cluster: ${err.message}`);
+            throw error;
+        }
+    }
+}

package/src/common/atlas/generatePassword.ts

@@ -0,0 +1,10 @@
+import { randomBytes } from "crypto";
+import { promisify } from "util";
+
+const randomBytesAsync = promisify(randomBytes);
+
+export async function generateSecurePassword(): Promise<string> {
+    const buf = await randomBytesAsync(16);
+    const pass = buf.toString("base64url");
+    return pass;
+}