@workos-inc/node 7.29.1 → 7.30.0

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,68 @@ 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);
+                        }
+                    }));
+                    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

package/lib/fga/fga.spec.js

@@ -16,6 +16,7 @@ const jest_fetch_mock_1 = __importDefault(require("jest-fetch-mock"));
 const test_utils_1 = require("../common/utils/test-utils");
 const workos_1 = require("../workos");
 const interfaces_1 = require("./interfaces");
+const exceptions_1 = require("../common/exceptions");
 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
 describe('FGA', () => {
     beforeEach(() => jest_fetch_mock_1.default.resetMocks());
@@ -46,6 +47,60 @@ describe('FGA', () => {
                 isImplicit: false,
             });
         }));
+        it('makes check request after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                result: 'authorized',
+                is_implicit: false,
+            });
+            const checkResult = yield workos.fga.check({
+                checks: [
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                ],
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/check');
+            expect(checkResult).toMatchObject({
+                result: 'authorized',
+                isImplicit: false,
+            });
+        }));
+        it('fails check request after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.check({
+                    checks: [
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'admin',
+                            },
+                            relation: 'member',
+                            subject: {
+                                resourceType: 'user',
+                                resourceId: 'user_123',
+                            },
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('createResource', () => {
         it('creates resource', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -65,6 +120,42 @@ describe('FGA', () => {
                 resourceId: 'admin',
             });
         }));
+        it('creates resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 502,
+            });
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.createResource({
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+        it('fails to creates resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.createResource({
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('creates resource with metadata', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 resource_type: 'role',
@@ -108,6 +199,38 @@ describe('FGA', () => {
                 resourceId: 'admin',
             });
         }));
+        it('gets resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 504,
+            });
+            (0, test_utils_1.fetchOnce)({
+                resource_type: 'role',
+                resource_id: 'admin',
+            });
+            const resource = yield workos.fga.getResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(resource).toMatchObject({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+        }));
+        it('fails to get resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.getResource({
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('listResources', () => {
         it('lists resources', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -140,6 +263,53 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('lists resources after two retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 502,
+            });
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: resources } = yield workos.fga.listResources();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources');
+            expect(resources).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'manager',
+                },
+            ]);
+        }));
+        it('fails to list resources after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.listResources();
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -177,6 +347,32 @@ describe('FGA', () => {
             expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
             expect(response).toBeUndefined();
         }));
+        it('should delete resource after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)();
+            const response = yield workos.fga.deleteResource({
+                resourceType: 'role',
+                resourceId: 'admin',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/role/admin');
+            expect(response).toBeUndefined();
+        }));
+        it('fails to delete resource after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.deleteResource({
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('batchWriteResources', () => {
         it('batch create resources', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -244,6 +440,110 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('batch create resources after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        meta: {
+                            description: 'The admin role',
+                        },
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'manager',
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'employee',
+                    },
+                ],
+            });
+            const createdResources = yield workos.fga.batchWriteResources({
+                op: interfaces_1.ResourceOp.Create,
+                resources: [
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        meta: {
+                            description: 'The admin role',
+                        },
+                    },
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'manager',
+                        },
+                    },
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'employee',
+                        },
+                    },
+                ],
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/resources/batch');
+            expect(createdResources).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    meta: {
+                        description: 'The admin role',
+                    },
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'manager',
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'employee',
+                },
+            ]);
+        }));
+        it('fails to batch create resources after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.batchWriteResources({
+                    op: interfaces_1.ResourceOp.Create,
+                    resources: [
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'admin',
+                            },
+                            meta: {
+                                description: 'The admin role',
+                            },
+                        },
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'manager',
+                            },
+                        },
+                        {
+                            resource: {
+                                resourceType: 'role',
+                                resourceId: 'employee',
+                            },
+                        },
+                    ],
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('batch delete resources', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -365,6 +665,62 @@ describe('FGA', () => {
                 warrantToken: 'some_token',
             });
         }));
+        it('should create warrant after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.writeWarrant({
+                op: interfaces_1.WarrantOp.Create,
+                resource: {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                },
+                relation: 'member',
+                subject: {
+                    resourceType: 'user',
+                    resourceId: 'user_123',
+                },
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual({
+                op: 'create',
+                resource_type: 'role',
+                resource_id: 'admin',
+                relation: 'member',
+                subject: {
+                    resource_type: 'user',
+                    resource_id: 'user_123',
+                },
+            });
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('fails to create warrant after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.writeWarrant({
+                    op: interfaces_1.WarrantOp.Create,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('should delete warrant with delete op', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 warrant_token: 'some_token',
@@ -475,6 +831,133 @@ describe('FGA', () => {
                 warrantToken: 'some_token',
             });
         }));
