20861587614

Committed 09 Jan 2026 06:28PM UTC coverage: 80.157% (+0.6%) from 79.54%

Build # 20861587614

Build Type

Pull #836

github

Committed by

web-flow

Commit Message

Merge 683bb9276 into d165aff7b

Pull Request Pull Request #836: feat: Add configurable api / auth client support

Run Details

1539 of 1993 branches covered (77.22%)

Branch coverage included in aggregate %.

206 of 209 new or added lines in 6 files covered. (98.56%)

64 existing lines in 2 files now uncovered.

7021 of 8686 relevant lines covered (80.83%)

89.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.93

/src/common/atlas/apiClient.ts

import createClient from "openapi-fetch";
import type { ClientOptions, FetchOptions, Client } from "openapi-fetch";
import { ApiClientError } from "./apiClientError.js";
import type { paths, operations } from "./openapi.js";
import type { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
import { packageInfo } from "../packageInfo.js";
import type { LoggerBase } from "../logger.js";
import { createFetch } from "@mongodb-js/devtools-proxy-support";
import { Request as NodeFetchRequest } from "node-fetch";
import type { Credentials, AuthProvider } from "./auth/authProvider.js";
import { AuthProviderFactory } from "./auth/authProvider.js";

const ATLAS_API_VERSION = "2025-03-12";

export interface ApiClientOptions {
    baseUrl: string;
    userAgent?: string;
    credentials?: Credentials;
    requestContext?: RequestContext;
}

type RequestContext = {
    headers?: Record<string, string | string[] | undefined>;
};

export type ApiClientFactoryFn = (options: ApiClientOptions, logger: LoggerBase) => ApiClient;

export const createAtlasApiClient: ApiClientFactoryFn = (options, logger) => {
    return new ApiClient(options, logger);
};

export class ApiClient {
    private readonly options: {
        baseUrl: string;
        userAgent: string;
    };

    // createFetch assumes that the first parameter of fetch is always a string
    // with the URL. However, fetch can also receive a Request object. While
    // the typechecking complains, createFetch does passthrough the parameters
    // so it works fine.
    private static customFetch: typeof fetch = createFetch({
        useEnvironmentVariableProxies: true,
    }) as unknown as typeof fetch;

    private client: Client<paths>;

    public hasCredentials(): boolean {
        return !!this.authProvider?.hasCredentials();
    }

    constructor(
        options: ApiClientOptions,
        public readonly logger: LoggerBase,
        public readonly authProvider?: AuthProvider
    ) {
        this.options = {
            ...options,
            userAgent:
                options.userAgent ??
                `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
        };

        this.authProvider =
            authProvider ??
            AuthProviderFactory.create(
                {
                    apiBaseUrl: this.options.baseUrl,
                    userAgent: this.options.userAgent,
                    credentials: options.credentials ?? {},
                },
                logger
            );

        this.client = createClient<paths>({
            baseUrl: this.options.baseUrl,
            headers: {
                "User-Agent": this.options.userAgent,
                Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
            },
            fetch: ApiClient.customFetch,
            // NodeFetchRequest has more overloadings than the native Request
            // so it complains here. However, the interfaces are actually compatible
            // so it's not a real problem, just a type checking problem.
            Request: NodeFetchRequest as unknown as ClientOptions["Request"],
        });

        if (this.authProvider) {
            this.client.use(this.authProvider.middleware());
        }
    }

    public async validateAccessToken(): Promise<void> {
        await this.authProvider?.validateAccessToken();
    }

    public async close(): Promise<void> {
        await this.authProvider?.revokeAccessToken();
    }

    public async getIpInfo(): Promise<{
        currentIpv4Address: string;
    }> {
        const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};

        const endpoint = "api/private/ipinfo";
        const url = new URL(endpoint, this.options.baseUrl);
        const response = await fetch(url, {
            method: "GET",
            headers: {
                ...authHeaders,
                Accept: "application/json",
                "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.authProvider) {
            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 authHeaders = await this.authProvider?.getAuthHeaders();
        if (!authHeaders) {
            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: {
                ...authHeaders,
                Accept: "application/json",
                "Content-Type": "application/json",
                "User-Agent": this.options.userAgent,
            },
            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.
    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listClusterDetails(options?: FetchOptions<operations["listClusterDetails"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listGroups(options?: FetchOptions<operations["listGroups"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async createGroup(options: FetchOptions<operations["createGroup"]>) {
        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async deleteGroup(options: FetchOptions<operations["deleteGroup"]>) {
        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async getGroup(options: FetchOptions<operations["getGroup"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listAccessListEntries(options: FetchOptions<operations["listGroupAccessListEntries"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async createAccessListEntry(options: FetchOptions<operations["createGroupAccessListEntry"]>) {
        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async deleteAccessListEntry(options: FetchOptions<operations["deleteGroupAccessListEntry"]>) {
        const { error, response } = await this.client.DELETE(
            "/api/atlas/v2/groups/{groupId}/accessList/{entryValue}",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listAlerts(options: FetchOptions<operations["listGroupAlerts"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/alerts", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listClusters(options: FetchOptions<operations["listGroupClusters"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async createCluster(options: FetchOptions<operations["createGroupCluster"]>) {
        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async deleteCluster(options: FetchOptions<operations["deleteGroupCluster"]>) {
        const { error, response } = await this.client.DELETE(
            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async getCluster(options: FetchOptions<operations["getGroupCluster"]>) {
        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;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listDropIndexSuggestions(
        options: FetchOptions<operations["listGroupClusterPerformanceAdvisorDropIndexSuggestions"]>
    ) {
        const { data, error, response } = await this.client.GET(
            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/dropIndexSuggestions",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listSchemaAdvice(options: FetchOptions<operations["listGroupClusterPerformanceAdvisorSchemaAdvice"]>) {
        const { data, error, response } = await this.client.GET(
            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/schemaAdvice",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listClusterSuggestedIndexes(
        options: FetchOptions<operations["listGroupClusterPerformanceAdvisorSuggestedIndexes"]>
    ) {
        const { data, error, response } = await this.client.GET(
            "/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/suggestedIndexes",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listDatabaseUsers(options: FetchOptions<operations["listGroupDatabaseUsers"]>) {
        const { data, error, response } = await this.client.GET(
            "/api/atlas/v2/groups/{groupId}/databaseUsers",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async createDatabaseUser(options: FetchOptions<operations["createGroupDatabaseUser"]>) {
        const { data, error, response } = await this.client.POST(
            "/api/atlas/v2/groups/{groupId}/databaseUsers",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async deleteDatabaseUser(options: FetchOptions<operations["deleteGroupDatabaseUser"]>) {
        const { error, response } = await this.client.DELETE(
            "/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listFlexClusters(options: FetchOptions<operations["listGroupFlexClusters"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async createFlexCluster(options: FetchOptions<operations["createGroupFlexCluster"]>) {
        const { data, error, response } = await this.client.POST(
            "/api/atlas/v2/groups/{groupId}/flexClusters",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async deleteFlexCluster(options: FetchOptions<operations["deleteGroupFlexCluster"]>) {
        const { error, response } = await this.client.DELETE(
            "/api/atlas/v2/groups/{groupId}/flexClusters/{name}",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async getFlexCluster(options: FetchOptions<operations["getGroupFlexCluster"]>) {
        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;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listSlowQueryLogs(options: FetchOptions<operations["listGroupProcessPerformanceAdvisorSlowQueryLogs"]>) {
        const { data, error, response } = await this.client.GET(
            "/api/atlas/v2/groups/{groupId}/processes/{processId}/performanceAdvisor/slowQueryLogs",
            options
        );
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async listOrgs(options?: FetchOptions<operations["listOrgs"]>) {
        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);
        if (error) {
            throw ApiClientError.fromError(response, error);
        }
        return data;
    }

    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
    async getOrgGroups(options: FetchOptions<operations["getOrgGroups"]>) {
        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.
}

1	import createClient from "openapi-fetch";	3✔
2	import type { ClientOptions, FetchOptions, Client } from "openapi-fetch";
3	import { ApiClientError } from "./apiClientError.js";	3✔
4	import type { paths, operations } from "./openapi.js";
5	import type { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
6	import { packageInfo } from "../packageInfo.js";	3✔
7	import type { LoggerBase } from "../logger.js";
8	import { createFetch } from "@mongodb-js/devtools-proxy-support";	3✔
9	import { Request as NodeFetchRequest } from "node-fetch";	3✔
10	import type { Credentials, AuthProvider } from "./auth/authProvider.js";
11	import { AuthProviderFactory } from "./auth/authProvider.js";	3✔
12
13	const ATLAS_API_VERSION = "2025-03-12";	3✔
14
15	export interface ApiClientOptions {
16	baseUrl: string;
17	userAgent?: string;
18	credentials?: Credentials;
19	requestContext?: RequestContext;
20	}
21
22	type RequestContext = {
23	headers?: Record<string, string \| string[] \| undefined>;
24	};
25
26	export type ApiClientFactoryFn = (options: ApiClientOptions, logger: LoggerBase) => ApiClient;
27
28	export const createAtlasApiClient: ApiClientFactoryFn = (options, logger) => {	3✔
29	return new ApiClient(options, logger);	145✔
30	};	145✔
31
32	export class ApiClient {	3✔
33	private readonly options: {
34	baseUrl: string;
35	userAgent: string;
36	};
37
38	// createFetch assumes that the first parameter of fetch is always a string
39	// with the URL. However, fetch can also receive a Request object. While
40	// the typechecking complains, createFetch does passthrough the parameters
41	// so it works fine.
42	private static customFetch: typeof fetch = createFetch({	3✔
43	useEnvironmentVariableProxies: true,	3✔
44	}) as unknown as typeof fetch;	3✔
45
46	private client: Client<paths>;
47
48	public hasCredentials(): boolean {	3✔
49	return !!this.authProvider?.hasCredentials();	32✔
50	}	32✔
51
52	constructor(	3✔
53	options: ApiClientOptions,	157✔
54	public readonly logger: LoggerBase,	157✔
55	public readonly authProvider?: AuthProvider	157✔
56	) {	157✔
57	this.options = {	157✔
58	...options,	157✔
59	userAgent:	157✔
60	options.userAgent ??	157✔
61	`AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME \|\| "unknown"})`,	145✔
62	};	157✔
63
64	this.authProvider =	157✔
65	authProvider ??	157✔
66	AuthProviderFactory.create(	157✔
67	{	157✔
68	apiBaseUrl: this.options.baseUrl,	157✔
69	userAgent: this.options.userAgent,	157✔
70	credentials: options.credentials ?? {},	157!
71	},	157✔
72	logger	157✔
73	);	157✔
74
75	this.client = createClient<paths>({	157✔
76	baseUrl: this.options.baseUrl,	157✔
77	headers: {	157✔
78	"User-Agent": this.options.userAgent,	157✔
79	Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,	157✔
80	},	157✔
81	fetch: ApiClient.customFetch,	157✔
82	// NodeFetchRequest has more overloadings than the native Request
83	// so it complains here. However, the interfaces are actually compatible
84	// so it's not a real problem, just a type checking problem.
85	Request: NodeFetchRequest as unknown as ClientOptions["Request"],	157✔
86	});	157✔
87
88	if (this.authProvider) {	157!
89	this.client.use(this.authProvider.middleware());	25✔
90	}	25✔
91	}	157✔
92
93	public async validateAccessToken(): Promise<void> {	3✔
94	await this.authProvider?.validateAccessToken();	20✔
95	}	20✔
96
97	public async close(): Promise<void> {	3✔
98	await this.authProvider?.revokeAccessToken();	119!
99	}	119✔
100
101	public async getIpInfo(): Promise<{	3✔
102	currentIpv4Address: string;
103	}> {	26✔
104	const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};	26!
105
106	const endpoint = "api/private/ipinfo";	26✔
107	const url = new URL(endpoint, this.options.baseUrl);	26✔
108	const response = await fetch(url, {	26✔
109	method: "GET",	26✔
110	headers: {	26✔
111	...authHeaders,	26✔
112	Accept: "application/json",	26✔
113	"User-Agent": this.options.userAgent,	26✔
114	},	26✔
115	});	26✔
116
117	if (!response.ok) {	26!
118	throw await ApiClientError.fromResponse(response);	2✔
119	}	2!
120
121	return (await response.json()) as Promise<{	24✔
122	currentIpv4Address: string;
123	}>;
124	}	26✔
125
126	public async sendEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {	3✔
127	if (!this.authProvider) {	129!
128	await this.sendUnauthEvents(events);	111✔
129	return;	102✔
130	}	102!
131
132	try {	18✔
133	await this.sendAuthEvents(events);	18✔
134	} catch (error) {	19!
135	if (error instanceof ApiClientError) {	11✔
136	if (error.response.status !== 401) {	2!
UNCOV 137	throw error;	×
UNCOV 138	}	×
139	}	2✔
140
141	// send unauth events if any of the following are true:
142	// 1: the token is not valid (not ApiClientError)
143	// 2: if the api responded with 401 (ApiClientError with status 401)
144	await this.sendUnauthEvents(events);	11✔
145	}	10✔
146	}	129✔
147
148	private async sendAuthEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {	3✔
149	const authHeaders = await this.authProvider?.getAuthHeaders();	18✔
150	if (!authHeaders) {	18!
151	throw new Error("No access token available");	8✔
152	}	8✔
153	const authUrl = new URL("api/private/v1.0/telemetry/events", this.options.baseUrl);	9✔
154	const response = await fetch(authUrl, {	9✔
155	method: "POST",	9✔
156	headers: {	9✔
157	...authHeaders,	9✔
158	Accept: "application/json",	9✔
159	"Content-Type": "application/json",	9✔
160	"User-Agent": this.options.userAgent,	9✔
161	},	9✔
162	body: JSON.stringify(events),	9✔
163	});	9✔
164
165	if (!response.ok) {	11!
166	throw await ApiClientError.fromResponse(response);	2✔
167	}	2✔
168	}	18✔
169
170	private async sendUnauthEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void> {	3✔
171	const headers: Record<string, string> = {	122✔
172	Accept: "application/json",	122✔
173	"Content-Type": "application/json",	122✔
174	"User-Agent": this.options.userAgent,	122✔
175	};	122✔
176
177	const unauthUrl = new URL("api/private/unauth/telemetry/events", this.options.baseUrl);	122✔
178	const response = await fetch(unauthUrl, {	122✔
179	method: "POST",	122✔
180	headers,	122✔
181	body: JSON.stringify(events),	122✔
182	});	122✔
183
184	if (!response.ok) {	121!
185	throw await ApiClientError.fromResponse(response);	1✔
186	}	1✔
187	}	122✔
188
189	// DO NOT EDIT. This is auto-generated code.
190	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
191	async listClusterDetails(options?: FetchOptions<operations["listClusterDetails"]>) {	3✔
UNCOV 192	const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);	×
UNCOV 193	if (error) {	×
UNCOV 194	throw ApiClientError.fromError(response, error);	×
UNCOV 195	}	×
UNCOV 196	return data;	×
UNCOV 197	}	×
198
199	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
200	async listGroups(options?: FetchOptions<operations["listGroups"]>) {	3✔
201	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", options);	4✔
202	if (error) {	4!
203	throw ApiClientError.fromError(response, error);	1✔
204	}	1✔
205	return data;	3✔
206	}	4✔
207
208	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
209	async createGroup(options: FetchOptions<operations["createGroup"]>) {	3✔
210	const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", options);	7✔
211	if (error) {	7!
UNCOV 212	throw ApiClientError.fromError(response, error);	×
213	}	×
214	return data;	7✔
215	}	7✔
216
217	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
218	async deleteGroup(options: FetchOptions<operations["deleteGroup"]>) {	3✔
219	const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);	7✔
220	if (error) {	7✔
221	throw ApiClientError.fromError(response, error);	2✔
222	}	2✔
223	}	7✔
224
225	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
226	async getGroup(options: FetchOptions<operations["getGroup"]>) {	3✔
227	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);	1✔
228	if (error) {	1!
UNCOV 229	throw ApiClientError.fromError(response, error);	×
UNCOV 230	}	×
231	return data;	1✔
232	}	1✔
233
234	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
235	async listAccessListEntries(options: FetchOptions<operations["listGroupAccessListEntries"]>) {	3✔
236	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);	4✔
237	if (error) {	4!
UNCOV 238	throw ApiClientError.fromError(response, error);	×
UNCOV 239	}	×
240	return data;	4✔
241	}	4✔
242
243	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
244	async createAccessListEntry(options: FetchOptions<operations["createGroupAccessListEntry"]>) {	3✔
245	const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);	18✔
246	if (error) {	18!
247	throw ApiClientError.fromError(response, error);	1✔
248	}	1!
249	return data;	17✔
250	}	18✔
251
252	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
253	async deleteAccessListEntry(options: FetchOptions<operations["deleteGroupAccessListEntry"]>) {	3✔
254	const { error, response } = await this.client.DELETE(	5✔
255	"/api/atlas/v2/groups/{groupId}/accessList/{entryValue}",	5✔
256	options	5✔
257	);	5✔
258	if (error) {	5!
259	throw ApiClientError.fromError(response, error);	×
260	}	×
261	}	5✔
262
263	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
264	async listAlerts(options: FetchOptions<operations["listGroupAlerts"]>) {	3✔
265	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/alerts", options);	1✔
266	if (error) {	1!
UNCOV 267	throw ApiClientError.fromError(response, error);	×
UNCOV 268	}	×
269	return data;	1✔
270	}	1✔
271
272	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
273	async listClusters(options: FetchOptions<operations["listGroupClusters"]>) {	3✔
274	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);	1✔
275	if (error) {	1!
UNCOV 276	throw ApiClientError.fromError(response, error);	×
UNCOV 277	}	×
278	return data;	1✔
279	}	1✔
280
281	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
282	async createCluster(options: FetchOptions<operations["createGroupCluster"]>) {	3✔
283	const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);	2✔
284	if (error) {	2!
UNCOV 285	throw ApiClientError.fromError(response, error);	×
UNCOV 286	}	×
287	return data;	2✔
288	}	2✔
289
290	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
291	async deleteCluster(options: FetchOptions<operations["deleteGroupCluster"]>) {	3✔
292	const { error, response } = await this.client.DELETE(	2✔
293	"/api/atlas/v2/groups/{groupId}/clusters/{clusterName}",	2✔
294	options	2✔
295	);	2✔
296	if (error) {	2!
297	throw ApiClientError.fromError(response, error);	×
298	}	×
299	}	2✔
300
301	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
302	async getCluster(options: FetchOptions<operations["getGroupCluster"]>) {	3✔
303	const { data, error, response } = await this.client.GET(	13✔
304	"/api/atlas/v2/groups/{groupId}/clusters/{clusterName}",	13✔
305	options	13✔
306	);	13✔
307	if (error) {	13!
UNCOV 308	throw ApiClientError.fromError(response, error);	×
UNCOV 309	}	×
310	return data;	13✔
311	}	13✔
312
313	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
314	async listDropIndexSuggestions(	3✔
UNCOV 315	options: FetchOptions<operations["listGroupClusterPerformanceAdvisorDropIndexSuggestions"]>	×
UNCOV 316	) {	×
UNCOV 317	const { data, error, response } = await this.client.GET(	×
318	"/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/dropIndexSuggestions",	×
319	options	×
UNCOV 320	);	×
UNCOV 321	if (error) {	×
UNCOV 322	throw ApiClientError.fromError(response, error);	×
UNCOV 323	}	×
UNCOV 324	return data;	×
UNCOV 325	}	×
326
327	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
328	async listSchemaAdvice(options: FetchOptions<operations["listGroupClusterPerformanceAdvisorSchemaAdvice"]>) {	3✔
329	const { data, error, response } = await this.client.GET(	×
330	"/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/schemaAdvice",	×
UNCOV 331	options	×
UNCOV 332	);	×
UNCOV 333	if (error) {	×
UNCOV 334	throw ApiClientError.fromError(response, error);	×
UNCOV 335	}	×
336	return data;	×
337	}	×
338
339	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
340	async listClusterSuggestedIndexes(	3✔
341	options: FetchOptions<operations["listGroupClusterPerformanceAdvisorSuggestedIndexes"]>	×
342	) {	×
343	const { data, error, response } = await this.client.GET(	×
344	"/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/suggestedIndexes",	×
345	options	×
346	);	×
UNCOV 347	if (error) {	×
UNCOV 348	throw ApiClientError.fromError(response, error);	×
UNCOV 349	}	×
350	return data;	×
351	}	×
352
353	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
354	async listDatabaseUsers(options: FetchOptions<operations["listGroupDatabaseUsers"]>) {	3✔
355	const { data, error, response } = await this.client.GET(	1✔
356	"/api/atlas/v2/groups/{groupId}/databaseUsers",	1✔
357	options	1✔
358	);	1✔
359	if (error) {	1!
UNCOV 360	throw ApiClientError.fromError(response, error);	×
UNCOV 361	}	×
362	return data;	1✔
363	}	1✔
364
365	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
366	async createDatabaseUser(options: FetchOptions<operations["createGroupDatabaseUser"]>) {	3✔
367	const { data, error, response } = await this.client.POST(	7✔
368	"/api/atlas/v2/groups/{groupId}/databaseUsers",	7✔
369	options	7✔
370	);	7✔
371	if (error) {	7!
372	throw ApiClientError.fromError(response, error);	×
UNCOV 373	}	×
374	return data;	7✔
375	}	7✔
376
377	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
378	async deleteDatabaseUser(options: FetchOptions<operations["deleteGroupDatabaseUser"]>) {	3✔
379	const { error, response } = await this.client.DELETE(	11✔
380	"/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}",	11✔
381	options	11✔
382	);	11✔
383	if (error) {	11✔
384	throw ApiClientError.fromError(response, error);	3✔
385	}	3✔
386	}	11✔
387
388	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
389	async listFlexClusters(options: FetchOptions<operations["listGroupFlexClusters"]>) {	3✔
UNCOV 390	const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters", options);	×
UNCOV 391	if (error) {	×
UNCOV 392	throw ApiClientError.fromError(response, error);	×
393	}	×
394	return data;	×
UNCOV 395	}	×
396
397	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
398	async createFlexCluster(options: FetchOptions<operations["createGroupFlexCluster"]>) {	3✔
UNCOV 399	const { data, error, response } = await this.client.POST(	×
UNCOV 400	"/api/atlas/v2/groups/{groupId}/flexClusters",	×
UNCOV 401	options	×
UNCOV 402	);	×
UNCOV 403	if (error) {	×
UNCOV 404	throw ApiClientError.fromError(response, error);	×
UNCOV 405	}	×
UNCOV 406	return data;	×
UNCOV 407	}	×
408
409	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
410	async deleteFlexCluster(options: FetchOptions<operations["deleteGroupFlexCluster"]>) {	3✔
411	const { error, response } = await this.client.DELETE(	×
412	"/api/atlas/v2/groups/{groupId}/flexClusters/{name}",	×
413	options	×
414	);	×
415	if (error) {	×
416	throw ApiClientError.fromError(response, error);	×
UNCOV 417	}	×
UNCOV 418	}	×
419
420	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
421	async getFlexCluster(options: FetchOptions<operations["getGroupFlexCluster"]>) {	3✔
422	const { data, error, response } = await this.client.GET(	×
423	"/api/atlas/v2/groups/{groupId}/flexClusters/{name}",	×
424	options	×
425	);	×
426	if (error) {	×
427	throw ApiClientError.fromError(response, error);	×
428	}	×
UNCOV 429	return data;	×
UNCOV 430	}	×
431
432	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
433	async listSlowQueryLogs(options: FetchOptions<operations["listGroupProcessPerformanceAdvisorSlowQueryLogs"]>) {	3✔
434	const { data, error, response } = await this.client.GET(	×
435	"/api/atlas/v2/groups/{groupId}/processes/{processId}/performanceAdvisor/slowQueryLogs",	×
436	options	×
437	);	×
438	if (error) {	×
439	throw ApiClientError.fromError(response, error);	×
UNCOV 440	}	×
UNCOV 441	return data;	×
UNCOV 442	}	×
443
444	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
445	async listOrgs(options?: FetchOptions<operations["listOrgs"]>) {	3✔
446	const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);	12!
447	if (error) {	10!
448	throw ApiClientError.fromError(response, error);	×
449	}	×
450	return data;	10✔
451	}	12✔
452
453	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
454	async getOrgGroups(options: FetchOptions<operations["getOrgGroups"]>) {	3✔
455	const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);	1✔
456	if (error) {	1!
457	throw ApiClientError.fromError(response, error);	×
458	}	×
459	return data;	1✔
460	}	1✔
461
462	// DO NOT EDIT. This is auto-generated code.
463	}	3✔

mongodb-js / mongodb-mcp-server / 20861587614

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous