refactor: use openapi-fetch (#47)

Author: fmenezes

package-lock.json

@@ -59,6 +59,7 @@
     "mongodb-log-writer": "^2.4.1",
     "mongodb-redact": "^1.1.6",
     "mongodb-schema": "^12.6.2",
+    "openapi-fetch": "^0.13.5",
     "yargs-parser": "^21.1.1",
     "zod": "^3.24.2"
   },

package.json

@@ -22,6 +22,7 @@ function filterOpenapi(openapi: OpenAPIV3_1.Document): OpenAPIV3_1.Document {
         "getProject",
         "createProject",
         "listClusters",
+        "getCluster",
         "createCluster",
         "listClustersForAllProjects",
         "createDatabaseUser",

scripts/filter.ts

@@ -1,16 +1,7 @@
 import config from "../../config.js";
+import createClient, { FetchOptions, Middleware } from "openapi-fetch";
 
-import {
-    Group,
-    PaginatedOrgGroupView,
-    PaginatedAtlasGroupView,
-    ClusterDescription20240805,
-    PaginatedClusterDescription20240805,
-    PaginatedNetworkAccessView,
-    NetworkPermissionEntry,
-    CloudDatabaseUser,
-    PaginatedApiAtlasDatabaseUserView,
-} from "./openapi.js";
+import { paths, operations } from "./openapi.js";
 
 export interface OAuthToken {
     access_token: string;
@@ -40,6 +31,16 @@ export class ApiClientError extends Error {
         this.name = "ApiClientError";
         this.response = response;
     }
+
+    static async fromResponse(response: Response, message?: string): Promise<ApiClientError> {
+        message ||= `error calling Atlas API`;
+        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);
+        }
+    }
 }
 
 export interface ApiClientOptions {
@@ -48,32 +49,40 @@ export interface ApiClientOptions {
 }
 
 export class ApiClient {
-    token?: OAuthToken;
-    saveToken?: saveTokenFunction;
+    private token?: OAuthToken;
+    private saveToken?: saveTokenFunction;
+    private client = createClient<paths>({
+        baseUrl: config.apiBaseUrl,
+        headers: {
+            "User-Agent": config.userAgent,
+            Accept: `application/vnd.atlas.${config.atlasApiVersion}+json`,
+        },
+    });
+    private authMiddleware = (apiClient: ApiClient): Middleware => ({
+        async onRequest({ request, schemaPath }) {
+            if (schemaPath.startsWith("/api/private/unauth") || schemaPath.startsWith("/api/oauth")) {
+                return undefined;
+            }
+            if (await apiClient.validateToken()) {
+                request.headers.set("Authorization", `Bearer ${apiClient.token?.access_token}`);
+                return request;
+            }
+        },
+    });
+    private errorMiddleware = (): Middleware => ({
+        async onResponse({ response }) {
+            if (!response.ok) {
+                throw await ApiClientError.fromResponse(response);
+            }
+        },
+    });
 
     constructor(options: ApiClientOptions) {
         const { token, saveToken } = options;
         this.token = token;
         this.saveToken = saveToken;
-    }
-
-    private defaultOptions(): RequestInit {
-        const authHeaders = !this.token?.access_token
-            ? null
-            : {
-                  Authorization: `Bearer ${this.token.access_token}`,
-              };
-
-        return {
-            method: "GET",
-            credentials: !this.token?.access_token ? undefined : "include",
-            headers: {
-                "Content-Type": "application/json",
-                Accept: `application/vnd.atlas.${config.atlasApiVersion}+json`,
-                "User-Agent": config.userAgent,
-                ...authHeaders,
-            },
-        };
+        this.client.use(this.authMiddleware(this));
+        this.client.use(this.errorMiddleware());
     }
 
     async storeToken(token: OAuthToken): Promise<OAuthToken> {
@@ -86,36 +95,6 @@ export class ApiClient {
         return token;
     }
 
-    async do<T>(endpoint: string, options?: RequestInit): Promise<T> {
-        if (!this.token || !this.token.access_token) {
-            throw new Error("Not authenticated. Please run the auth tool first.");
-        }
-
-        const url = new URL(`api/atlas/v2${endpoint}`, `${config.apiBaseUrl}`);
-
-        if (!this.checkTokenExpiry()) {
-            await this.refreshToken();
-        }
-
-        const defaultOpt = this.defaultOptions();
-        const opt = {
-            ...defaultOpt,
-            ...options,
-            headers: {
-                ...defaultOpt.headers,
-                ...options?.headers,
-            },
-        };
-
-        const response = await fetch(url, opt);
-
-        if (!response.ok) {
-            throw new ApiClientError(`Error calling Atlas API: ${await response.text()}`, response);
-        }
-
-        return (await response.json()) as T;
-    }
-
     async authenticate(): Promise<OauthDeviceCode> {
         const endpoint = "api/private/unauth/account/device/authorize";
 
@@ -135,7 +114,7 @@ export class ApiClient {
         });
 
         if (!response.ok) {
-            throw new ApiClientError(`Failed to initiate authentication: ${response.statusText}`, response);
+            throw await ApiClientError.fromResponse(response, `failed to initiate authentication`);
         }
 
         return (await response.json()) as OauthDeviceCode;
@@ -166,14 +145,18 @@ export class ApiClient {
         try {
             const errorResponse = await response.json();
             if (errorResponse.errorCode === "DEVICE_AUTHORIZATION_PENDING") {
-                throw new ApiClientError("Authentication pending. Try again later.", response);
-            } else if (errorResponse.error === "expired_token") {
-                throw new ApiClientError("Device code expired. Please restart the authentication process.", response);
+                throw await ApiClientError.fromResponse(response, "Authentication pending. Try again later.");
             } else {
-                throw new ApiClientError("Device code expired. Please restart the authentication process.", response);
+                throw await ApiClientError.fromResponse(
+                    response,
+                    "Device code expired. Please restart the authentication process."
+                );
             }
         } catch {
-            throw new ApiClientError("Failed to retrieve token. Please check your device code.", response);
+            throw await ApiClientError.fromResponse(
+                response,
+                "Failed to retrieve token. Please check your device code."
+            );
         }
     }
 
@@ -195,7 +178,7 @@ export class ApiClient {
         });
 
         if (!response.ok) {
-            throw new ApiClientError(`Failed to refresh token: ${response.statusText}`, response);
+            throw await ApiClientError.fromResponse(response, "Failed to refresh token");
         }
         const data = await response.json();
 
@@ -229,7 +212,7 @@ export class ApiClient {
         });
 
         if (!response.ok) {
-            throw new ApiClientError(`Failed to revoke token: ${response.statusText}`, response);
+            throw await ApiClientError.fromResponse(response);
         }
 
         if (!token && this.token) {
@@ -269,58 +252,53 @@ export class ApiClient {
         }
     }
 
-    async listProjects(): Promise<PaginatedAtlasGroupView> {
-        return await this.do<PaginatedAtlasGroupView>("/groups");
+    async listProjects(options?: FetchOptions<operations["listProjects"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups`, options);
+        return data;
     }
 
-    async listProjectIpAccessLists(groupId: string): Promise<PaginatedNetworkAccessView> {
-        return await this.do<PaginatedNetworkAccessView>(`/groups/${groupId}/accessList`);
+    async listProjectIpAccessLists(options: FetchOptions<operations["listProjectIpAccessLists"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups/{groupId}/accessList`, options);
+        return data;
     }
 
-    async createProjectIpAccessList(
-        groupId: string,
-        entries: NetworkPermissionEntry[]
-    ): Promise<PaginatedNetworkAccessView> {
-        return await this.do<PaginatedNetworkAccessView>(`/groups/${groupId}/accessList`, {
-            method: "POST",
-            body: JSON.stringify(entries),
-        });
+    async createProjectIpAccessList(options: FetchOptions<operations["createProjectIpAccessList"]>) {
+        const { data } = await this.client.POST(`/api/atlas/v2/groups/{groupId}/accessList`, options);
+        return data;
     }
 
-    async getProject(groupId: string): Promise<Group> {
-        return await this.do<Group>(`/groups/${groupId}`);
+    async getProject(options: FetchOptions<operations["getProject"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups/{groupId}`, options);
+        return data;
     }
 
-    async listClusters(groupId: string): Promise<PaginatedClusterDescription20240805> {
-        return await this.do<PaginatedClusterDescription20240805>(`/groups/${groupId}/clusters`);
+    async listClusters(options: FetchOptions<operations["listClusters"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups/{groupId}/clusters`, options);
+        return data;
     }
 
-    async listClustersForAllProjects(): Promise<PaginatedOrgGroupView> {
-        return await this.do<PaginatedOrgGroupView>(`/clusters`);
+    async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/clusters`, options);
+        return data;
     }
 
-    async getCluster(groupId: string, clusterName: string): Promise<ClusterDescription20240805> {
-        return await this.do<ClusterDescription20240805>(`/groups/${groupId}/clusters/${clusterName}`);
+    async getCluster(options: FetchOptions<operations["getCluster"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups/{groupId}/clusters/{clusterName}`, options);
+        return data;
     }
 
-    async createCluster(groupId: string, cluster: ClusterDescription20240805): Promise<ClusterDescription20240805> {
-        if (!cluster.groupId) {
-            throw new Error("Cluster groupId is required");
-        }
-        return await this.do<ClusterDescription20240805>(`/groups/${groupId}/clusters`, {
-            method: "POST",
-            body: JSON.stringify(cluster),
-        });
+    async createCluster(options: FetchOptions<operations["createCluster"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
+        return data;
     }
 
-    async createDatabaseUser(groupId: string, user: CloudDatabaseUser): Promise<CloudDatabaseUser> {
-        return await this.do<CloudDatabaseUser>(`/groups/${groupId}/databaseUsers`, {
-            method: "POST",
-            body: JSON.stringify(user),
-        });
+    async createDatabaseUser(options: FetchOptions<operations["createDatabaseUser"]>) {
+        const { data } = await this.client.POST("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        return data;
     }
 
-    async listDatabaseUsers(groupId: string): Promise<PaginatedApiAtlasDatabaseUserView> {
-        return await this.do<PaginatedApiAtlasDatabaseUserView>(`/groups/${groupId}/databaseUsers`);
+    async listDatabaseUsers(options: FetchOptions<operations["listDatabaseUsers"]>) {
+        const { data } = await this.client.GET(`/api/atlas/v2/groups/{groupId}/databaseUsers`, options);
+        return data;
     }
 }

src/common/atlas/apiClient.ts

@@ -120,6 +120,28 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Return One Cluster from One Project
+         * @description Returns the details for one cluster in the specified project. Clusters contain a group of hosts that maintain the same data set. The response includes clusters with asymmetrically-sized shards. To use this resource, the requesting Service Account or API Key must have the Project Read Only role. This feature is not available for serverless clusters.
+         *
+         *     This endpoint can also be used on Flex clusters that were created using the [createCluster](https://www.mongodb.com/docs/atlas/reference/api-resources-spec/v2/#tag/Clusters/operation/createCluster) endpoint or former M2/M5 clusters that have been migrated to Flex clusters until January 2026. Please use the getFlexCluster endpoint for Flex clusters instead. Deprecated versions: v2-{2023-02-01}, v2-{2023-01-01}
+         */
+        get: operations["getCluster"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/atlas/v2/groups/{groupId}/databaseUsers": {
         parameters: {
             query?: never;
@@ -7467,6 +7489,42 @@ export interface operations {
             500: components["responses"]["internalServerError"];
         };
     };
+    getCluster: {
+        parameters: {
+            query?: {
+                /** @description Flag that indicates whether Application wraps the response in an `envelope` JSON object. Some API clients cannot access the HTTP response headers or status code. To remediate this, set envelope=true in the query. Endpoints that return a list of results use the results object as an envelope. Application adds the status parameter to the response body. */
+                envelope?: components["parameters"]["envelope"];
+                /** @description Flag that indicates whether the response body should be in the prettyprint format. */
+                pretty?: components["parameters"]["pretty"];
+            };
+            header?: never;
+            path: {
+                /** @description Unique 24-hexadecimal digit string that identifies your project. Use the [/groups](#tag/Projects/operation/listProjects) endpoint to retrieve all projects to which the authenticated user has access.
+                 *
+                 *     **NOTE**: Groups and projects are synonymous terms. Your group id is the same as your project id. For existing groups, your group/project id remains the same. The resource and corresponding endpoints use the term groups. */
+                groupId: components["parameters"]["groupId"];
+                /** @description Human-readable label that identifies this cluster. */
+                clusterName: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/vnd.atlas.2024-08-05+json": components["schemas"]["ClusterDescription20240805"];
+                };
+            };
+            401: components["responses"]["unauthorized"];
+            404: components["responses"]["notFound"];
+            409: components["responses"]["conflict"];
+            500: components["responses"]["internalServerError"];
+        };
+    };
     listDatabaseUsers: {
         parameters: {
             query?: {