@agnostack/next-shopify 1.15.0-beta.9 → 1.15.0

package/dist/umd/{verification.js → verification/index.js}

@@ -1,7 +1,7 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@agnostack/next-shopify/umd-verification"] = {}));
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@agnostack/next-shopify/verification"] = {}));
 })(this, (function (exports) { 'use strict';
 
   const COLLECTION_ROOT = 'oauth-data';
@@ -227,11 +227,41 @@
     ONLINE: 'online',
   };
 
-  var n,r=((n=function(){return r}).toString=n.toLocaleString=n[Symbol.toPrimitive]=function(){return ""},n.valueOf=function(){return !1},new Proxy(Object.freeze(n),{get:function(n,t){return n.hasOwnProperty(t)?n[t]:r}})),u=function(n){return n===r};
+  class VerificationError extends Error {
+    constructor(message, _data) {
+      super(message);
+      const { code = 500, ...data } = _data ?? {};
+      this.code = code;
+      this.data = data;
+      this.name = 'VerificationError';
+      Object.setPrototypeOf(this, VerificationError.prototype);
+    }
+  }
 
-  let win = global.window;
-  let exists = (variable) => !u(variable);
-  let window = typeof win !== "undefined" ? win : r;
+  const getChunkedRawBody = async (readable) => {
+    if (readable?.rawBody) {
+      return readable.rawBody
+    }
+
+    // TODO: move to req.text() after next 13.5: https://github.com/vercel/next.js/discussions/13405
+    try {
+      const getRawBody = (await Promise.resolve().then(function () { return index; })).default;
+      return getRawBody(readable)
+    } catch (error) {
+      console.error(`Failed to import 'raw-body', please ensure the dependency is installed`);
+      throw error
+    }
+  };
+
+  // TODO: explore returning mutated request object adding on req.rawBody??
+  const ensureRawBody = async (req) => (
+    getChunkedRawBody(req)
+      .then((_rawBody) => _rawBody.toString())
+      .catch((error) => {
+        console.error(`Error getting raw body for '${req?.url}'`, error);
+        throw error
+    })
+  );
 
   /* eslint-disable no-use-before-define */
 
@@ -333,438 +363,429 @@
     return ![...ensureArray(falsy), '', 'false'].includes(string)
   };
 
-  const getWebCrypto = async () => {
-    try {
-      const crypto = (await import('isomorphic-webcrypto')).default;
-      return crypto
-    } catch (error) {
-      console.error('Failed to import isomorphic-webcrypto', error);
-      throw error
-    }
-  };
+  const TEMP_HOSTNAME = 'xyz.com';
+  const REMOVABLE_KEYS = ['shop', 'host'];
 
-  const getTextDecoder = async () => {
-    if (exists(window) && (typeof window?.TextDecoder === 'function')) {
-      return window.TextDecoder
-    }
+  const getRequestMethod = (body, _method) => {
+    const method = _method ?? (body ? 'POST' : 'GET');
 
-    try {
-      const TextDecoder = (await import('util')).TextDecoder;
-      return TextDecoder
-    } catch (error) {
-      console.error('Failed to import utils.TextDecoder', error);
-      throw error
-    }
+    return uppercase(method)
   };
 
-  const getTextEncoder = async () => {
-    if (exists(window) && (typeof window?.TextEncoder === 'function')) {
-      return window.TextEncoder
-    }
-
-    try {
-      const TextEncoder = (await import('util')).TextEncoder;
-      return TextEncoder
-    } catch (error) {
-      console.error('Failed to import utils.TextEncoder', error);
-      throw error
+  const convertToURL = (uri) => {
+    if (stringEmpty(uri)) {
+      return undefined
     }
-  };
 
-  const timingSafeEqual = (value1, value2) => {
-    if (
-      (value1 == undefined) ||
-      (value2 == undefined) ||
-      (value1.length !== value2.length)
-    ) {
-      return false
-    }
+    const protocolRegex = /^(https?:\/\/).+/i;
 
-    let result = 0;
-    // eslint-disable-next-line no-plusplus
-    for (let i = 0; i < value1.length; i++) {
-      // eslint-disable-next-line no-bitwise
-      result |= value1[i] ^ value2[i];
+    if (!protocolRegex.test(uri)) {
+      return new URL(`https://${TEMP_HOSTNAME}${ensureLeadingSlash(uri)}`)
     }
 
-    return (result === 0)
+    return new URL(uri)
   };
 
-  const stringToHex = (stringValue) => (
-    Array.from(ensureString(stringValue), (char) => (
-      char.charCodeAt(0).toString(16).padStart(2, '0')
-    )).join('')
-  );
+  const normalizeURIParts = (uri) => {
+    const urlObject = convertToURL(uri);
+    if (!urlObject) {
+      return undefined
+    }
 
-  const hexToString = (hexValue) => (
-    ensureArray(
-      ensureString(hexValue).match(/.{1,2}/g)
-    )
-      .map((byte) => String.fromCharCode(parseInt(byte, 16)))
-      .join('')
-  );
+    REMOVABLE_KEYS.forEach((key) => urlObject.searchParams.delete(key));
 
-  const arrayBufferToString = async (arrayBuffer) => {
-    const uint8Array = new Uint8Array(arrayBuffer);
-    const Decoder = await getTextDecoder();
-    return new Decoder().decode(uint8Array)
+    return {
+      ...(urlObject.hostname !== TEMP_HOSTNAME) && {
+        origin: urlObject.origin,
+      },
+      pathname: urlObject.pathname,
+      search: urlObject.search,
+    }
   };
 
-  const arrayToArrayBuffer = (array) => (
-    (ArrayBuffer.from != undefined)
-      ? ArrayBuffer.from(array)
-      : new Uint8Array(array).buffer
-  );
+  var n,r=((n=function(){return r}).toString=n.toLocaleString=n[Symbol.toPrimitive]=function(){return ""},n.valueOf=function(){return !1},new Proxy(Object.freeze(n),{get:function(n,t){return n.hasOwnProperty(t)?n[t]:r}})),u=function(n){return n===r};
 
-  const ensureArrayBuffer = (arrayOrArrayBuffer) => (
-    (arrayOrArrayBuffer instanceof ArrayBuffer)
-      ? arrayOrArrayBuffer
-      : arrayToArrayBuffer(arrayOrArrayBuffer)
-  );
+  let win = global.window;
+  let exists = (variable) => !u(variable);
+  let window = typeof win !== "undefined" ? win : r;
 
-  const generateKeyPair = async () => {
-    const crypto = await getWebCrypto();
-    const keyPair = await crypto.subtle.generateKey(
-      {
-        name: 'ECDH',
-        namedCurve: 'P-256',
-      },
-      true,
-      ['deriveKey']
-    );
+  class WebCrypto {
+    constructor({ crypto: _crypto, util: _util } = {}) {
+      this._crypto = _crypto ?? {};
+      this._util = _util ?? {};
+    }
 
-    return keyPair
-  };
+    get subtle() {
+      return this._crypto?.subtle
+    }
 
-  const getKeyOperations = (keyType) => {
-    switch (keyType) {
-      case 'private':
-      case 'privateKey': {
-        return ['deriveKey']
+    async getWebCrypto() {
+      if (!this._crypto?.subtle) {
+        try {
+          this._crypto = (await import('isomorphic-webcrypto')).default;
+        } catch (_ignore) {
+          console.info('Failed to import isomorphic-webcrypto, retrying w/ node crypto');
+          try {
+            this._crypto = (await import('crypto')).default;
+          } catch (error) {
+            // eslint-disable-next-line max-len
+            console.error(`Failed to import node crypto, ensure 'isomorphic-webcrypto' (or node 'crypto') is installed and/or pass in implementation via 'new WebCrypto({ crypto })'`);
+            throw error
+          }
+        }
       }
 
-      case 'secret':
-      case 'secretKey':
-      case 'sharedSecret': {
-        return ['encrypt', 'decrypt'] 
+      if (!this._crypto?.subtle) {
+        throw new Error('Invalid crypto, missing subtle')
       }
 
-      default: {
-        return []
-      }
+      return this._crypto
     }
-  };
 
-  const getKeyAlgorythm = (keyType) => {
-    switch (keyType) {
-      case 'derivedKey':
-      case 'derived':
-      case 'secret':
-      case 'secretKey':
-      case 'sharedSecret': {
-        return {
-          name: 'AES-GCM',
-        }
+    async getTextDecoder() {
+      if (this._util?.TextDecoder) {
+        return this._util.TextDecoder
       }
 
-      default: {
-        return {
-          name: 'ECDH',
-          namedCurve: 'P-256',
-        }
+      if (exists(window) && typeof window?.TextDecoder === 'function') {
+        return window.TextDecoder
       }
-    }
-  };
 
-  const generateHMAC = async (message, derivedKey) => {
-    if (!message || !derivedKey) {
-      return undefined
-    } 
+      try {
+        const TextDecoder = (await import('util')).TextDecoder;
+        this._util.TextDecoder = TextDecoder;
 
-    const crypto = await getWebCrypto();
-    const Encoder = await getTextEncoder();
+        return TextDecoder
+      } catch (error) {
+        console.error(`Failed to import 'utils.TextDecoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+        throw error
+      }
+    }
 
-    const signature = await crypto.subtle.sign(
-      'HMAC',
-      derivedKey,
-      new Encoder().encode(message)
-    );
+    async getTextEncoder() {
+      if (this._util?.TextEncoder) {
+        return this._util.TextEncoder
+      }
 
-    return stringToHex(
-      arrayBufferToString(signature)
-    )
-  };
+      if (exists(window) && typeof window?.TextEncoder === 'function') {
+        return window.TextEncoder
+      }
 
-  const verifyHMAC = async (message, derivedKey, verifiableHMAC) => {
-    const calculatedHMAC = await generateHMAC(message, derivedKey);
+      try {
+        const TextEncoder = (await import('util')).TextEncoder;
+        this._util.TextEncoder = TextEncoder;
 
-    return timingSafeEqual(calculatedHMAC, verifiableHMAC)
-  };
+        return TextEncoder
+      } catch (error) {
+        console.error(`Failed to import 'utils.TextEncoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+        throw error
+      }
+    }
 
-  const getStorableKey = async (key) => {
-    const crypto = await getWebCrypto();
+    timingSafeEqual(value1, value2) {
+      if (
+        (value1 == undefined) ||
+        (value2 == undefined) ||
+        (value1.length !== value2.length)
+      ) {
+        return false
+      }
 
-    const exportedJWK = await crypto.subtle.exportKey('jwk', key);
-    return stringToHex(JSON.stringify(exportedJWK))
-  };
+      let result = 0;
+      // eslint-disable-next-line no-plusplus
+      for (let i = 0; i < value1.length; i++) {
+        // eslint-disable-next-line no-bitwise
+        result |= value1[i] ^ value2[i];
+      }
 
-  const restoreStorableKey = async (keyType, storableHex) => {
-    if (!storableHex) {
-      return undefined
+      return (result === 0)
     }
-    const crypto = await getWebCrypto();
 
-    const exportedJWK = JSON.parse(hexToString(storableHex) || '{}');
-    if (objectEmpty(exportedJWK)) {
-      return undefined
+    stringToHex(stringValue) {
+      return (
+        Array.from(ensureString(stringValue), (char) => (
+          char.charCodeAt(0).toString(16).padStart(2, '0')
+        )).join('')
+      )
     }
 
-    return crypto.subtle.importKey(
-      'jwk',
-      exportedJWK,
-      getKeyAlgorythm(keyType),
-      true,
-      getKeyOperations(keyType)
-    )
-  };
+    hexToString(hexValue) {
+      return (
+        ensureArray(
+          ensureString(hexValue).match(/.{1,2}/g)
+        )
+        .map((byte) => String.fromCharCode(parseInt(byte, 16)))
+        .join('')
+      )
+    }
 
-  const getStorableKeyPair = async (keyPair) => {
-    const storableKeys = {};
+    async arrayBufferToString(arrayBuffer) {
+      const uint8Array = new Uint8Array(arrayBuffer);
+      const Decoder = await this.getTextDecoder();
+      return new Decoder().decode(uint8Array)
+    }
 
-    // eslint-disable-next-line no-restricted-syntax
-    for (const [keyType, key] of Object.entries(keyPair)) {
-      // eslint-disable-next-line no-await-in-loop
-      storableKeys[keyType] = await getStorableKey(key);
+    arrayToArrayBuffer(array) {
+      return (
+        (ArrayBuffer.from != undefined)
+          ? ArrayBuffer.from(array)
+          : new Uint8Array(array).buffer
+      )
     }
 
-    return storableKeys
-  };
+    ensureArrayBuffer(arrayOrArrayBuffer) {
+      return (
+        (arrayOrArrayBuffer instanceof ArrayBuffer)
+          ? arrayOrArrayBuffer
+          : this.arrayToArrayBuffer(arrayOrArrayBuffer)
+      )
+    }
 
-  const restoreStorableKeyPair = async (keyPair) => {
-    const restoredKeys = {};
+    async generateKeyPair() {
+      const crypto = await this.getWebCrypto();
+      const keyPair = await crypto.subtle.generateKey(
+        {
+          name: 'ECDH',
+          namedCurve: 'P-256',
+        },
+        true,
+        ['deriveKey']
+      );
 
-    // eslint-disable-next-line no-restricted-syntax
-    for (const [keyType, key] of Object.entries(keyPair)) {
-      // eslint-disable-next-line no-await-in-loop
-      restoredKeys[keyType] = await restoreStorableKey(keyType, key);
+      return keyPair
     }
 
-    return restoredKeys
-  };
+    getKeyOperations(keyType) {
+      switch (keyType) {
+        case 'private':
+        case 'privateKey': {
+          return ['deriveKey']
+        }
 
-  const deriveSharedKey = async ({ publicKey, privateKey }) => {
-    if (!publicKey || !privateKey) {
-      return undefined
+        case 'secret':
+        case 'secretKey':
+        case 'sharedSecret': {
+          return ['encrypt', 'decrypt'] 
+        }
+
+        default: {
+          return []
+        }
+      }
     }
 
-    const crypto = await getWebCrypto();
-    const derivedKey = await crypto.subtle.deriveKey(
-      {
-        name: 'ECDH',
-        public: publicKey,
-      },
-      privateKey,
-      {
-        name: 'AES-GCM',
-        length: 256,
-      },
-      true,
-      ['encrypt', 'decrypt']
-    );
-    return derivedKey
-  };
+    getKeyAlgorythm(keyType) {
+      switch (keyType) {
+        case 'derivedKey':
+        case 'derived':
+        case 'secret':
+        case 'secretKey':
+        case 'sharedSecret': {
+          return {
+            name: 'AES-GCM',
+          }
+        }
 
-  const deriveHMACKey = async ({ publicKey, privateKey }) => {
-    if (!publicKey || !privateKey) {
-      return undefined
+        default: {
+          return {
+            name: 'ECDH',
+            namedCurve: 'P-256',
+          }
+        }
+      }
     }
 
-    const crypto = await getWebCrypto();
-    const derivedKey = await crypto.subtle.deriveKey(
-      {
-        name: 'ECDH',
-        public: publicKey,
-      },
-      privateKey,
-      {
-        name: 'HMAC',
-        hash: { name: 'SHA-256' },
-        length: 256,  // Adjusted key length, e.g., 128 bits
-      },
-      true,
-      ['sign', 'verify']
-    );
-    return derivedKey
-  };
+    async generateHMAC(message, derivedKey) {
+      if (!message || !derivedKey) {
+        return undefined
+      } 
 
-  const getVerificationKeys = async ({ publicKey, privateKey }) => {
-    if (!publicKey || !privateKey) {
-      return {}
-    }
+      const crypto = await this.getWebCrypto();
+      const Encoder = await this.getTextEncoder();
 
-    const sharedKeyPair = await restoreStorableKeyPair({ publicKey, privateKey });
-    const derivedHMACKey = await deriveHMACKey(sharedKeyPair);
-    const derivedSecretKey = await deriveSharedKey(sharedKeyPair);
+      const signature = await crypto.subtle.sign(
+        'HMAC',
+        derivedKey,
+        new Encoder().encode(message)
+      );
 
-    return {
-      derivedSecretKey,
-      derivedHMACKey,
+      return this.stringToHex(
+        this.arrayBufferToString(signature)
+      )
     }
-  };
 
-  const encryptMessage = async (decryptedMessage, derivedKey) => {
-    if (!decryptedMessage || !derivedKey) {
-      return undefined
+    async verifyHMAC(message, derivedKey, verifiableHMAC) {
+      const calculatedHMAC = await this.generateHMAC(message, derivedKey);
+
+      return this.timingSafeEqual(calculatedHMAC, verifiableHMAC)
     }
 
-    const crypto = await getWebCrypto();
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const Encoder = await getTextEncoder();
-    const encodedMessage = new Encoder().encode(decryptedMessage);
-    const ciphertext = await crypto.subtle.encrypt(
-      {
-        name: 'AES-GCM',
-        iv,
-      },
-      derivedKey,
-      encodedMessage
-    );
-
-    const encryptedMessage = new Uint8Array([
-      ...iv,
-      ...new Uint8Array(ciphertext)
-    ]);
-    return Array.from(encryptedMessage)
-  };
+    async getStorableKey(key) {
+      const crypto = await this.getWebCrypto();
 
-  const decryptMessage = async (encryptedMessage, derivedKey) => {
-    if (!encryptedMessage || !derivedKey) {
-      return undefined
+      const exportedJWK = await crypto.subtle.exportKey('jwk', key);
+      return this.stringToHex(JSON.stringify(exportedJWK))
     }
 
-    const crypto = await getWebCrypto();
-    // NOTE: this presumed an array or arrayBuffer coming in as encryptedMessage (will fail w/ IV error if its a string)
-    const encryptedArrayBuffer = ensureArrayBuffer(encryptedMessage);
-    const iv = encryptedArrayBuffer.slice(0, 12);
-    const ciphertext = encryptedArrayBuffer.slice(12);
+    async restoreStorableKey(keyType, storableHex) {
+      if (!storableHex) {
+        return undefined
+      }
+      const crypto = await this.getWebCrypto();
 
-    const decryptedArrayBuffer = await crypto.subtle.decrypt(
-      {
-        name: 'AES-GCM',
-        iv,
-      },
-      derivedKey,
-      ciphertext
-    );
+      const exportedJWK = JSON.parse(this.hexToString(storableHex) || '{}');
+      if (objectEmpty(exportedJWK)) {
+        return undefined
+      }
 
-    const Decoder = await getTextDecoder();
-    const decryptedMessage = new Decoder().decode(decryptedArrayBuffer);
-    return decryptedMessage
-  };
+      return crypto.subtle.importKey(
+        'jwk',
+        exportedJWK,
+        this.getKeyAlgorythm(keyType),
+        true,
+        this.getKeyOperations(keyType)
+      )
+    }
 
-  const subtle = {
-    generateKeyPair,
-    generateHMAC,
-    verifyHMAC,
-    getStorableKey,
-    getStorableKeyPair,
-    restoreStorableKeyPair,
-    deriveSharedKey,
-    deriveHMACKey,
-    getVerificationKeys,
-    encryptMessage,
-    decryptMessage,
-  };
+    async getStorableKeyPair(keyPair) {
+      const storableKeys = {};
 
-  const TEMP_HOSTNAME = 'xyz.com';
-  const REMOVABLE_KEYS = ['shop', 'host'];
+      // eslint-disable-next-line no-restricted-syntax
+      for (const [keyType, key] of Object.entries(keyPair)) {
+        // eslint-disable-next-line no-await-in-loop
+        storableKeys[keyType] = await this.getStorableKey(key);
+      }
 
-  const getRequestMethod = (body, _method) => {
-    const method = _method ?? (body ? 'POST' : 'GET');
+      return storableKeys
+    }
 
-    return uppercase(method)
-  };
+    async restoreStorableKeyPair(keyPair) {
+      const restoredKeys = {};
 
-  const convertToURL = (uri) => {
-    if (stringEmpty(uri)) {
-      return undefined
+      // eslint-disable-next-line no-restricted-syntax
+      for (const [keyType, key] of Object.entries(keyPair)) {
+        // eslint-disable-next-line no-await-in-loop
+        restoredKeys[keyType] = await this.restoreStorableKey(keyType, key);
+      }
+
+      return restoredKeys
     }
 
-    const protocolRegex = /^(https?:\/\/).+/i;
+    async deriveSharedKey({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return undefined
+      }
 
-    if (!protocolRegex.test(uri)) {
-      return new URL(`https://${TEMP_HOSTNAME}${ensureLeadingSlash(uri)}`)
+      const crypto = await this.getWebCrypto();
+      const derivedKey = await crypto.subtle.deriveKey(
+        {
+          name: 'ECDH',
+          public: publicKey,
+        },
+        privateKey,
+        {
+          name: 'AES-GCM',
+          length: 256,
+        },
+        true,
+        ['encrypt', 'decrypt']
+      );
+      return derivedKey
     }
 
-    return new URL(uri)
-  };
+    async deriveHMACKey({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return undefined
+      }
 
-  const normalizeURIParts = (uri) => {
-    const urlObject = convertToURL(uri);
-    if (!urlObject) {
-      return undefined
+      const crypto = await this.getWebCrypto();
+      const derivedKey = await crypto.subtle.deriveKey(
+        {
+          name: 'ECDH',
+          public: publicKey,
+        },
+        privateKey,
+        {
+          name: 'HMAC',
+          hash: { name: 'SHA-256' },
+          length: 256,  // Adjusted key length, e.g., 128 bits
+        },
+        true,
+        ['sign', 'verify']
+      );
+      return derivedKey
     }
 
-    REMOVABLE_KEYS.forEach((key) => urlObject.searchParams.delete(key));
+    async getVerificationKeys({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return {}
+      }
 
-    return {
-      ...(urlObject.hostname !== TEMP_HOSTNAME) && {
-        origin: urlObject.origin,
-      },
-      pathname: urlObject.pathname,
-      search: urlObject.search,
-    }
-  };
+      const sharedKeyPair = await this.restoreStorableKeyPair({ publicKey, privateKey });
+      const derivedHMACKey = await this.deriveHMACKey(sharedKeyPair);
+      const derivedSecretKey = await this.deriveSharedKey(sharedKeyPair);
 
-  class VerificationError extends Error {
-    constructor(message, _data) {
-      super(message);
-      const { code = 500, ...data } = _data ?? {};
-      this.code = code;
-      this.data = data;
-      this.name = 'VerificationError';
-      Object.setPrototypeOf(this, VerificationError.prototype);
+      return {
+        derivedSecretKey,
+        derivedHMACKey,
+      }
     }
-  }
-
-  // import getRawBody from 'raw-body'
-  // import * as getRawBody from 'raw-body'
 
-  const getChunkedRawBody = async (readable) => {
-    const chunks = [];
+    async encryptMessage(decryptedMessage, derivedKey) {
+      if (!decryptedMessage || !derivedKey) {
+        return undefined
+      }
 
-    for await (const chunk of readable) {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+      const crypto = await this.getWebCrypto();
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const Encoder = await this.getTextEncoder();
+      const encodedMessage = new Encoder().encode(decryptedMessage);
+      const ciphertext = await crypto.subtle.encrypt(
+        {
+          name: 'AES-GCM',
+          iv,
+        },
+        derivedKey,
+        encodedMessage
+      );
+
+      const encryptedMessage = new Uint8Array([
+        ...iv,
+        ...new Uint8Array(ciphertext)
+      ]);
+      return Array.from(encryptedMessage)
     }
 
-    return Buffer.concat(chunks)
-  };
+    async decryptMessage(encryptedMessage, derivedKey) {
+      if (!encryptedMessage || !derivedKey) {
+        return undefined
+      }
 
-  // TODO: explore returning mutated request object adding on req.rawBody??
-  // TODO: move to req.text() after next 13.5: https://github.com/vercel/next.js/discussions/13405
-  const ensureRawBody = async (req) => (
-    getChunkedRawBody(req)
-    // getRawBody(req)
-      .then((_rawBody) => _rawBody.toString())
-      .catch((error) => {
-        // NOTE: this is intended to ensure if getRawBody is called 2x w/in a route that it returns the already streamed body
-        if ((error?.type === 'stream.not.readable')) {
-          if (!req?.rawBody) {
-            // eslint-disable-next-line max-len
-            console.info('Ignoring error reading raw requst body. This can occur if the body is attempted to be read twice in a single request. If intentional, please mutate the request to add the result of this call as req.rawBody (to prevent this warning).');
-            return req?.body
-          }
+      const crypto = await this.getWebCrypto();
+      // NOTE: this presumed an array or arrayBuffer coming in as encryptedMessage (will fail w/ IV error if its a string)
+      const encryptedArrayBuffer = this.ensureArrayBuffer(encryptedMessage);
+      const iv = encryptedArrayBuffer.slice(0, 12);
+      const ciphertext = encryptedArrayBuffer.slice(12);
 
-          return req?.rawBody
-        }
+      const decryptedArrayBuffer = await crypto.subtle.decrypt(
+        {
+          name: 'AES-GCM',
+          iv,
+        },
+        derivedKey,
+        ciphertext
+      );
+
+      const Decoder = await this.getTextDecoder();
+      const decryptedMessage = new Decoder().decode(decryptedArrayBuffer);
+      return decryptedMessage
+    }
+  }
 
-        console.error(`Error getting raw body for '${req?.url}'`, error);
-        throw error
-    })
-  );
+  const getVerificationHelpers = ({ keyPairs, crypto: _crypto, util: _util  } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
 
-  const getVerificationHelpers = ({ keyPairs }) => (
-    async (req, params) => {
+    return async (req, params) => {
       const {
         'x-public-key': apiKey,
         'x-ephemeral-key': ephemeralPublicKey,
@@ -808,7 +829,7 @@
             throw new VerificationError('Invalid or missing authorization', { code: 401 })
           }
 
-          verificationKeys = await subtle.getVerificationKeys({
+          verificationKeys = await webCrypto.getVerificationKeys({
             publicKey: ephemeralPublicKey,
             privateKey: keyPairs.shared.privateKey,
           });
@@ -824,7 +845,7 @@
             ...normalizeURIParts(uri),
           });
 
-          const isValid = await subtle.verifyHMAC(
+          const isValid = await webCrypto.verifyHMAC(
             verificationPayload,
             verificationKeys.derivedHMACKey,
             authSignature
@@ -835,7 +856,7 @@
           }
 
           if (!disableRecryption && requestBody) {
-            const decryptedMessage = await subtle.decryptMessage(requestBody, verificationKeys.derivedSecretKey);
+            const decryptedMessage = await webCrypto.decryptMessage(requestBody, verificationKeys.derivedSecretKey);
             requestBody = safeParse(decryptedMessage);
           }
         }
@@ -845,7 +866,7 @@
             return response
           }
 
-          return subtle.encryptMessage(JSON.stringify(response), verificationKeys.derivedSecretKey)
+          return webCrypto.encryptMessage(JSON.stringify(response), verificationKeys.derivedSecretKey)
         };
 
         return { rawBody, requestBody, processResponse }
@@ -854,7 +875,346 @@
         throw error
       }
     }
-  );
+  };
+
+  /*!
+   * raw-body
+   * Copyright(c) 2013-2014 Jonathan Ong
+   * Copyright(c) 2014-2022 Douglas Christopher Wilson
+   * MIT Licensed
+   */
+
+  /**
+   * Module dependencies.
+   * @private
+   */
+
+  var asyncHooks = tryRequireAsyncHooks();
+  var bytes = require('bytes');
+  var createError = require('http-errors');
+  var iconv = require('iconv-lite');
+  var unpipe = require('unpipe');
+
+  /**
+   * Module exports.
+   * @public
+   */
+
+  module.exports = getRawBody;
+
+  /**
+   * Module variables.
+   * @private
+   */
+
+  var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
+
+  /**
+   * Get the decoder for a given encoding.
+   *
+   * @param {string} encoding
+   * @private
+   */
+
+  function getDecoder (encoding) {
+    if (!encoding) return null
+
+    try {
+      return iconv.getDecoder(encoding)
+    } catch (e) {
+      // error getting decoder
+      if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e
+
+      // the encoding was not found
+      throw createError(415, 'specified encoding unsupported', {
+        encoding: encoding,
+        type: 'encoding.unsupported'
+      })
+    }
+  }
+
+  /**
+   * Get the raw body of a stream (typically HTTP).
+   *
+   * @param {object} stream
+   * @param {object|string|function} [options]
+   * @param {function} [callback]
+   * @public
+   */
+
+  function getRawBody (stream, options, callback) {
+    var done = callback;
+    var opts = options || {};
+
+    // light validation
+    if (stream === undefined) {
+      throw new TypeError('argument stream is required')
+    } else if (typeof stream !== 'object' || stream === null || typeof stream.on !== 'function') {
+      throw new TypeError('argument stream must be a stream')
+    }
+
+    if (options === true || typeof options === 'string') {
+      // short cut for encoding
+      opts = {
+        encoding: options
+      };
+    }
+
+    if (typeof options === 'function') {
+      done = options;
+      opts = {};
+    }
+
+    // validate callback is a function, if provided
+    if (done !== undefined && typeof done !== 'function') {
+      throw new TypeError('argument callback must be a function')
+    }
+
+    // require the callback without promises
+    if (!done && !global.Promise) {
+      throw new TypeError('argument callback is required')
+    }
+
+    // get encoding
+    var encoding = opts.encoding !== true
+      ? opts.encoding
+      : 'utf-8';
+
+    // convert the limit to an integer
+    var limit = bytes.parse(opts.limit);
+
+    // convert the expected length to an integer
+    var length = opts.length != null && !isNaN(opts.length)
+      ? parseInt(opts.length, 10)
+      : null;
+
+    if (done) {
+      // classic callback style
+      return readStream(stream, encoding, length, limit, wrap(done))
+    }
+
+    return new Promise(function executor (resolve, reject) {
+      readStream(stream, encoding, length, limit, function onRead (err, buf) {
+        if (err) return reject(err)
+        resolve(buf);
+      });
+    })
+  }
+
+  /**
+   * Halt a stream.
+   *
+   * @param {Object} stream
+   * @private
+   */
+
+  function halt (stream) {
+    // unpipe everything from the stream
+    unpipe(stream);
+
+    // pause stream
+    if (typeof stream.pause === 'function') {
+      stream.pause();
+    }
+  }
+
+  /**
+   * Read the data from the stream.
+   *
+   * @param {object} stream
+   * @param {string} encoding
+   * @param {number} length
+   * @param {number} limit
+   * @param {function} callback
+   * @public
+   */
+
+  function readStream (stream, encoding, length, limit, callback) {
+    var complete = false;
+    var sync = true;
+
+    // check the length and limit options.
+    // note: we intentionally leave the stream paused,
+    // so users should handle the stream themselves.
+    if (limit !== null && length !== null && length > limit) {
+      return done(createError(413, 'request entity too large', {
+        expected: length,
+        length: length,
+        limit: limit,
+        type: 'entity.too.large'
+      }))
+    }
+
+    // streams1: assert request encoding is buffer.
+    // streams2+: assert the stream encoding is buffer.
+    //   stream._decoder: streams1
+    //   state.encoding: streams2
+    //   state.decoder: streams2, specifically < 0.10.6
+    var state = stream._readableState;
+    if (stream._decoder || (state && (state.encoding || state.decoder))) {
+      // developer error
+      return done(createError(500, 'stream encoding should not be set', {
+        type: 'stream.encoding.set'
+      }))
+    }
+
+    if (typeof stream.readable !== 'undefined' && !stream.readable) {
+      return done(createError(500, 'stream is not readable', {
+        type: 'stream.not.readable'
+      }))
+    }
+
+    var received = 0;
+    var decoder;
+
+    try {
+      decoder = getDecoder(encoding);
+    } catch (err) {
+      return done(err)
+    }
+
+    var buffer = decoder
+      ? ''
+      : [];
+
+    // attach listeners
+    stream.on('aborted', onAborted);
+    stream.on('close', cleanup);
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onEnd);
+
+    // mark sync section complete
+    sync = false;
+
+    function done () {
+      var args = new Array(arguments.length);
+
+      // copy arguments
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i];
+      }
+
+      // mark complete
+      complete = true;
+
+      if (sync) {
+        process.nextTick(invokeCallback);
+      } else {
+        invokeCallback();
+      }
+
+      function invokeCallback () {
+        cleanup();
+
+        if (args[0]) {
+          // halt the stream on error
+          halt(stream);
+        }
+
+        callback.apply(null, args);
+      }
+    }
+
+    function onAborted () {
+      if (complete) return
+
+      done(createError(400, 'request aborted', {
+        code: 'ECONNABORTED',
+        expected: length,
+        length: length,
+        received: received,
+        type: 'request.aborted'
+      }));
+    }
+
+    function onData (chunk) {
+      if (complete) return
+
+      received += chunk.length;
+
+      if (limit !== null && received > limit) {
+        done(createError(413, 'request entity too large', {
+          limit: limit,
+          received: received,
+          type: 'entity.too.large'
+        }));
+      } else if (decoder) {
+        buffer += decoder.write(chunk);
+      } else {
+        buffer.push(chunk);
+      }
+    }
+
+    function onEnd (err) {
+      if (complete) return
+      if (err) return done(err)
+
+      if (length !== null && received !== length) {
+        done(createError(400, 'request size did not match content length', {
+          expected: length,
+          length: length,
+          received: received,
+          type: 'request.size.invalid'
+        }));
+      } else {
+        var string = decoder
+          ? buffer + (decoder.end() || '')
+          : Buffer.concat(buffer);
+        done(null, string);
+      }
+    }
+
+    function cleanup () {
+      buffer = null;
+
+      stream.removeListener('aborted', onAborted);
+      stream.removeListener('data', onData);
+      stream.removeListener('end', onEnd);
+      stream.removeListener('error', onEnd);
+      stream.removeListener('close', cleanup);
+    }
+  }
+
+  /**
+   * Try to require async_hooks
+   * @private
+   */
+
+  function tryRequireAsyncHooks () {
+    try {
+      return require('async_hooks')
+    } catch (e) {
+      return {}
+    }
+  }
+
+  /**
+   * Wrap function with async resource, if possible.
+   * AsyncResource.bind static method backported.
+   * @private
+   */
+
+  function wrap (fn) {
+    var res;
+
+    // create anonymous resource
+    if (asyncHooks.AsyncResource) {
+      res = new asyncHooks.AsyncResource(fn.name || 'bound-anonymous-fn');
+    }
+
+    // incompatible node.js
+    if (!res || !res.runInAsyncScope) {
+      return fn
+    }
+
+    // return bound function
+    return res.runInAsyncScope.bind(res, fn, null)
+  }
+
+  var index = /*#__PURE__*/Object.freeze({
+    __proto__: null
+  });
 
   exports.API_ROUTE_NAMES = API_ROUTE_NAMES;
   exports.API_WEBHOOK_TOPICS = API_WEBHOOK_TOPICS;
@@ -863,10 +1223,12 @@
   exports.BILLING_INTERVALS = BILLING_INTERVALS;
   exports.COLLECTION_ROOT = COLLECTION_ROOT;
   exports.PAGE_ROUTE_NAMES = PAGE_ROUTE_NAMES;
+  exports.VerificationError = VerificationError;
   exports.convertEventTopic = convertEventTopic;
+  exports.ensureRawBody = ensureRawBody;
   exports.getVerificationHelpers = getVerificationHelpers;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-//# sourceMappingURL=verification.js.map
+//# sourceMappingURL=index.js.map