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

package/lib/common/crypto/node-crypto-provider.js

@@ -0,0 +1,109 @@
+"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.NodeCryptoProvider = void 0;
+const crypto = __importStar(require("crypto"));
+const crypto_provider_1 = require("./crypto-provider");
+/**
+ * `CryptoProvider which uses the Node `crypto` package for its computations.
+ */
+class NodeCryptoProvider extends crypto_provider_1.CryptoProvider {
+    /** @override */
+    computeHMACSignature(payload, secret) {
+        return crypto
+            .createHmac('sha256', secret)
+            .update(payload, 'utf8')
+            .digest('hex');
+    }
+    /** @override */
+    computeHMACSignatureAsync(payload, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signature = this.computeHMACSignature(payload, secret);
+            return signature;
+        });
+    }
+    /** @override */
+    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;
+            }
+            // Generate a random key for HMAC
+            const key = crypto.randomBytes(32); // Generates a 256-bit key
+            const hmacA = crypto.createHmac('sha256', key).update(bufferA).digest();
+            const hmacB = crypto.createHmac('sha256', key).update(bufferB).digest();
+            // Perform a constant time comparison
+            return crypto.timingSafeEqual(hmacA, hmacB);
+        });
+    }
+    encrypt(plaintext, key, iv, aad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const actualIv = iv || crypto.randomBytes(32);
+            const cipher = crypto.createCipheriv('aes-256-gcm', key, actualIv);
+            if (aad) {
+                cipher.setAAD(Buffer.from(aad));
+            }
+            const ciphertext = Buffer.concat([
+                cipher.update(Buffer.from(plaintext)),
+                cipher.final(),
+            ]);
+            const tag = cipher.getAuthTag();
+            return {
+                ciphertext: new Uint8Array(ciphertext),
+                iv: new Uint8Array(actualIv),
+                tag: new Uint8Array(tag),
+            };
+        });
+    }
+    decrypt(ciphertext, key, iv, tag, aad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+            decipher.setAuthTag(Buffer.from(tag));
+            if (aad) {
+                decipher.setAAD(Buffer.from(aad));
+            }
+            const decrypted = Buffer.concat([
+                decipher.update(Buffer.from(ciphertext)),
+                decipher.final(),
+            ]);
+            return new Uint8Array(decrypted);
+        });
+    }
+    randomBytes(length) {
+        return new Uint8Array(crypto.randomBytes(length));
+    }
+}
+exports.NodeCryptoProvider = NodeCryptoProvider;

package/lib/common/crypto/signature-provider.d.ts

