@workos-inc/node 7.9.0 → 7.11.0

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

@@ -0,0 +1,155 @@
+"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';
+    }
+    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);
+        });
+    }
+    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', 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.nodeRequest(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.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();
+            });
+        });
+    }
+}
+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/index.d.ts

@@ -1,4 +1,7 @@
+import { HttpClient } from './common/net/http-client';
+import { Webhooks } from './webhooks/webhooks';
 import { WorkOS } from './workos';
+import { WorkOSOptions } from './common/interfaces';
 export * from './audit-logs/interfaces';
 export * from './common/exceptions';
 export * from './common/interfaces';
@@ -11,5 +14,10 @@ export * from './passwordless/interfaces';
 export * from './portal/interfaces';
 export * from './sso/interfaces';
 export * from './user-management/interfaces';
-export { WorkOS };
-export default WorkOS;
+declare class WorkOSNode extends WorkOS {
+    /** @override */
+    createHttpClient(options: WorkOSOptions, userAgent: string): HttpClient;
+    /** @override */
+    createWebhookClient(): Webhooks;
+}
+export { WorkOSNode as WorkOS };

package/lib/index.js

@@ -15,8 +15,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkOS = void 0;
+const node_crypto_provider_1 = require("./common/crypto/node-crypto-provider");
+const subtle_crypto_provider_1 = require("./common/crypto/subtle-crypto-provider");
+const fetch_client_1 = require("./common/net/fetch-client");
+const node_client_1 = require("./common/net/node-client");
+const webhooks_1 = require("./webhooks/webhooks");
 const workos_1 = require("./workos");
-Object.defineProperty(exports, "WorkOS", { enumerable: true, get: function () { return workos_1.WorkOS; } });
 __exportStar(require("./audit-logs/interfaces"), exports);
 __exportStar(require("./common/exceptions"), exports);
 __exportStar(require("./common/interfaces"), exports);
@@ -29,5 +33,29 @@ __exportStar(require("./passwordless/interfaces"), exports);
 __exportStar(require("./portal/interfaces"), exports);
 __exportStar(require("./sso/interfaces"), exports);
 __exportStar(require("./user-management/interfaces"), exports);
-// tslint:disable-next-line:no-default-export
-exports.default = workos_1.WorkOS;
+class WorkOSNode extends workos_1.WorkOS {
+    /** @override */
+    createHttpClient(options, userAgent) {
+        var _a;
+        const opts = 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': userAgent }) });
+        if (typeof fetch !== 'undefined' ||
+            typeof options.fetchFn !== 'undefined') {
+            return new fetch_client_1.FetchHttpClient(this.baseURL, opts, options.fetchFn);
+        }
+        else {
+            return new node_client_1.NodeHttpClient(this.baseURL, opts);
+        }
+    }
+    /** @override */
+    createWebhookClient() {
+        let cryptoProvider;
+        if (typeof crypto !== 'undefined' && typeof crypto.subtle !== 'undefined') {
+            cryptoProvider = new subtle_crypto_provider_1.SubtleCryptoProvider();
+        }
+        else {
+            cryptoProvider = new node_crypto_provider_1.NodeCryptoProvider();
+        }
+        return new webhooks_1.Webhooks(cryptoProvider);
+    }
+}
+exports.WorkOS = WorkOSNode;

package/lib/index.worker.d.ts

@@ -0,0 +1,23 @@
+import { HttpClient } from './common/net/http-client';
+import { WorkOSOptions } from './index.worker';
+import { Webhooks } from './webhooks/webhooks';
+import { WorkOS } from './workos';
+export * from './audit-logs/interfaces';
+export * from './common/exceptions';
+export * from './common/interfaces';
+export * from './common/utils/pagination';
+export * from './directory-sync/interfaces';
+export * from './directory-sync/utils/get-primary-email';
+export * from './events/interfaces';
+export * from './organizations/interfaces';
+export * from './passwordless/interfaces';
+export * from './portal/interfaces';
+export * from './sso/interfaces';
+export * from './user-management/interfaces';
+declare class WorkOSWorker extends WorkOS {
+    /** @override */
+    createHttpClient(options: WorkOSOptions, userAgent: string): HttpClient;
+    /** @override */
+    createWebhookClient(): Webhooks;
+}
+export { WorkOSWorker as WorkOS };

package/lib/index.worker.js