+        it('should batch write warrants after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                warrant_token: 'some_token',
+            });
+            const warrantToken = yield workos.fga.batchWriteWarrants([
+                {
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Create,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                },
+                {
+                    op: interfaces_1.WarrantOp.Delete,
+                    resource: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                    },
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_125',
+                    },
+                },
+            ]);
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect((0, test_utils_1.fetchBody)()).toEqual([
+                {
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_123',
+                    },
+                },
+                {
+                    op: 'create',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_124',
+                    },
+                },
+                {
+                    op: 'delete',
+                    resource_type: 'role',
+                    resource_id: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resource_type: 'user',
+                        resource_id: 'user_125',
+                    },
+                },
+            ]);
+            expect(warrantToken).toMatchObject({
+                warrantToken: 'some_token',
+            });
+        }));
+        it('fails to batch write warrants after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.batchWriteWarrants([
+                    {
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                    {
+                        op: interfaces_1.WarrantOp.Create,
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_124',
+                        },
+                    },
+                    {
+                        op: interfaces_1.WarrantOp.Delete,
+                        resource: {
+                            resourceType: 'role',
+                            resourceId: 'admin',
+                        },
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_125',
+                        },
+                    },
+                ]);
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
     });
     describe('listWarrants', () => {
         it('should list warrants', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -529,6 +1012,72 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('should list warrants after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_123',
+                        },
+                    },
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resource_type: 'user',
+                            resource_id: 'user_124',
+                        },
+                        policy: 'region == "us"',
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: warrants } = yield workos.fga.listWarrants();
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/warrants');
+            expect(warrants).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_123',
+                    },
+                },
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    relation: 'member',
+                    subject: {
+                        resourceType: 'user',
+                        resourceId: 'user_124',
+                    },
+                    policy: 'region == "us"',
+                },
+            ]);
+        }));
+        it('fails to list warrants after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.listWarrants();
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params when filtering', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [
@@ -604,6 +1153,66 @@ describe('FGA', () => {
                 },
             ]);
         }));
+        it('makes query request after one retry', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, test_utils_1.fetchOnce)({}, {
+                status: 500,
+            });
+            (0, test_utils_1.fetchOnce)({
+                data: [
+                    {
+                        resource_type: 'role',
+                        resource_id: 'admin',
+                        warrant: {
+                            resource_type: 'role',
+                            resource_id: 'admin',
+                            relation: 'member',
+                            subject: {
+                                resource_type: 'user',
+                                resource_id: 'user_123',
+                            },
+                        },
+                        is_implicit: false,
+                    },
+                ],
+                list_metadata: {
+                    before: null,
+                    after: null,
+                },
+            });
+            const { data: queryResults } = yield workos.fga.query({
+                q: 'select role where user:user_123 is member',
+            });
+            expect((0, test_utils_1.fetchURL)()).toContain('/fga/v1/query');
+            expect(queryResults).toMatchObject([
+                {
+                    resourceType: 'role',
+                    resourceId: 'admin',
+                    warrant: {
+                        resourceType: 'role',
+                        resourceId: 'admin',
+                        relation: 'member',
+                        subject: {
+                            resourceType: 'user',
+                            resourceId: 'user_123',
+                        },
+                    },
+                    isImplicit: false,
+                },
+            ]);
+        }));
+        it('fails to make query after max retries', () => __awaiter(void 0, void 0, void 0, function* () {
+            jest_fetch_mock_1.default.mockResponse(JSON.stringify({
+                message: 'Internal Server Error',
+            }), { status: 500 });
+            try {
+                yield workos.fga.query({
+                    q: 'select role where user:user_123 is member',
+                });
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(exceptions_1.GenericServerException);
+            }
+        }), 8000);
         it('sends correct params and options', () => __awaiter(void 0, void 0, void 0, function* () {
             (0, test_utils_1.fetchOnce)({
                 data: [

package/lib/workos.js

@@ -27,7 +27,7 @@ const bad_request_exception_1 = require("./common/exceptions/bad-request.excepti
 const http_client_1 = require("./common/net/http-client");
 const subtle_crypto_provider_1 = require("./common/crypto/subtle-crypto-provider");
 const fetch_client_1 = require("./common/net/fetch-client");
-const VERSION = '7.29.1';
+const VERSION = '7.30.0';
 const DEFAULT_HOSTNAME = 'api.workos.com';
 const HEADER_AUTHORIZATION = 'Authorization';
 const HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "7.29.1",
+  "version": "7.30.0",
   "name": "@workos-inc/node",
   "author": "WorkOS",
   "description": "A Node wrapper for the WorkOS API",