@@ -1,6 +1,5 @@
-import { CryptoProvider } from './crypto-provider.js';
-
-declare class SignatureProvider {
+import { CryptoProvider } from './crypto-provider';
+export declare class SignatureProvider {
     private cryptoProvider;
     constructor(cryptoProvider: CryptoProvider);
     verifyHeader({ payload, sigHeader, secret, tolerance, }: {
@@ -12,5 +11,3 @@ declare class SignatureProvider {
     getTimestampAndSignatureHash(sigHeader: string): [string, string];
     computeSignature(timestamp: any, payload: any, secret: string): Promise<string>;
 }
-
-export { SignatureProvider };

package/lib/common/crypto/signature-provider.js

@@ -1,61 +1,53 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { SignatureVerificationException } from "../exceptions";
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureProvider = void 0;
+const exceptions_1 = require("../exceptions");
 class SignatureProvider {
-  static {
-    __name(this, "SignatureProvider");
-  }
-  cryptoProvider;
-  constructor(cryptoProvider) {
-    this.cryptoProvider = cryptoProvider;
-  }
-  async verifyHeader({
-    payload,
-    sigHeader,
-    secret,
-    tolerance = 18e4
-  }) {
-    const [timestamp, signatureHash] = this.getTimestampAndSignatureHash(sigHeader);
-    if (!signatureHash || Object.keys(signatureHash).length === 0) {
-      throw new SignatureVerificationException(
-        "No signature hash found with expected scheme v1"
-      );
+    constructor(cryptoProvider) {
+        this.cryptoProvider = cryptoProvider;
     }
-    if (parseInt(timestamp, 10) < Date.now() - tolerance) {
-      throw new SignatureVerificationException(
-        "Timestamp outside the tolerance zone"
-      );
+    verifyHeader({ payload, sigHeader, secret, tolerance = 180000, }) {
+        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.cryptoProvider.secureCompare(expectedSig, signatureHash)) ===
+                false) {
+                throw new exceptions_1.SignatureVerificationException('Signature hash does not match the expected signature hash for payload');
+            }
+            return true;
+        });
     }
-    const expectedSig = await this.computeSignature(timestamp, payload, secret);
-    if (await this.cryptoProvider.secureCompare(expectedSig, signatureHash) === false) {
-      throw new SignatureVerificationException(
-        "Signature hash does not match the expected signature hash for payload"
-      );
+    getTimestampAndSignatureHash(sigHeader) {
+        const signature = sigHeader;
+        const [t, v1] = signature.split(',');
+        if (typeof t === 'undefined' || typeof v1 === 'undefined') {
+            throw new exceptions_1.SignatureVerificationException('Signature or timestamp missing');
+        }
+        const { 1: timestamp } = t.split('=');
+        const { 1: signatureHash } = v1.split('=');
+        return [timestamp, signatureHash];
     }
-    return true;
-  }
-  getTimestampAndSignatureHash(sigHeader) {
-    const signature = sigHeader;
-    const [t, v1] = signature.split(",");
-    if (typeof t === "undefined" || typeof v1 === "undefined") {
-      throw new SignatureVerificationException(
-        "Signature or timestamp missing"
-      );
+    computeSignature(timestamp, payload, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            payload = JSON.stringify(payload);
+            const signedPayload = `${timestamp}.${payload}`;
+            return yield this.cryptoProvider.computeHMACSignatureAsync(signedPayload, secret);
+        });
     }
-    const { 1: timestamp } = t.split("=");
-    const { 1: signatureHash } = v1.split("=");
-    return [timestamp, signatureHash];
-  }
-  async computeSignature(timestamp, payload, secret) {
-    payload = JSON.stringify(payload);
-    const signedPayload = `${timestamp}.${payload}`;
-    return await this.cryptoProvider.computeHMACSignatureAsync(
-      signedPayload,
-      secret
-    );
-  }
 }
-export {
-  SignatureProvider
-};
-//# sourceMappingURL=signature-provider.js.map
+exports.SignatureProvider = SignatureProvider;

package/lib/common/crypto/signature-provider.spec.d.ts

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

package/lib/common/crypto/signature-provider.spec.js

@@ -0,0 +1,66 @@
+"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 crypto_1 = __importDefault(require("crypto"));
+const subtle_crypto_provider_1 = require("./subtle-crypto-provider");
+const webhook_json_1 = __importDefault(require("../../webhooks/fixtures/webhook.json"));
+const signature_provider_1 = require("./signature-provider");
+describe('SignatureProvider', () => {
+    let payload;
+    let secret;
+    let timestamp;
+    let signatureHash;
+    const signatureProvider = new signature_provider_1.SignatureProvider(new subtle_crypto_provider_1.SubtleCryptoProvider());
+    beforeEach(() => {
+        payload = webhook_json_1.default;
+        secret = 'secret';
+        timestamp = Date.now() * 1000;
+        const unhashedString = `${timestamp}.${JSON.stringify(payload)}`;
+        signatureHash = crypto_1.default
+            .createHmac('sha256', secret)
+            .update(unhashedString)
+            .digest()
+            .toString('hex');
+    });
+    describe('verifyHeader', () => {
+        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 };
+            const result = yield signatureProvider.verifyHeader(options);
+            expect(result).toBeTruthy();
+        }));
+    });
+    describe('getTimestampAndSignatureHash', () => {
+        it('returns the timestamp and signature when the signature is valid', () => {
+            const sigHeader = `t=${timestamp}, v1=${signatureHash}`;
+            const timestampAndSignature = signatureProvider.getTimestampAndSignatureHash(sigHeader);
+            expect(timestampAndSignature).toEqual([
+                timestamp.toString(),
+                signatureHash,
+            ]);
+        });
+    });
+    describe('computeSignature', () => {
+        it('returns the computed signature', () => __awaiter(void 0, void 0, void 0, function* () {
+            const signature = yield signatureProvider.computeSignature(timestamp, payload, secret);
+            expect(signature).toEqual(signatureHash);
+        }));
+    });
+    describe('when in an environment that supports SubtleCrypto', () => {
+        it('automatically uses the subtle crypto library', () => {
+            // tslint:disable-next-line
+            expect(signatureProvider['cryptoProvider']).toBeInstanceOf(subtle_crypto_provider_1.SubtleCryptoProvider);
+        });
+    });
+});