@@ -0,0 +1,46 @@
+"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.WorkOS = void 0;
+const subtle_crypto_provider_1 = require("./common/crypto/subtle-crypto-provider");
+const fetch_client_1 = require("./common/net/fetch-client");
+const webhooks_1 = require("./webhooks/webhooks");
+const workos_1 = require("./workos");
+__exportStar(require("./audit-logs/interfaces"), exports);
+__exportStar(require("./common/exceptions"), exports);
+__exportStar(require("./common/interfaces"), exports);
+__exportStar(require("./common/utils/pagination"), exports);
+__exportStar(require("./directory-sync/interfaces"), exports);
+__exportStar(require("./directory-sync/utils/get-primary-email"), exports);
+__exportStar(require("./events/interfaces"), exports);
+__exportStar(require("./organizations/interfaces"), exports);
+__exportStar(require("./passwordless/interfaces"), exports);
+__exportStar(require("./portal/interfaces"), exports);
+__exportStar(require("./sso/interfaces"), exports);
+__exportStar(require("./user-management/interfaces"), exports);
+class WorkOSWorker extends workos_1.WorkOS {
+    /** @override */
+    createHttpClient(options, userAgent) {
+        var _a;
+        return new fetch_client_1.FetchHttpClient(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': userAgent }) }));
+    }
+    /** @override */
+    createWebhookClient() {
+        const cryptoProvider = new subtle_crypto_provider_1.SubtleCryptoProvider();
+        return new webhooks_1.Webhooks(cryptoProvider);
+    }
+}
+exports.WorkOS = WorkOSWorker;

package/lib/organizations/interfaces/create-organization-options.interface.d.ts

@@ -2,8 +2,11 @@ import { PostOptions } from '../../common/interfaces';
 import { DomainData } from './domain-data.interface';
 export interface CreateOrganizationOptions {
     name: string;
-    allowProfilesOutsideOrganization?: boolean;
     domainData?: DomainData[];
+    /**
+     * @deprecated If you need to allow sign-ins from any email domain, contact support@workos.com.
+     */
+    allowProfilesOutsideOrganization?: boolean;
     /**
      * @deprecated Use `domain_data` instead.
      */
@@ -11,8 +14,11 @@ export interface CreateOrganizationOptions {
 }
 export interface SerializedCreateOrganizationOptions {
     name: string;
-    allow_profiles_outside_organization?: boolean;
     domain_data?: DomainData[];
+    /**
+     * @deprecated If you need to allow sign-ins from any email domain, contact support@workos.com.
+     */
+    allow_profiles_outside_organization?: boolean;
     /**
      * @deprecated Use `domain_data` instead.
      */

package/lib/organizations/interfaces/update-organization-options.interface.d.ts

@@ -2,8 +2,11 @@ import { DomainData } from './domain-data.interface';
 export interface UpdateOrganizationOptions {
     organization: string;
     name: string;
-    allowProfilesOutsideOrganization?: boolean;
     domainData?: DomainData[];
+    /**
+     * @deprecated If you need to allow sign-ins from any email domain, contact support@workos.com.
+     */
+    allowProfilesOutsideOrganization?: boolean;
     /**
      * @deprecated Use `domain_data` instead.
      */
@@ -11,8 +14,11 @@ export interface UpdateOrganizationOptions {
 }
 export interface SerializedUpdateOrganizationOptions {
     name: string;
-    allow_profiles_outside_organization?: boolean;
     domain_data?: DomainData[];
+    /**
+     * @deprecated If you need to allow sign-ins from any email domain, contact support@workos.com.
+     */
+    allow_profiles_outside_organization?: boolean;
     /**
      * @deprecated Use `domain_data` instead.
      */

package/lib/user-management/user-management.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserManagement = void 0;
 const pagination_1 = require("../common/utils/pagination");
@@ -183,7 +194,8 @@ class UserManagement {
     }
     listAuthFactors(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, `/user_management/users/${options.userId}/auth_factors`, factor_serializer_1.deserializeFactor, options), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, `/user_management/users/${options.userId}/auth_factors`, factor_serializer_1.deserializeFactor, params), options);
+            const { userId } = options, restOfOptions = __rest(options, ["userId"]);
+            return new pagination_1.AutoPaginatable(yield (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, `/user_management/users/${userId}/auth_factors`, factor_serializer_1.deserializeFactor, restOfOptions), (params) => (0, fetch_and_deserialize_1.fetchAndDeserialize)(this.workos, `/user_management/users/${userId}/auth_factors`, factor_serializer_1.deserializeFactor, params), restOfOptions);
         });
     }
     deleteUser(userId) {

package/lib/webhooks/webhooks.d.ts

@@ -1,6 +1,8 @@
 import { Event } from '../common/interfaces';
+import { CryptoProvider } from '../common/crypto/crypto-provider';
 export declare class Webhooks {
-    private encoder;
+    private cryptoProvider;
+    constructor(cryptoProvider: CryptoProvider);
     constructEvent({ payload, sigHeader, secret, tolerance, }: {
         payload: unknown;
         sigHeader: string;
@@ -15,5 +17,4 @@ export declare class Webhooks {
     }): Promise<boolean>;
     getTimestampAndSignatureHash(sigHeader: string): [string, string];
     computeSignature(timestamp: any, payload: any, secret: string): Promise<string>;
-    secureCompare(stringA: string, stringB: string): Promise<boolean>;
 }

package/lib/webhooks/webhooks.js

@@ -13,8 +13,8 @@ exports.Webhooks = void 0;
 const exceptions_1 = require("../common/exceptions");
 const serializers_1 = require("../common/serializers");
 class Webhooks {
-    constructor() {
-        this.encoder = new TextEncoder();
+    constructor(cryptoProvider) {
+        this.cryptoProvider = cryptoProvider;
     }
     constructEvent({ payload, sigHeader, secret, tolerance = 180000, }) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -34,7 +34,8 @@ class Webhooks {
                 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) {
+            if ((yield this.cryptoProvider.secureCompare(expectedSig, signatureHash)) ===
+                false) {
                 throw new exceptions_1.SignatureVerificationException('Signature hash does not match the expected signature hash for payload');
             }
             return true;
@@ -54,41 +55,8 @@ class Webhooks {
         return __awaiter(this, void 0, void 0, function* () {
             payload = JSON.stringify(payload);
             const signedPayload = `${timestamp}.${payload}`;
-            const key = yield crypto.subtle.importKey('raw', this.encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-            const signatureBuffer = yield crypto.subtle.sign('HMAC', key, this.encoder.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) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const bufferA = this.encoder.encode(stringA);
-            const bufferB = this.encoder.encode(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;
+            return yield this.cryptoProvider.computeHMACSignatureAsync(signedPayload, secret);
         });
     }
 }
 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

@@ -17,6 +17,8 @@ const workos_1 = require("../workos");
 const webhook_json_1 = __importDefault(require("./fixtures/webhook.json"));
 const workos = new workos_1.WorkOS('sk_test_Sz3IQjepeSWaI4cMS4ms4sMuU');
 const exceptions_1 = require("../common/exceptions");
+const node_crypto_provider_1 = require("../common/crypto/node-crypto-provider");
+const subtle_crypto_provider_1 = require("../common/crypto/subtle-crypto-provider");
 describe('Webhooks', () => {
     let payload;
     let secret;
@@ -187,4 +189,32 @@ describe('Webhooks', () => {
             expect(signature).toEqual(signatureHash);
         }));
     });
+    describe('when in an environment that supports SubtleCrypto', () => {
+        it('automatically uses the subtle crypto library', () => {
+            // tslint:disable-next-line
+            expect(workos.webhooks['cryptoProvider']).toBeInstanceOf(subtle_crypto_provider_1.SubtleCryptoProvider);
+        });
+    });
+    describe('CryptoProvider', () => {
+        describe('when computing HMAC signature', () => {
+            it('returns the same for the Node crypto and Web Crypto versions', () => __awaiter(void 0, void 0, void 0, function* () {
+                const nodeCryptoProvider = new node_crypto_provider_1.NodeCryptoProvider();
+                const subtleCryptoProvider = new subtle_crypto_provider_1.SubtleCryptoProvider();
+                const stringifiedPayload = JSON.stringify(payload);
+                const payloadHMAC = `${timestamp}.${stringifiedPayload}`;
+                const nodeCompare = yield nodeCryptoProvider.computeHMACSignatureAsync(payloadHMAC, secret);
+                const subtleCompare = yield subtleCryptoProvider.computeHMACSignatureAsync(payloadHMAC, secret);
+                expect(nodeCompare).toEqual(subtleCompare);
+            }));
+        });
+        describe('when securely comparing', () => {
+            it('returns the same for the Node crypto and Web Crypto versions', () => __awaiter(void 0, void 0, void 0, function* () {
+                const nodeCryptoProvider = new node_crypto_provider_1.NodeCryptoProvider();
+                const subtleCryptoProvider = new subtle_crypto_provider_1.SubtleCryptoProvider();
+                const signature = yield workos.webhooks.computeSignature(timestamp, payload, secret);
+                expect(nodeCryptoProvider.secureCompare(signature, signatureHash)).toEqual(subtleCryptoProvider.secureCompare(signature, signatureHash));
+                expect(nodeCryptoProvider.secureCompare(signature, 'foo')).toEqual(subtleCryptoProvider.secureCompare(signature, 'foo'));
+            }));
+        });
+    });
 });

package/lib/workos.d.ts

@@ -10,11 +10,12 @@ import { Webhooks } from './webhooks/webhooks';
 import { Mfa } from './mfa/mfa';
 import { AuditLogs } from './audit-logs/audit-logs';
 import { UserManagement } from './user-management/user-management';
+import { HttpClient } from './common/net/http-client';
 export declare class WorkOS {
     readonly key?: string | undefined;
     readonly options: WorkOSOptions;
     readonly baseURL: string;
-    private readonly client;
+    readonly client: HttpClient;
     readonly auditLogs: AuditLogs;
     readonly directorySync: DirectorySync;
     readonly organizations: Organizations;
@@ -27,6 +28,8 @@ export declare class WorkOS {
     readonly events: Events;
     readonly userManagement: UserManagement;
     constructor(key?: string | undefined, options?: WorkOSOptions);
+    createWebhookClient(): Webhooks;
+    createHttpClient(options: WorkOSOptions, userAgent: string): HttpClient;
     get version(): string;
     post<Result = any, Entity = any>(path: string, entity: Entity, options?: PostOptions): Promise<{
         data: Result;
@@ -39,5 +42,5 @@ export declare class WorkOS {
     }>;
     delete(path: string, query?: any): Promise<void>;
     emitWarning(warning: string): void;
-    private handleFetchError;
+    private handleHttpError;
 }

package/lib/workos.js

@@ -23,12 +23,13 @@ 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 fetch_client_1 = require("./common/utils/fetch-client");
-const VERSION = '7.9.0';
+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.11.0';
 const DEFAULT_HOSTNAME = 'api.workos.com';
 class WorkOS {
     constructor(key, options = {}) {
-        var _a;
         this.key = key;
         this.options = options;
         this.auditLogs = new audit_logs_1.AuditLogs(this);
@@ -38,7 +39,6 @@ class WorkOS {
         this.passwordless = new passwordless_1.Passwordless(this);
         this.portal = new portal_1.Portal(this);
         this.sso = new sso_1.SSO(this);
-        this.webhooks = new webhooks_1.Webhooks();
         this.mfa = new mfa_1.Mfa(this);
         this.events = new events_1.Events(this);
         this.userManagement = new user_management_1.UserManagement(this);
@@ -64,7 +64,15 @@ class WorkOS {
             const { name, version } = options.appInfo;
             userAgent += ` ${name}: ${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': userAgent }) }));
+        this.webhooks = this.createWebhookClient();
+        this.client = this.createHttpClient(options, userAgent);
+    }
+    createWebhookClient() {
+        return new webhooks_1.Webhooks(new subtle_crypto_provider_1.SubtleCryptoProvider());
+    }
+    createHttpClient(options, userAgent) {
+        var _a;
+        return new fetch_client_1.FetchHttpClient(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': userAgent }) }));
     }
     get version() {
         return VERSION;
@@ -76,13 +84,14 @@ class WorkOS {
                 requestHeaders['Idempotency-Key'] = options.idempotencyKey;
             }
             try {
-                return yield this.client.post(path, entity, {
+                const res = yield this.client.post(path, entity, {
                     params: options.query,
                     headers: requestHeaders,
                 });
+                return { data: yield res.toJSON() };
             }
             catch (error) {
-                this.handleFetchError({ path, error });
+                this.handleHttpError({ path, error });
                 throw error;
             }
         });
@@ -91,15 +100,16 @@ class WorkOS {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const { accessToken } = options;
-                return yield this.client.get(path, {
+                const res = yield this.client.get(path, {
                     params: options.query,
                     headers: accessToken
                         ? { Authorization: `Bearer ${accessToken}` }
                         : undefined,
                 });
+                return { data: yield res.toJSON() };
             }
             catch (error) {
-                this.handleFetchError({ path, error });
+                this.handleHttpError({ path, error });
                 throw error;
             }
         });
@@ -111,13 +121,14 @@ class WorkOS {
                 requestHeaders['Idempotency-Key'] = options.idempotencyKey;
             }
             try {
-                return yield this.client.put(path, entity, {
+                const res = yield this.client.put(path, entity, {
                     params: options.query,
                     headers: requestHeaders,
                 });
+                return { data: yield res.toJSON() };
             }
             catch (error) {
-                this.handleFetchError({ path, error });
+                this.handleHttpError({ path, error });
                 throw error;
             }
         });
@@ -130,7 +141,7 @@ class WorkOS {
                 });
             }
             catch (error) {
-                this.handleFetchError({ path, error });
+                this.handleHttpError({ path, error });
                 throw error;
             }
         });
@@ -143,12 +154,15 @@ class WorkOS {
         }
         return process.emitWarning(warning, 'WorkOS');
     }
-    handleFetchError({ path, error }) {
+    handleHttpError({ path, error }) {
         var _a;
+        if (!(error instanceof http_client_1.HttpClientError)) {
+            throw new Error(`Unexpected error: ${error}`);
+        }
         const { response } = error;
         if (response) {
             const { status, data, headers } = response;
-            const requestID = (_a = headers.get('X-Request-ID')) !== null && _a !== void 0 ? _a : '';
+            const requestID = (_a = headers['X-Request-ID']) !== null && _a !== void 0 ? _a : '';
             const { code, error_description: errorDescription, error, errors, message, } = data;
             switch (status) {
                 case 401: {