fix: ApiClientError constructor

fmenezes · fmenezes · commit 7ea9854c85d9 · 2025-04-30T18:28:42.000+01:00
diff --git a/scripts/apply.ts b/scripts/apply.ts
@@ -95,7 +95,7 @@ async function main() {
             return `async ${operationId}(options${requiredParams ? "" : "?"}: FetchOptions<operations["${operationId}"]>) {
     const { ${hasResponseBody ? `data, ` : ``}error, response } = await this.client.${method}("${path}", options);
     if (error) {
-        throw new ApiClientError("error calling Atlas API", response, error);
+        throw ApiClientError.fromApiError(response, error);
     }
     ${
         hasResponseBody
diff --git a/src/common/atlas/apiClient.ts b/src/common/atlas/apiClient.ts
@@ -144,54 +144,54 @@ export class ApiClient {
     async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {
         const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
@@ -202,22 +202,22 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
     }
 
     async listClusters(options: FetchOptions<operations["listClusters"]>) {
         const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
@@ -228,7 +228,7 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
     }
 
@@ -238,7 +238,7 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
@@ -249,7 +249,7 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
@@ -260,7 +260,7 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
@@ -271,22 +271,22 @@ export class ApiClient {
             options
         );
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
     }
 
     async listOrganizations(options?: FetchOptions<operations["listOrganizations"]>) {
         const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);
         if (error) {
-            throw new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(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 new ApiClientError("error calling Atlas API", response, error);
+            throw ApiClientError.fromApiError(response, error);
         }
         return data;
     }
diff --git a/src/common/atlas/apiClientError.ts b/src/common/atlas/apiClientError.ts
@@ -1,15 +1,24 @@
 import { ApiError } from "./openapi.js";
 
 export class ApiClientError extends Error {
-    constructor(
+    private constructor(
         message: string,
-        public readonly response?: Response,
-        public readonly body?: ApiError
+        public readonly apiError?: ApiError
     ) {
         super(message);
         this.name = "ApiClientError";
     }
 
+    static fromApiError(
+        response: Response,
+        apiError: ApiError,
+        message: string = `error calling Atlas API`
+    ): ApiClientError {
+        const errorMessage = this.buildErrorMessage(apiError);
+
+        return new ApiClientError(`[${response.status} ${response.statusText}] ${message}: ${errorMessage}`, apiError);
+    }
+
     static async fromResponse(
         response: Response,
         message: string = `error calling Atlas API`
@@ -20,11 +29,7 @@ export class ApiClientError extends Error {
 
         const body = err && typeof err === "object" ? err : undefined;
 
-        return new ApiClientError(
-            `[${response.status} ${response.statusText}] ${message}: ${errorMessage}`,
-            response,
-            body
-        );
+        return new ApiClientError(`[${response.status} ${response.statusText}] ${message}: ${errorMessage}`, body);
     }
 
     private static async extractError(response: Response): Promise<ApiError | string | undefined> {

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ async function main() {`
`95`	`95`	return `async ${operationId}(options${requiredParams ? "" : "?"}: FetchOptions<operations["${operationId}"]>) {
`96`	`96`	const { ${hasResponseBody ? `data, ` : ``}error, response } = await this.client.${method}("${path}", options);
`97`	`97`	`if (error) {`
`98`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`98`	`+ throw ApiClientError.fromApiError(response, error);`
`99`	`99`	`}`
`100`	`100`	`${`
`101`	`101`	`hasResponseBody`
Original file line number	Diff line number	Diff line change
`@@ -144,54 +144,54 @@ export class ApiClient {`
`144`	`144`	`async listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>) {`
`145`	`145`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);`
`146`	`146`	`if (error) {`
`147`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`147`	`+ throw ApiClientError.fromApiError(response, error);`
`148`	`148`	`}`
`149`	`149`	`return data;`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`async listProjects(options?: FetchOptions<operations["listProjects"]>) {`
`153`	`153`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", options);`
`154`	`154`	`if (error) {`
`155`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`155`	`+ throw ApiClientError.fromApiError(response, error);`
`156`	`156`	`}`
`157`	`157`	`return data;`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`async createProject(options: FetchOptions<operations["createProject"]>) {`
`161`	`161`	`const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", options);`
`162`	`162`	`if (error) {`
`163`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`163`	`+ throw ApiClientError.fromApiError(response, error);`
`164`	`164`	`}`
`165`	`165`	`return data;`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`async deleteProject(options: FetchOptions<operations["deleteProject"]>) {`
`169`	`169`	`const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);`
`170`	`170`	`if (error) {`
`171`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`171`	`+ throw ApiClientError.fromApiError(response, error);`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`async getProject(options: FetchOptions<operations["getProject"]>) {`
`176`	`176`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);`
`177`	`177`	`if (error) {`
`178`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`178`	`+ throw ApiClientError.fromApiError(response, error);`
`179`	`179`	`}`
`180`	`180`	`return data;`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`async listProjectIpAccessLists(options: FetchOptions<operations["listProjectIpAccessLists"]>) {`
`184`	`184`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);`
`185`	`185`	`if (error) {`
`186`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`186`	`+ throw ApiClientError.fromApiError(response, error);`
`187`	`187`	`}`
`188`	`188`	`return data;`
`189`	`189`	`}`
`190`	`190`
`191`	`191`	`async createProjectIpAccessList(options: FetchOptions<operations["createProjectIpAccessList"]>) {`
`192`	`192`	`const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);`
`193`	`193`	`if (error) {`
`194`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`194`	`+ throw ApiClientError.fromApiError(response, error);`
`195`	`195`	`}`
`196`	`196`	`return data;`
`197`	`197`	`}`
`@@ -202,22 +202,22 @@ export class ApiClient {`
`202`	`202`	`options`
`203`	`203`	`);`
`204`	`204`	`if (error) {`
`205`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`205`	`+ throw ApiClientError.fromApiError(response, error);`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`async listClusters(options: FetchOptions<operations["listClusters"]>) {`
`210`	`210`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);`
`211`	`211`	`if (error) {`
`212`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`212`	`+ throw ApiClientError.fromApiError(response, error);`
`213`	`213`	`}`
`214`	`214`	`return data;`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`async createCluster(options: FetchOptions<operations["createCluster"]>) {`
`218`	`218`	`const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);`
`219`	`219`	`if (error) {`
`220`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`220`	`+ throw ApiClientError.fromApiError(response, error);`
`221`	`221`	`}`
`222`	`222`	`return data;`
`223`	`223`	`}`
`@@ -228,7 +228,7 @@ export class ApiClient {`
`228`	`228`	`options`
`229`	`229`	`);`
`230`	`230`	`if (error) {`
`231`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`231`	`+ throw ApiClientError.fromApiError(response, error);`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -238,7 +238,7 @@ export class ApiClient {`
`238`	`238`	`options`
`239`	`239`	`);`
`240`	`240`	`if (error) {`
`241`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`241`	`+ throw ApiClientError.fromApiError(response, error);`
`242`	`242`	`}`
`243`	`243`	`return data;`
`244`	`244`	`}`
`@@ -249,7 +249,7 @@ export class ApiClient {`
`249`	`249`	`options`
`250`	`250`	`);`
`251`	`251`	`if (error) {`
`252`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`252`	`+ throw ApiClientError.fromApiError(response, error);`
`253`	`253`	`}`
`254`	`254`	`return data;`
`255`	`255`	`}`
`@@ -260,7 +260,7 @@ export class ApiClient {`
`260`	`260`	`options`
`261`	`261`	`);`
`262`	`262`	`if (error) {`
`263`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`263`	`+ throw ApiClientError.fromApiError(response, error);`
`264`	`264`	`}`
`265`	`265`	`return data;`
`266`	`266`	`}`
`@@ -271,22 +271,22 @@ export class ApiClient {`
`271`	`271`	`options`
`272`	`272`	`);`
`273`	`273`	`if (error) {`
`274`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`274`	`+ throw ApiClientError.fromApiError(response, error);`
`275`	`275`	`}`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`async listOrganizations(options?: FetchOptions<operations["listOrganizations"]>) {`
`279`	`279`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);`
`280`	`280`	`if (error) {`
`281`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`281`	`+ throw ApiClientError.fromApiError(response, error);`
`282`	`282`	`}`
`283`	`283`	`return data;`
`284`	`284`	`}`
`285`	`285`
`286`	`286`	`async listOrganizationProjects(options: FetchOptions<operations["listOrganizationProjects"]>) {`
`287`	`287`	`const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);`
`288`	`288`	`if (error) {`
`289`		`- throw new ApiClientError("error calling Atlas API", response, error);`
	`289`	`+ throw ApiClientError.fromApiError(response, error);`
`290`	`290`	`}`
`291`	`291`	`return data;`
`292`	`292`	`}`