@workos-inc/node 7.29.1 → 7.30.1

package/lib/common/net/fetch-client.d.ts

@@ -12,6 +12,8 @@ export declare class FetchHttpClient extends HttpClient implements HttpClientInt
     put<Entity = any>(path: string, entity: Entity, options: RequestOptions): Promise<HttpClientResponseInterface>;
     delete(path: string, options: RequestOptions): Promise<HttpClientResponseInterface>;
     private fetchRequest;
+    private fetchRequestWithRetry;
+    private shouldRetryRequest;
 }
 export declare class FetchHttpClientResponse extends HttpClientResponse implements HttpClientResponseInterface {
     _res: Response;

package/lib/common/net/fetch-client.js

@@ -32,25 +32,45 @@ class FetchHttpClient extends http_client_1.HttpClient {
     get(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.fetchRequest(resourceURL, 'GET', null, options.headers);
+            if (path.startsWith('/fga/')) {
+                return yield this.fetchRequestWithRetry(resourceURL, 'GET', null, options.headers);
+            }
+            else {
+                return yield this.fetchRequest(resourceURL, 'GET', null, options.headers);
+            }
         });
     }
     post(path, entity, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.fetchRequest(resourceURL, 'POST', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            if (path.startsWith('/fga/')) {
+                return yield this.fetchRequestWithRetry(resourceURL, 'POST', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
+            else {
+                return yield this.fetchRequest(resourceURL, 'POST', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
         });
     }
     put(path, entity, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.fetchRequest(resourceURL, 'PUT', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            if (path.startsWith('/fga/')) {
+                return yield this.fetchRequestWithRetry(resourceURL, 'PUT', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
+            else {
+                return yield this.fetchRequest(resourceURL, 'PUT', http_client_1.HttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
         });
     }
     delete(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.fetchRequest(resourceURL, 'DELETE', null, options.headers);
+            if (path.startsWith('/fga/')) {
+                return yield this.fetchRequestWithRetry(resourceURL, 'DELETE', null, options.headers);
+            }
+            else {
+                return yield this.fetchRequest(resourceURL, 'DELETE', null, options.headers);
+            }
         });
     }
     fetchRequest(url, method, body, headers) {
@@ -80,6 +100,46 @@ class FetchHttpClient extends http_client_1.HttpClient {
             return new FetchHttpClientResponse(res);
         });
     }
+    fetchRequestWithRetry(url, method, body, headers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let response;
+            let retryAttempts = 1;
+            const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+                let requestError = null;
+                try {
+                    response = yield this.fetchRequest(url, method, body, headers);
+                }
+                catch (e) {
+                    requestError = e;
+                }
+                if (this.shouldRetryRequest(requestError, retryAttempts)) {
+                    retryAttempts++;
+                    yield this.sleep(retryAttempts);
+                    return makeRequest();
+                }
+                if (requestError != null) {
+                    throw requestError;
+                }
+                return response;
+            });
+            return makeRequest();
+        });
+    }
+    shouldRetryRequest(requestError, retryAttempt) {
+        if (retryAttempt > this.MAX_RETRY_ATTEMPTS) {
+            return false;
+        }
+        if (requestError != null) {
+            if (requestError instanceof TypeError) {
+                return true;
+            }
+            if (requestError instanceof http_client_1.HttpClientError &&
+                this.RETRY_STATUS_CODES.includes(requestError.response.status)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 exports.FetchHttpClient = FetchHttpClient;
 // tslint:disable-next-line

package/lib/common/net/http-client.d.ts

@@ -2,6 +2,10 @@ import { HttpClientInterface, HttpClientResponseInterface, RequestHeaders, Reque
 export declare abstract class HttpClient implements HttpClientInterface {
     readonly baseURL: string;
     readonly options?: RequestInit | undefined;
+    readonly MAX_RETRY_ATTEMPTS = 3;
+    readonly BACKOFF_MULTIPLIER = 1.5;
+    readonly MINIMUM_SLEEP_TIME_IN_MILLISECONDS = 500;
+    readonly RETRY_STATUS_CODES: number[];
     constructor(baseURL: string, options?: RequestInit | undefined);
     /** The HTTP client name used for diagnostics */
     getClientName(): string;
@@ -14,6 +18,8 @@ export declare abstract class HttpClient implements HttpClientInterface {
     static getQueryString(queryObj?: Record<string, any>): string | undefined;
     static getContentTypeHeader(entity: any): RequestHeaders | undefined;
     static getBody(entity: any): BodyInit | null | undefined;
+    private getSleepTimeInMilliseconds;
+    sleep: (retryAttempt: number) => Promise<unknown>;
 }
 export declare abstract class HttpClientResponse implements HttpClientResponseInterface {
     _statusCode: number;

package/lib/common/net/http-client.js

@@ -5,6 +5,11 @@ class HttpClient {
     constructor(baseURL, options) {
         this.baseURL = baseURL;
         this.options = options;
+        this.MAX_RETRY_ATTEMPTS = 3;
+        this.BACKOFF_MULTIPLIER = 1.5;
+        this.MINIMUM_SLEEP_TIME_IN_MILLISECONDS = 500;
+        this.RETRY_STATUS_CODES = [500, 502, 504];
+        this.sleep = (retryAttempt) => new Promise((resolve) => setTimeout(resolve, this.getSleepTimeInMilliseconds(retryAttempt)));
     }
     /** The HTTP client name used for diagnostics */
     getClientName() {
@@ -47,6 +52,12 @@ class HttpClient {
         }
         return JSON.stringify(entity);
     }
+    getSleepTimeInMilliseconds(retryAttempt) {
+        const sleepTime = this.MINIMUM_SLEEP_TIME_IN_MILLISECONDS *
+            Math.pow(this.BACKOFF_MULTIPLIER, retryAttempt);
+        const jitter = Math.random() + 0.5;
+        return sleepTime * jitter;
+    }
 }
 exports.HttpClient = HttpClient;
 // tslint:disable-next-line

package/lib/common/net/node-client.d.ts

@@ -14,6 +14,8 @@ export declare class NodeHttpClient extends HttpClient implements HttpClientInte
     put<Entity = any>(path: string, entity: Entity, options: RequestOptions): Promise<HttpClientResponseInterface>;
     delete(path: string, options: RequestOptions): Promise<HttpClientResponseInterface>;
     private nodeRequest;
+    private nodeRequestWithRetry;
+    private shouldRetryRequest;
 }
 export declare class NodeHttpClientResponse extends HttpClientResponse implements HttpClientResponseInterface {
     _res: http_.IncomingMessage;

package/lib/common/net/node-client.js

@@ -67,25 +67,45 @@ class NodeHttpClient extends http_client_1.HttpClient {
     get(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.nodeRequest(resourceURL, 'GET', null, options.headers);
+            if (path.startsWith('/fga/')) {
+                return yield this.nodeRequestWithRetry(resourceURL, 'GET', null, options.headers);
+            }
+            else {
+                return yield this.nodeRequest(resourceURL, 'GET', null, options.headers);
+            }
         });
     }
     post(path, entity, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.nodeRequest(resourceURL, 'POST', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            if (path.startsWith('/fga/')) {
+                return yield this.nodeRequestWithRetry(resourceURL, 'POST', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
+            else {
+                return yield this.nodeRequest(resourceURL, 'POST', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
         });
     }
     put(path, entity, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.nodeRequest(resourceURL, 'PUT', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            if (path.startsWith('/fga/')) {
+                return yield this.nodeRequestWithRetry(resourceURL, 'PUT', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
+            else {
+                return yield this.nodeRequest(resourceURL, 'PUT', NodeHttpClient.getBody(entity), Object.assign(Object.assign({}, http_client_1.HttpClient.getContentTypeHeader(entity)), options.headers));
+            }
         });
     }
     delete(path, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
-            return yield this.nodeRequest(resourceURL, 'DELETE', null, options.headers);
+            if (path.startsWith('/fga/')) {
+                return yield this.nodeRequestWithRetry(resourceURL, 'DELETE', null, options.headers);
+            }
+            else {
+                return yield this.nodeRequest(resourceURL, 'DELETE', null, options.headers);
+            }
         });
     }
     nodeRequest(url, method, body, headers) {
@@ -126,6 +146,69 @@ class NodeHttpClient extends http_client_1.HttpClient {
             });
         });
     }
+    nodeRequestWithRetry(url, method, body, headers) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSecureConnection = url.startsWith('https');
+            const agent = isSecureConnection ? this.httpsAgent : this.httpAgent;
+            const lib = isSecureConnection ? https : http;
+            const { 'User-Agent': userAgent } = (_a = this.options) === null || _a === void 0 ? void 0 : _a.headers;
+            const options = {
+                method,
+                headers: Object.assign(Object.assign(Object.assign({ Accept: 'application/json, text/plain, */*', 'Content-Type': 'application/json' }, (_b = this.options) === null || _b === void 0 ? void 0 : _b.headers), headers), { 'User-Agent': this.addClientToUserAgent(userAgent.toString()) }),
+                agent,
+            };
+            let retryAttempts = 1;
+            const makeRequest = () => __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    const req = lib.request(url, options, (res) => __awaiter(this, void 0, void 0, function* () {
+                        const clientResponse = new NodeHttpClientResponse(res);
+                        if (this.shouldRetryRequest(res, retryAttempts)) {
+                            retryAttempts++;
+                            yield this.sleep(retryAttempts);
+                            return makeRequest().then(resolve).catch(reject);
+                        }
+                        if (res.statusCode &&
+                            (res.statusCode < 200 || res.statusCode > 299)) {
+                            reject(new http_client_1.HttpClientError({
+                                message: res.statusMessage,
+                                response: {
+                                    status: res.statusCode,
+                                    headers: res.headers,
+                                    data: yield clientResponse.toJSON(),
+                                },
+                            }));
+                        }
+                        resolve(new NodeHttpClientResponse(res));
+                    }));
+                    req.on('error', (err) => __awaiter(this, void 0, void 0, function* () {
+                        if (err != null && err instanceof TypeError) {
+                            retryAttempts++;
+                            yield this.sleep(retryAttempts);
+                            return makeRequest().then(resolve).catch(reject);
+                        }
+                        reject(new Error(err.message));
+                    }));
+                    if (body) {
+                        req.setHeader('Content-Length', Buffer.byteLength(body));
+                        req.write(body);
+                    }
+                    req.end();
+                });
+            });
+            return makeRequest();
+        });
+    }
+    shouldRetryRequest(response, retryAttempt) {
+        if (retryAttempt > this.MAX_RETRY_ATTEMPTS) {
+            return false;
+        }
+        if (response != null &&
+            this.RETRY_STATUS_CODES.includes(response.statusCode)) {
+            return true;
+        }
+        return false;
+    }
 }
 exports.NodeHttpClient = NodeHttpClient;
 // tslint:disable-next-line