package/lib/common/crypto/subtle-crypto-provider.d.ts

@@ -1,11 +1,10 @@
-import { CryptoProvider } from './crypto-provider.js';
-
+import { CryptoProvider } from './crypto-provider';
 /**
  * `CryptoProvider which uses the SubtleCrypto interface of the Web Crypto API.
  *
  * This only supports asynchronous operations.
  */
-declare class SubtleCryptoProvider extends CryptoProvider {
+export declare class SubtleCryptoProvider extends CryptoProvider {
     subtleCrypto: SubtleCrypto;
     constructor(subtleCrypto?: SubtleCrypto);
     computeHMACSignature(_payload: string, _secret: string): string;
@@ -21,5 +20,3 @@ declare class SubtleCryptoProvider extends CryptoProvider {
     decrypt(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, tag: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
     randomBytes(length: number): Uint8Array;
 }
-
-export { SubtleCryptoProvider };

package/lib/common/crypto/subtle-crypto-provider.js

@@ -1,129 +1,123 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-import { CryptoProvider } from "./crypto-provider";
-class SubtleCryptoProvider extends CryptoProvider {
-  static {
-    __name(this, "SubtleCryptoProvider");
-  }
-  subtleCrypto;
-  constructor(subtleCrypto) {
-    super();
-    this.subtleCrypto = subtleCrypto || crypto.subtle;
-  }
-  computeHMACSignature(_payload, _secret) {
-    throw new Error(
-      "SubleCryptoProvider cannot be used in a synchronous context."
-    );
-  }
-  /** @override */
-  async computeHMACSignatureAsync(payload, secret) {
-    const encoder = new TextEncoder();
-    const key = await this.subtleCrypto.importKey(
-      "raw",
-      encoder.encode(secret),
-      {
-        name: "HMAC",
-        hash: { name: "SHA-256" }
-      },
-      false,
-      ["sign"]
-    );
-    const signatureBuffer = await this.subtleCrypto.sign(
-      "hmac",
-      key,
-      encoder.encode(payload)
-    );
-    const signatureBytes = new Uint8Array(signatureBuffer);
-    const signatureHexCodes = new Array(signatureBytes.length);
-    for (let i = 0; i < signatureBytes.length; i++) {
-      signatureHexCodes[i] = byteHexMapping[signatureBytes[i]];
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubtleCryptoProvider = void 0;
+const crypto_provider_1 = require("./crypto-provider");
+/**
+ * `CryptoProvider which uses the SubtleCrypto interface of the Web Crypto API.
+ *
+ * This only supports asynchronous operations.
+ */
+class SubtleCryptoProvider extends crypto_provider_1.CryptoProvider {
+    constructor(subtleCrypto) {
+        super();
+        // If no subtle crypto is interface, default to the global namespace. This
+        // is to allow custom interfaces (eg. using the Node webcrypto interface in
+        // tests).
+        this.subtleCrypto = subtleCrypto || crypto.subtle;
+    }
+    computeHMACSignature(_payload, _secret) {
+        throw new Error('SubleCryptoProvider cannot be used in a synchronous context.');
+    }
+    /** @override */
+    computeHMACSignatureAsync(payload, secret) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoder = new TextEncoder();
+            const key = yield this.subtleCrypto.importKey('raw', encoder.encode(secret), {
+                name: 'HMAC',
+                hash: { name: 'SHA-256' },
+            }, false, ['sign']);
+            const signatureBuffer = yield this.subtleCrypto.sign('hmac', key, encoder.encode(payload));
+            // 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('');
+        });
     }
-    return signatureHexCodes.join("");
-  }
-  /** @override */
-  async secureCompare(stringA, stringB) {
-    const bufferA = this.encoder.encode(stringA);
-    const bufferB = this.encoder.encode(stringB);
-    if (bufferA.length !== bufferB.length) {
-      return false;
+    /** @override */
+    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;
+        });
     }
-    const algorithm = { name: "HMAC", hash: "SHA-256" };
-    const key = await crypto.subtle.generateKey(algorithm, false, [
-      "sign",
-      "verify"
-    ]);
-    const hmac = await crypto.subtle.sign(algorithm, key, bufferA);
-    const equal = await crypto.subtle.verify(algorithm, key, hmac, bufferB);
-    return equal;
-  }
-  async encrypt(plaintext, key, iv, aad) {
-    const actualIv = iv || crypto.getRandomValues(new Uint8Array(32));
-    const cryptoKey = await this.subtleCrypto.importKey(
-      "raw",
-      key,
-      { name: "AES-GCM" },
-      false,
-      ["encrypt"]
-    );
-    const encryptParams = {
-      name: "AES-GCM",
-      iv: actualIv
-    };
-    if (aad) {
-      encryptParams.additionalData = aad;
+    encrypt(plaintext, key, iv, aad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const actualIv = iv || crypto.getRandomValues(new Uint8Array(32));
+            const cryptoKey = yield this.subtleCrypto.importKey('raw', key, { name: 'AES-GCM' }, false, ['encrypt']);
+            const encryptParams = {
+                name: 'AES-GCM',
+                iv: actualIv,
+            };
+            if (aad) {
+                encryptParams.additionalData = aad;
+            }
+            const encryptedData = yield this.subtleCrypto.encrypt(encryptParams, cryptoKey, plaintext);
+            const encryptedBytes = new Uint8Array(encryptedData);
+            // Extract tag (last 16 bytes)
+            const tagSize = 16;
+            const tagStart = encryptedBytes.length - tagSize;
+            const tag = encryptedBytes.slice(tagStart);
+            const ciphertext = encryptedBytes.slice(0, tagStart);
+            return {
+                ciphertext,
+                iv: actualIv,
+                tag,
+            };
+        });
     }
-    const encryptedData = await this.subtleCrypto.encrypt(
-      encryptParams,
-      cryptoKey,
-      plaintext
-    );
-    const encryptedBytes = new Uint8Array(encryptedData);
-    const tagSize = 16;
-    const tagStart = encryptedBytes.length - tagSize;
-    const tag = encryptedBytes.slice(tagStart);
-    const ciphertext = encryptedBytes.slice(0, tagStart);
-    return {
-      ciphertext,
-      iv: actualIv,
-      tag
-    };
-  }
-  async decrypt(ciphertext, key, iv, tag, aad) {
-    const combinedData = new Uint8Array(ciphertext.length + tag.length);
-    combinedData.set(ciphertext, 0);
-    combinedData.set(tag, ciphertext.length);
-    const cryptoKey = await this.subtleCrypto.importKey(
-      "raw",
-      key,
-      { name: "AES-GCM" },
-      false,
-      ["decrypt"]
-    );
-    const decryptParams = {
-      name: "AES-GCM",
-      iv
-    };
-    if (aad) {
-      decryptParams.additionalData = aad;
+    decrypt(ciphertext, key, iv, tag, aad) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // SubtleCrypto expects tag to be appended to ciphertext for AES-GCM
+            const combinedData = new Uint8Array(ciphertext.length + tag.length);
+            combinedData.set(ciphertext, 0);
+            combinedData.set(tag, ciphertext.length);
+            const cryptoKey = yield this.subtleCrypto.importKey('raw', key, { name: 'AES-GCM' }, false, ['decrypt']);
+            const decryptParams = {
+                name: 'AES-GCM',
+                iv,
+            };
+            if (aad) {
+                decryptParams.additionalData = aad;
+            }
+            const decryptedData = yield this.subtleCrypto.decrypt(decryptParams, cryptoKey, combinedData);
+            return new Uint8Array(decryptedData);
+        });
+    }
+    randomBytes(length) {
+        const bytes = new Uint8Array(length);
+        crypto.getRandomValues(bytes);
+        return bytes;
     }
