@workos-inc/node 8.0.0-beta.2 → 8.0.0-beta.3

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

@@ -1,100 +1,87 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientError = exports.HttpClientResponse = exports.HttpClient = void 0;
 class HttpClient {
-  constructor(baseURL, options) {
-    this.baseURL = baseURL;
-    this.options = options;
-  }
-  static {
-    __name(this, "HttpClient");
-  }
-  MAX_RETRY_ATTEMPTS = 3;
-  BACKOFF_MULTIPLIER = 1.5;
-  MINIMUM_SLEEP_TIME_IN_MILLISECONDS = 500;
-  RETRY_STATUS_CODES = [500, 502, 504];
-  /** The HTTP client name used for diagnostics */
-  getClientName() {
-    throw new Error("getClientName not implemented");
-  }
-  addClientToUserAgent(userAgent) {
-    if (userAgent.indexOf(" ") > -1) {
-      return userAgent.replace(/\b\s/, `/${this.getClientName()} `);
-    } else {
-      return userAgent += `/${this.getClientName()}`;
+    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)));
     }
-  }
-  static getResourceURL(baseURL, path, params) {
-    const queryString = HttpClient.getQueryString(params);
-    const url = new URL([path, queryString].filter(Boolean).join("?"), baseURL);
-    return url.toString();
-  }
-  static getQueryString(queryObj) {
-    if (!queryObj) return void 0;
-    const sanitizedQueryObj = {};
-    Object.entries(queryObj).forEach(([param, value]) => {
-      if (value !== "" && value !== void 0) sanitizedQueryObj[param] = value;
-    });
-    return new URLSearchParams(sanitizedQueryObj).toString();
-  }
-  static getContentTypeHeader(entity) {
-    if (entity instanceof URLSearchParams) {
-      return {
-        "Content-Type": "application/x-www-form-urlencoded;charset=utf-8"
-      };
+    /** The HTTP client name used for diagnostics */
+    getClientName() {
+        throw new Error('getClientName not implemented');
     }
-    return void 0;
-  }
-  static getBody(entity) {
-    if (entity === null || entity instanceof URLSearchParams) {
-      return entity;
+    addClientToUserAgent(userAgent) {
+        if (userAgent.indexOf(' ') > -1) {
+            return userAgent.replace(/\b\s/, `/${this.getClientName()} `);
+        }
+        else {
+            return (userAgent += `/${this.getClientName()}`);
+        }
+    }
+    static getResourceURL(baseURL, path, params) {
+        const queryString = HttpClient.getQueryString(params);
+        const url = new URL([path, queryString].filter(Boolean).join('?'), baseURL);
+        return url.toString();
+    }
+    static getQueryString(queryObj) {
+        if (!queryObj)
+            return undefined;
+        const sanitizedQueryObj = {};
+        Object.entries(queryObj).forEach(([param, value]) => {
+            if (value !== '' && value !== undefined)
+                sanitizedQueryObj[param] = value;
+        });
+        return new URLSearchParams(sanitizedQueryObj).toString();
+    }
+    static getContentTypeHeader(entity) {
+        if (entity instanceof URLSearchParams) {
+            return {
+                'Content-Type': 'application/x-www-form-urlencoded;charset=utf-8',
+            };
+        }
+        return undefined;
+    }
+    static getBody(entity) {
+        if (entity === null || entity instanceof URLSearchParams) {
+            return entity;
+        }
+        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;
     }
-    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;
-  }
-  sleep = /* @__PURE__ */ __name((retryAttempt) => new Promise(
-    (resolve) => setTimeout(resolve, this.getSleepTimeInMilliseconds(retryAttempt))
-  ), "sleep");
 }
+exports.HttpClient = HttpClient;
+// tslint:disable-next-line
 class HttpClientResponse {
-  static {
-    __name(this, "HttpClientResponse");
-  }
-  _statusCode;
-  _headers;
-  constructor(statusCode, headers) {
-    this._statusCode = statusCode;
-    this._headers = headers;
-  }
-  getStatusCode() {
-    return this._statusCode;
-  }
-  getHeaders() {
-    return this._headers;
-  }
+    constructor(statusCode, headers) {
+        this._statusCode = statusCode;
+        this._headers = headers;
+    }
+    getStatusCode() {
+        return this._statusCode;
+    }
+    getHeaders() {
+        return this._headers;
+    }
 }
+exports.HttpClientResponse = HttpClientResponse;
+// tslint:disable-next-line
 class HttpClientError extends Error {
-  static {
-    __name(this, "HttpClientError");
-  }
-  name = "HttpClientError";
-  message = "The request could not be completed.";
-  response;
-  constructor({
-    message,
-    response
-  }) {
-    super(message);
-    this.message = message;
-    this.response = response;
-  }
+    constructor({ message, response, }) {
+        super(message);
+        this.name = 'HttpClientError';
+        this.message = 'The request could not be completed.';
+        this.message = message;
+        this.response = response;
+    }
 }
-export {
-  HttpClient,
-  HttpClientError,
-  HttpClientResponse
-};
-//# sourceMappingURL=http-client.js.map
+exports.HttpClientError = HttpClientError;

package/lib/common/net/index.d.ts

@@ -0,0 +1,5 @@
+import { HttpClient } from './http-client';
+export declare function createHttpClient(baseURL: string, options: RequestInit, fetchFn?: typeof fetch): HttpClient;
+export * from './fetch-client';
+export * from './node-client';
+export * from './http-client';

package/lib/common/net/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpClient = void 0;
+const fetch_client_1 = require("./fetch-client");
+const node_client_1 = require("./node-client");
+function createHttpClient(baseURL, options, fetchFn) {
+    if (typeof fetch !== 'undefined' || typeof fetchFn !== 'undefined') {
+        return new fetch_client_1.FetchHttpClient(baseURL, options, fetchFn);
+    }
+    else {
+        return new node_client_1.NodeHttpClient(baseURL, options);
+    }
+}
+exports.createHttpClient = createHttpClient;
+__exportStar(require("./fetch-client"), exports);
+__exportStar(require("./node-client"), exports);
+__exportStar(require("./http-client"), exports);

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

@@ -0,0 +1,25 @@
+import { HttpClient, HttpClientResponse } from './http-client';
+import { HttpClientInterface, HttpClientResponseInterface, RequestOptions } from '../interfaces/http-client.interface';
+import * as http_ from 'node:http';
+export declare class NodeHttpClient extends HttpClient implements HttpClientInterface {
+    readonly baseURL: string;
+    readonly options?: RequestInit | undefined;
+    private httpAgent;
+    private httpsAgent;
+    constructor(baseURL: string, options?: RequestInit | undefined);
+    getClientName(): string;
+    static getBody(entity: unknown): string | null;
+    get(path: string, options: RequestOptions): Promise<HttpClientResponseInterface>;
+    post<Entity = any>(path: string, entity: Entity, options: RequestOptions): Promise<HttpClientResponseInterface>;
+    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;
+    constructor(res: http_.IncomingMessage);
+    getRawResponse(): http_.IncomingMessage;
+    toJSON(): Promise<any> | any;
+}

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

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeHttpClientResponse = exports.NodeHttpClient = void 0;
+const http_client_1 = require("./http-client");
+const http_ = __importStar(require("node:http"));
+const https_ = __importStar(require("node:https"));
+// `import * as http_ from 'http'` creates a "Module Namespace Exotic Object"
+// which is immune to monkey-patching, whereas http_.default (in an ES Module context)
+// will resolve to the same thing as require('http'), which is
+// monkey-patchable. We care about this because users in their test
+// suites might be using a library like "nock" which relies on the ability
+// to monkey-patch and intercept calls to http.request.
+const http = http_.default || http_;
+const https = https_.default || https_;
+class NodeHttpClient extends http_client_1.HttpClient {
+    constructor(baseURL, options) {
+        super(baseURL, options);
+        this.baseURL = baseURL;
+        this.options = options;
+        this.httpAgent = new http.Agent({ keepAlive: true });
+        this.httpsAgent = new https.Agent({ keepAlive: true });
+    }
+    getClientName() {
+        return 'node';
+    }
+    static getBody(entity) {
+        if (entity === null || entity === undefined) {
+            return null;
+        }
+        if (entity instanceof URLSearchParams) {
+            return entity.toString();
+        }
+        return JSON.stringify(entity);
+    }
+    get(path, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resourceURL = http_client_1.HttpClient.getResourceURL(this.baseURL, path, options.params);
+            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);
+            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);
+            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);
+            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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a, _b;
+                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,
+                };
+                const req = lib.request(url, options, (res) => __awaiter(this, void 0, void 0, function* () {
+                    const clientResponse = new NodeHttpClientResponse(res);
+                    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(clientResponse);
+                }));
+                req.on('error', (err) => {
+                    reject(new Error(err.message));
+                });
+                if (body) {
+                    req.setHeader('Content-Length', Buffer.byteLength(body));
+                    req.write(body);
+                }
+                req.end();
+            });
+        });
+    }
+    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
+class NodeHttpClientResponse extends http_client_1.HttpClientResponse {
+    constructor(res) {
+        // @ts-ignore
+        super(res.statusCode, res.headers || {});
+        this._res = res;
+    }
+    getRawResponse() {
+        return this._res;
+    }
+    toJSON() {
+        return new Promise((resolve, reject) => {
+            const contentType = this._res.headers['content-type'];
+            const isJsonResponse = contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json');
+            if (!isJsonResponse) {
+                resolve(null);
+            }
+            let response = '';
+            this._res.setEncoding('utf8');
+            this._res.on('data', (chunk) => {
+                response += chunk;
+            });
+            this._res.once('end', () => {
+                try {
+                    resolve(JSON.parse(response));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+    }
+}
+exports.NodeHttpClientResponse = NodeHttpClientResponse;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,140 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const node_client_1 = require("./node-client");
+const nodeClient = new node_client_1.NodeHttpClient('https://test.workos.com', {
+    headers: {
+        Authorization: `Bearer sk_test`,
+        'User-Agent': 'test-node-client',
+    },
+});
+describe('Node client', () => {
+    beforeEach(() => nock_1.default.cleanAll());
+    it('get for FGA path should call nodeRequestWithRetry and return response', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockNodeRequestWithRetry = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'nodeRequestWithRetry');
+        const response = yield nodeClient.get('/fga/v1/resources', {});
+        expect(mockNodeRequestWithRetry).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('post for FGA path should call nodeRequestWithRetry and return response', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .post('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockNodeRequestWithRetry = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'nodeRequestWithRetry');
+        const response = yield nodeClient.post('/fga/v1/resources', {}, {});
+        expect(mockNodeRequestWithRetry).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('put for FGA path should call nodeRequestWithRetry and return response', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .put('/fga/v1/resources/user/user-1')
+            .reply(200, { data: 'response' });
+        const mockNodeRequestWithRetry = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'nodeRequestWithRetry');
+        const response = yield nodeClient.put('/fga/v1/resources/user/user-1', {}, {});
+        expect(mockNodeRequestWithRetry).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('delete for FGA path should call nodeRequestWithRetry and return response', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .delete('/fga/v1/resources/user/user-1')
+            .reply(200, { data: 'response' });
+        const mockNodeRequestWithRetry = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'nodeRequestWithRetry');
+        const response = yield nodeClient.delete('/fga/v1/resources/user/user-1', {});
+        expect(mockNodeRequestWithRetry).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('should retry request on 500 status code', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .reply(500)
+            .get('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        const mockSleep = jest.spyOn(nodeClient, 'sleep');
+        mockSleep.mockImplementation(() => Promise.resolve());
+        const response = yield nodeClient.get('/fga/v1/resources', {});
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(2);
+        expect(mockSleep).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('should retry request on 502 status code', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .reply(502)
+            .get('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        const mockSleep = jest.spyOn(nodeClient, 'sleep');
+        mockSleep.mockImplementation(() => Promise.resolve());
+        const response = yield nodeClient.get('/fga/v1/resources', {});
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(2);
+        expect(mockSleep).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('should retry request on 504 status code', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .reply(504)
+            .get('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        const mockSleep = jest.spyOn(nodeClient, 'sleep');
+        mockSleep.mockImplementation(() => Promise.resolve());
+        const response = yield nodeClient.get('/fga/v1/resources', {});
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(2);
+        expect(mockSleep).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+    it('should retry request up to 3 times on retryable status code', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .reply(504)
+            .get('/fga/v1/resources')
+            .reply(502)
+            .get('/fga/v1/resources')
+            .reply(500)
+            .get('/fga/v1/resources')
+            .reply(500);
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        const mockSleep = jest.spyOn(nodeClient, 'sleep');
+        mockSleep.mockImplementation(() => Promise.resolve());
+        yield expect(nodeClient.get('/fga/v1/resources', {})).rejects.toThrowError();
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(4);
+        expect(mockSleep).toHaveBeenCalledTimes(3);
+    }));
+    it('should not retry request on non-retryable status code', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com').get('/fga/v1/resources').reply(400);
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        yield expect(nodeClient.get('/fga/v1/resources', {})).rejects.toThrowError();
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(1);
+    }));
+    it('should retry request on TypeError', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('https://test.workos.com')
+            .get('/fga/v1/resources')
+            .replyWithError(new TypeError('Network request failed'))
+            .get('/fga/v1/resources')
+            .reply(200, { data: 'response' });
+        const mockShouldRetryRequest = jest.spyOn(node_client_1.NodeHttpClient.prototype, 'shouldRetryRequest');
+        const mockSleep = jest.spyOn(nodeClient, 'sleep');
+        mockSleep.mockImplementation(() => Promise.resolve());
+        const response = yield nodeClient.get('/fga/v1/resources', {});
+        expect(mockShouldRetryRequest).toHaveBeenCalledTimes(1);
+        expect(mockSleep).toHaveBeenCalledTimes(1);
+        expect(yield response.toJSON()).toEqual({ data: 'response' });
+    }));
+});

package/lib/common/serializers/event.serializer.cjs

@@ -165,6 +165,7 @@ const deserializeEvent = /* @__PURE__ */ __name((event) => {
         data: (0, import_role.deserializeRoleEvent)(event.data)
       };
     case "session.created":
+    case "session.revoked":
       return {
         ...eventBase,
         event: event.event,