@workos-inc/node 5.2.0 → 6.0.0-rc.2

package/lib/webhooks/webhooks.js

@@ -1,32 +1,41 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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.Webhooks = void 0;
-const crypto_1 = __importDefault(require("crypto"));
 const exceptions_1 = require("../common/exceptions");
 const serializers_1 = require("../common/serializers");
 class Webhooks {
     constructEvent({ payload, sigHeader, secret, tolerance = 180000, }) {
-        const options = { payload, sigHeader, secret, tolerance };
-        this.verifyHeader(options);
-        const webhookPayload = payload;
-        return (0, serializers_1.deserializeEvent)(webhookPayload);
+        return __awaiter(this, void 0, void 0, function* () {
+            const options = { payload, sigHeader, secret, tolerance };
+            yield this.verifyHeader(options);
+            const webhookPayload = payload;
+            return (0, serializers_1.deserializeEvent)(webhookPayload);
+        });
     }
     verifyHeader({ payload, sigHeader, secret, tolerance = 180000, }) {
-        const [timestamp, signatureHash] = this.getTimestampAndSignatureHash(sigHeader);
-        if (!signatureHash || Object.keys(signatureHash).length === 0) {
-            throw new exceptions_1.SignatureVerificationException('No signature hash found with expected scheme v1');
-        }
-        if (parseInt(timestamp, 10) < Date.now() - tolerance) {
-            throw new exceptions_1.SignatureVerificationException('Timestamp outside the tolerance zone');
-        }
-        const expectedSig = this.computeSignature(timestamp, payload, secret);
-        if (this.secureCompare(expectedSig, signatureHash) === false) {
-            throw new exceptions_1.SignatureVerificationException('Signature hash does not match the expected signature hash for payload');
-        }
-        return true;
+        return __awaiter(this, void 0, void 0, function* () {
+            const [timestamp, signatureHash] = this.getTimestampAndSignatureHash(sigHeader);
+            if (!signatureHash || Object.keys(signatureHash).length === 0) {
+                throw new exceptions_1.SignatureVerificationException('No signature hash found with expected scheme v1');
+            }
+            if (parseInt(timestamp, 10) < Date.now() - tolerance) {
+                throw new exceptions_1.SignatureVerificationException('Timestamp outside the tolerance zone');
+            }
+            const expectedSig = yield this.computeSignature(timestamp, payload, secret);
+            if ((yield this.secureCompare(expectedSig, signatureHash)) === false) {
+                throw new exceptions_1.SignatureVerificationException('Signature hash does not match the expected signature hash for payload');
+            }
+            return true;
+        });
     }
     getTimestampAndSignatureHash(sigHeader) {
         const signature = sigHeader;
@@ -39,31 +48,44 @@ class Webhooks {
         return [timestamp, signatureHash];
     }
     computeSignature(timestamp, payload, secret) {
-        payload = JSON.stringify(payload);
-        const signedPayload = `${timestamp}.${payload}`;
-        const expectedSignature = crypto_1.default
-            .createHmac('sha256', secret)
-            .update(signedPayload)
-            .digest()
-            .toString('hex');
-        return expectedSignature;
+        return __awaiter(this, void 0, void 0, function* () {
+            payload = JSON.stringify(payload);
+            const signedPayload = `${timestamp}.${payload}`;
+            const key = yield crypto.subtle.importKey('raw', new TextEncoder().encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+            const signatureBuffer = yield crypto.subtle.sign('HMAC', key, new TextEncoder().encode(signedPayload));
+            // crypto.subtle returns the signature in base64 format. This must be
+            // encoded in hex to match the CryptoProvider contract. We map each byte in
+            // the buffer to its corresponding hex octet and then combine into a string.
+            const signatureBytes = new Uint8Array(signatureBuffer);
+            const signatureHexCodes = new Array(signatureBytes.length);
+            for (let i = 0; i < signatureBytes.length; i++) {
+                signatureHexCodes[i] = byteHexMapping[signatureBytes[i]];
+            }
+            return signatureHexCodes.join('');
+        });
     }
     secureCompare(stringA, stringB) {
-        const strA = Buffer.from(stringA);
-        const strB = Buffer.from(stringB);
-        if (strA.length !== strB.length) {
-            return false;
-        }
-        if (crypto_1.default.timingSafeEqual) {
-            return crypto_1.default.timingSafeEqual(strA, strB);
-        }
-        const len = strA.length;
-        let result = 0;
-        for (let i = 0; i < len; ++i) {
-            // tslint:disable-next-line:no-bitwise
-            result |= strA[i] ^ strB[i];
-        }
-        return result === 0;
+        return __awaiter(this, void 0, void 0, function* () {
+            const bufferA = Buffer.from(stringA);
+            const bufferB = Buffer.from(stringB);
+            if (bufferA.length !== bufferB.length) {
+                return false;
+            }
+            const algorithm = { name: 'HMAC', hash: 'SHA-256' };
+            const key = (yield crypto.subtle.generateKey(algorithm, false, [
+                'sign',
+                'verify',
+            ]));
+            const hmac = yield crypto.subtle.sign(algorithm, key, bufferA);
+            const equal = yield crypto.subtle.verify(algorithm, key, hmac, bufferB);
+            return equal;
+        });
     }
 }
 exports.Webhooks = Webhooks;
+// Cached mapping of byte to hex representation. We do this once to avoid re-
+// computing every time we need to convert the result of a signature to hex.
+const byteHexMapping = new Array(256);
+for (let i = 0; i < byteHexMapping.length; i++) {
+    byteHexMapping[i] = i.toString(16).padStart(2, '0');
+}

package/lib/webhooks/webhooks.spec.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -90,76 +99,77 @@ describe('Webhooks', () => {
     });
     describe('constructEvent', () => {
         describe('with the correct payload, sig_header, and secret', () => {
-            it('returns a webhook event', () => {
+            it('returns a webhook event', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
                 const options = { payload, sigHeader, secret };
-                const webhook = workos.webhooks.constructEvent(options);
+                const webhook = yield workos.webhooks.constructEvent(options);
                 expect(webhook.data).toEqual(expectation);
                 expect(webhook.event).toEqual('dsync.user.created');
                 expect(webhook.id).toEqual('wh_123');
-            });
+            }));
         });
         describe('with the correct payload, sig_header, secret, and tolerance', () => {
-            it('returns a webhook event', () => {
+            it('returns a webhook event', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
                 const options = { payload, sigHeader, secret, tolerance: 200 };
-                const webhook = workos.webhooks.constructEvent(options);
+                const webhook = yield workos.webhooks.constructEvent(options);
                 expect(webhook.data).toEqual(expectation);
                 expect(webhook.event).toEqual('dsync.user.created');
                 expect(webhook.id).toEqual('wh_123');
-            });
+            }));
         });
         describe('with an empty header', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = '';
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
         describe('with an empty signature hash', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=`;
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
         describe('with an incorrect signature hash', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=99999`;
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
         describe('with an incorrect payload', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
                 payload = 'invalid';
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
         describe('with an incorrect webhook secret', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
                 secret = 'invalid';
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
         describe('with a timestamp outside tolerance', () => {
-            it('raises an error', () => {
+            it('raises an error', () => __awaiter(void 0, void 0, void 0, function* () {
                 const sigHeader = `t=9999, v1=${signatureHash}`;
                 const options = { payload, sigHeader, secret };
-                expect(() => workos.webhooks.constructEvent(options)).toThrowError(exceptions_1.SignatureVerificationException);
-            });
+                yield expect(workos.webhooks.constructEvent(options)).rejects.toThrowError(exceptions_1.SignatureVerificationException);
+            }));
         });
     });
     describe('verifyHeader', () => {
-        it('returns true when the signature is valid', () => {
+        it('returns true when the signature is valid', () => __awaiter(void 0, void 0, void 0, function* () {
             const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
             const options = { payload, sigHeader, secret };
-            expect(() => workos.webhooks.verifyHeader(options)).toBeTruthy();
-        });
+            const result = yield workos.webhooks.verifyHeader(options);
+            expect(result).toBeTruthy();
+        }));
     });
     describe('getTimestampAndSignatureHash', () => {
         it('returns the timestamp and signature when the signature is valid', () => {
@@ -172,9 +182,9 @@ describe('Webhooks', () => {
         });
     });
     describe('computeSignature', () => {
-        it('returns the computed signature', () => {
-            const signature = workos.webhooks.computeSignature(timestamp, payload, secret);
+        it('returns the computed signature', () => __awaiter(void 0, void 0, void 0, function* () {
+            const signature = yield workos.webhooks.computeSignature(timestamp, payload, secret);
             expect(signature).toEqual(signatureHash);
-        });
+        }));
     });
 });

package/lib/workos.d.ts

@@ -1,4 +1,3 @@
-import { AxiosResponse } from 'axios';
 import { GetOptions, PostOptions, PutOptions, WorkOSOptions } from './common/interfaces';
 import { DirectorySync } from './directory-sync/directory-sync';
 import { Events } from './events/events';
@@ -29,10 +28,16 @@ export declare class WorkOS {
     readonly userManagement: UserManagement;
     constructor(key?: string | undefined, options?: WorkOSOptions);
     get version(): string;
-    post<T = any, D = any, P = any>(path: string, entity: P, options?: PostOptions): Promise<AxiosResponse<T, D>>;
-    get<T = any, D = any>(path: string, options?: GetOptions): Promise<AxiosResponse<T, D>>;
-    put<T = any, D = any>(path: string, entity: any, options?: PutOptions): Promise<AxiosResponse<T, D>>;
-    delete<T = any, D = any>(path: string, query?: any): Promise<AxiosResponse<T, D>>;
+    post<Result = any, Entity = any>(path: string, entity: Entity, options?: PostOptions): Promise<{
+        data: Result;
+    }>;
+    get<Result = any>(path: string, options?: GetOptions): Promise<{
+        data: Result;
+    }>;
+    put<Result = any, Entity = any>(path: string, entity: Entity, options?: PutOptions): Promise<{
+        data: Result;
+    }>;
+    delete(path: string, query?: any): Promise<void>;
     emitWarning(warning: string): void;
-    private handleAxiosError;
+    private handleFetchError;
 }

package/lib/workos.js

@@ -8,12 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 exports.WorkOS = void 0;
-const axios_1 = __importDefault(require("axios"));
 const exceptions_1 = require("./common/exceptions");
 const directory_sync_1 = require("./directory-sync/directory-sync");
 const events_1 = require("./events/events");
@@ -27,7 +23,8 @@ const mfa_1 = require("./mfa/mfa");
 const audit_logs_1 = require("./audit-logs/audit-logs");
 const user_management_1 = require("./user-management/user-management");
 const bad_request_exception_1 = require("./common/exceptions/bad-request.exception");
-const VERSION = '5.2.0';
+const fetch_client_1 = require("./common/utils/fetch-client");
+const VERSION = '6.0.0-rc.2';
 const DEFAULT_HOSTNAME = 'api.workos.com';
 class WorkOS {
     constructor(key, options = {}) {
@@ -46,7 +43,8 @@ class WorkOS {
         this.events = new events_1.Events(this);
         this.userManagement = new user_management_1.UserManagement(this);
         if (!key) {
-            this.key = process.env.WORKOS_API_KEY;
+            // process might be undefined in some environments
+            this.key = process === null || process === void 0 ? void 0 : process.env.WORKOS_API_KEY;
             if (!this.key) {
                 throw new exceptions_1.NoApiKeyProvidedException();
             }
@@ -61,7 +59,7 @@ class WorkOS {
         if (port) {
             this.baseURL = this.baseURL + `:${port}`;
         }
-        this.client = axios_1.default.create(Object.assign(Object.assign({}, options.axios), { baseURL: this.baseURL, headers: Object.assign(Object.assign({}, (_a = options.axios) === null || _a === void 0 ? void 0 : _a.headers), { Authorization: `Bearer ${this.key}`, 'User-Agent': `workos-node/${VERSION}` }) }));
+        this.client = new fetch_client_1.FetchClient(this.baseURL, Object.assign(Object.assign({}, options.config), { headers: Object.assign(Object.assign({}, (_a = options.config) === null || _a === void 0 ? void 0 : _a.headers), { Authorization: `Bearer ${this.key}`, 'User-Agent': `workos-node/${VERSION}` }) }));
     }
     get version() {
         return VERSION;
@@ -79,7 +77,7 @@ class WorkOS {
                 });
             }
             catch (error) {
-                this.handleAxiosError({ path, error });
+                this.handleFetchError({ path, error });
                 throw error;
             }
         });
@@ -91,14 +89,12 @@ class WorkOS {
                 return yield this.client.get(path, {
                     params: options.query,
                     headers: accessToken
-                        ? {
-                            Authorization: `Bearer ${accessToken}`,
-                        }
+                        ? { Authorization: `Bearer ${accessToken}` }
                         : undefined,
                 });
             }
             catch (error) {
-                this.handleAxiosError({ path, error });
+                this.handleFetchError({ path, error });
                 throw error;
             }
         });
@@ -116,7 +112,7 @@ class WorkOS {
                 });
             }
             catch (error) {
-                this.handleAxiosError({ path, error });
+                this.handleFetchError({ path, error });
                 throw error;
             }
         });