-    const decryptedData = await this.subtleCrypto.decrypt(
-      decryptParams,
-      cryptoKey,
-      combinedData
-    );
-    return new Uint8Array(decryptedData);
-  }
-  randomBytes(length) {
-    const bytes = new Uint8Array(length);
-    crypto.getRandomValues(bytes);
-    return bytes;
-  }
 }
+exports.SubtleCryptoProvider = SubtleCryptoProvider;
+// 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");
+    byteHexMapping[i] = i.toString(16).padStart(2, '0');
 }
-export {
-  SubtleCryptoProvider
-};
-//# sourceMappingURL=subtle-crypto-provider.js.map

package/lib/common/exceptions/bad-request.exception.d.ts

@@ -1,6 +1,5 @@
-import { RequestException } from '../interfaces/request-exception.interface.js';
-
-declare class BadRequestException extends Error implements RequestException {
+import { RequestException } from '../interfaces/request-exception.interface';
+export declare class BadRequestException extends Error implements RequestException {
     readonly status = 400;
     readonly name = "BadRequestException";
     readonly message: string;
@@ -14,5 +13,3 @@ declare class BadRequestException extends Error implements RequestException {
         requestID: string;
     });
 }
-
-export { BadRequestException };

package/lib/common/exceptions/bad-request.exception.js