@@ -124,35 +120,36 @@ class WorkOS {
     delete(path, query) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return yield this.client.delete(path, {
+                yield this.client.delete(path, {
                     params: query,
                 });
             }
             catch (error) {
-                this.handleAxiosError({ path, error });
+                this.handleFetchError({ path, error });
                 throw error;
             }
         });
     }
     emitWarning(warning) {
-        if (typeof process.emitWarning !== 'function') {
+        // process might be undefined in some environments
+        if (typeof (process === null || process === void 0 ? void 0 : process.emitWarning) !== 'function') {
             //  tslint:disable:no-console
             return console.warn(`WorkOS: ${warning}`);
         }
         return process.emitWarning(warning, 'WorkOS');
     }
-    handleAxiosError({ path, error }) {
+    handleFetchError({ path, error }) {
+        var _a;
         const { response } = error;
         if (response) {
             const { status, data, headers } = response;
-            const requestID = headers['X-Request-ID'];
+            const requestID = (_a = headers.get('X-Request-ID')) !== null && _a !== void 0 ? _a : '';
             const { code, error_description: errorDescription, error, errors, message, } = data;
             switch (status) {
                 case 401: {
                     throw new exceptions_1.UnauthorizedException(requestID);
                 }
                 case 422: {
-                    const { errors } = data;
                     throw new exceptions_1.UnprocessableEntityException({
                         code,
                         errors,

package/lib/workos.spec.js

@@ -12,13 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
-const axios_mock_adapter_1 = __importDefault(require("axios-mock-adapter"));
+const jest_fetch_mock_1 = __importDefault(require("jest-fetch-mock"));
+const test_utils_1 = require("./common/utils/test-utils");
 const promises_1 = __importDefault(require("fs/promises"));
 const exceptions_1 = require("./common/exceptions");
 const workos_1 = require("./workos");
-const mock = new axios_mock_adapter_1.default(axios_1.default);
 describe('WorkOS', () => {
+    beforeEach(() => jest_fetch_mock_1.default.resetMocks());
     describe('constructor', () => {
         const OLD_ENV = process.env;
         beforeEach(() => {
@@ -66,18 +66,18 @@ describe('WorkOS', () => {
                 expect(workos.baseURL).toEqual('https://localhost:4000');
             });
         });
-        describe('when the `axios` option is provided', () => {
-            it('applies the configuration to the Axios client', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock.onPost().reply(200, 'OK', { 'X-Request-ID': 'a-request-id' });
+        describe('when the `config` option is provided', () => {
+            it('applies the configuration to the fetch client', () => __awaiter(void 0, void 0, void 0, function* () {
+                (0, test_utils_1.fetchOnce)('{}', { headers: { 'X-Request-ID': 'a-request-id' } });
                 const workos = new workos_1.WorkOS('sk_test', {
-                    axios: {
+                    config: {
                         headers: {
                             'X-My-Custom-Header': 'Hey there!',
                         },
                     },
                 });
                 yield workos.post('/somewhere', {});
-                expect(mock.history.post[0].headers).toMatchObject({
+                expect((0, test_utils_1.fetchHeaders)()).toMatchObject({
                     'X-My-Custom-Header': 'Hey there!',
                 });
             }));
@@ -96,9 +96,7 @@ describe('WorkOS', () => {
         describe('when the api responds with a 404', () => {
             it('throws a NotFoundException', () => __awaiter(void 0, void 0, void 0, function* () {
                 const message = 'Not Found';
-                mock.onPost().reply(404, {
-                    message,
-                }, { 'X-Request-ID': 'a-request-id' });
+                (0, test_utils_1.fetchOnce)({ message }, { status: 404, headers: { 'X-Request-ID': 'a-request-id' } });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.post('/path', {})).rejects.toStrictEqual(new exceptions_1.NotFoundException({
                     message,
@@ -109,10 +107,7 @@ describe('WorkOS', () => {
             it('preserves the error code, status, and message from the underlying response', () => __awaiter(void 0, void 0, void 0, function* () {
                 const message = 'The thing you are looking for is not here.';
                 const code = 'thing-not-found';
-                mock.onPost().reply(404, {
-                    code,
-                    message,
-                }, { 'X-Request-ID': 'a-request-id' });
+                (0, test_utils_1.fetchOnce)({ code, message }, { status: 404, headers: { 'X-Request-ID': 'a-request-id' } });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.post('/path', {})).rejects.toMatchObject({
                     code,
@@ -123,9 +118,7 @@ describe('WorkOS', () => {
             it('includes the path in the message if there is no message in the response', () => __awaiter(void 0, void 0, void 0, function* () {
                 const code = 'thing-not-found';
                 const path = '/path/to/thing/that-aint-there';
-                mock.onPost().reply(404, {
-                    code,
-                }, { 'X-Request-ID': 'a-request-id' });
+                (0, test_utils_1.fetchOnce)({ code }, { status: 404, headers: { 'X-Request-ID': 'a-request-id' } });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.post(path, {})).rejects.toMatchObject({
                     code,
@@ -136,8 +129,9 @@ describe('WorkOS', () => {
         });
         describe('when the api responds with a 500 and no error/error_description', () => {
             it('throws an GenericServerException', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock.onPost().reply(500, {}, {
-                    'X-Request-ID': 'a-request-id',
+                (0, test_utils_1.fetchOnce)({}, {
+                    status: 500,
+                    headers: { 'X-Request-ID': 'a-request-id' },
                 });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.post('/path', {})).rejects.toStrictEqual(new exceptions_1.GenericServerException(500, undefined, {}, 'a-request-id'));
@@ -145,8 +139,9 @@ describe('WorkOS', () => {
         });
         describe('when the api responds with a 400 and an error/error_description', () => {
             it('throws an OauthException', () => __awaiter(void 0, void 0, void 0, function* () {
-                mock.onPost().reply(400, { error: 'error', error_description: 'error description' }, {
-                    'X-Request-ID': 'a-request-id',
+                (0, test_utils_1.fetchOnce)({ error: 'error', error_description: 'error description' }, {
+                    status: 400,
+                    headers: { 'X-Request-ID': 'a-request-id' },
                 });
                 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
                 yield expect(workos.post('/path', {})).rejects.toStrictEqual(new exceptions_1.OauthException(400, 'a-request-id', 'error', 'error description', { error: 'error', error_description: 'error description' }));

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.2.0",
+  "version": "6.0.0-rc.2",
   "name": "@workos-inc/node",
   "author": "WorkOS",
   "description": "A Node wrapper for the WorkOS API",
@@ -34,15 +34,16 @@
     "prepublishOnly": "yarn run build"
   },
   "dependencies": {
-    "axios": "~1.6.5",
     "pluralize": "8.0.0"
   },
   "devDependencies": {
+    "@peculiar/webcrypto": "^1.4.5",
     "@types/jest": "29.5.3",
     "@types/node": "14.18.54",
     "@types/pluralize": "0.0.30",
     "axios-mock-adapter": "1.21.5",
     "jest": "29.6.2",
+    "jest-fetch-mock": "^3.0.3",
     "prettier": "2.8.8",
     "supertest": "6.3.3",
     "ts-jest": "29.1.1",