@@ -1,35 +1,22 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadRequestException = void 0;
 class BadRequestException extends Error {
-  static {
-    __name(this, "BadRequestException");
-  }
-  status = 400;
-  name = "BadRequestException";
-  message = "Bad request";
-  code;
-  errors;
-  requestID;
-  constructor({
-    code,
-    errors,
-    message,
-    requestID
-  }) {
-    super();
-    this.requestID = requestID;
-    if (message) {
-      this.message = message;
+    constructor({ code, errors, message, requestID, }) {
+        super();
+        this.status = 400;
+        this.name = 'BadRequestException';
+        this.message = 'Bad request';
+        this.requestID = requestID;
+        if (message) {
+            this.message = message;
+        }
+        if (code) {
+            this.code = code;
+        }
+        if (errors) {
+            this.errors = errors;
+        }
     }
-    if (code) {
-      this.code = code;
-    }
-    if (errors) {
-      this.errors = errors;
-    }
-  }
 }
-export {
-  BadRequestException
-};
-//# sourceMappingURL=bad-request.exception.js.map
+exports.BadRequestException = BadRequestException;

package/lib/common/exceptions/conflict.exception.d.ts

@@ -1,6 +1,5 @@
-import { RequestException } from '../interfaces/request-exception.interface.js';
-
-declare class ConflictException extends Error implements RequestException {
+import { RequestException } from '../interfaces/request-exception.interface';
+export declare class ConflictException extends Error implements RequestException {
     readonly status = 409;
     readonly name = "ConflictException";
     readonly requestID: string;
@@ -10,5 +9,3 @@ declare class ConflictException extends Error implements RequestException {
         requestID: string;
     });
 }
-
-export { ConflictException };