@queue-it/fastly 2.0.3-beta.4 → 4.4.3-beta.0

package/README.md

@@ -109,6 +109,28 @@ if (res != null) {
 - Create desired waiting room(s), triggers, and actions in the Go Queue-It self-service platform.  
   Then, save/publish the configuration.
 
+## Enqueue Token Settings
+
+The connector supports enqueue tokens, which are used to secure the queue redirect flow. These settings are read at runtime from the Fastly `IntegrationConfiguration` Config Store. They are optional — if not set, the defaults below apply.
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `enqueueTokenEnabled` | `"true"` | Enables enqueue token generation. Set to `"false"` to disable. |
+| `enqueueTokenValidityTime` | `"240000"` | Token validity time in milliseconds. |
+| `enqueueTokenKeyEnabled` | `"false"` | Enables key-based enqueue tokens. Set to `"true"` to enable. |
+
+To configure these, add them as items in the `IntegrationConfiguration` Config Store alongside the other settings (`customerId`, `apiKey`, `secret`, etc.) — either via the Fastly UI or the Fastly API.
+
+## Request Body Trigger Matching
+
+The connector supports matching triggers based on the request body content. This is disabled by default. When enabled, up to 2048 characters of the request body are read and passed to the SDK for trigger evaluation.
+
+To enable it, add the following key to the `IntegrationConfiguration` Config Store:
+
+| Key | Default | Description |
+|-----|---------|-------------|
+| `requestBodyEnabled` | `"false"` | Set to `"true"` to enable request body trigger matching. |
+
 ## Providing the queue configuration
 
 The recommended way is to use the Go Queue-it self-service portal to setup the configuration. The configuration

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@queue-it/fastly",
-  "version": "2.0.3-beta.4",
+  "version": "4.4.3-beta.0",
   "description": "Queue-it connector for Fastly",
   "main": "src/index.ts",
   "author": "devs@queue-it.com",
@@ -18,13 +18,15 @@
     "src/index.ts"
   ],
   "scripts": {
+    "typecheck": "tsc --noEmit",
     "bundle": "esbuild src/index.ts --bundle --outfile=bin/index.js --platform=node --target=es2022 && js-compute-runtime bin/index.js bin/main.wasm",
     "build": "fastly compute build",
     "deploy": "fastly compute deploy"
   },
   "dependencies": {
     "@fastly/js-compute": "^3.0.0",
-    "@queue-it/connector-javascript": "^5.0.1"
+    "@queue-it/connector-javascript": "^4.4.4",
+    "@queue-it/queue-token": "~1.0.4"
   },
   "devDependencies": {
     "esbuild": "^0.27.3",

package/src/contextProvider.ts

@@ -1,127 +1,172 @@
-import { IConnectorContextProvider, IHttpRequest, IHttpResponse } from '@queue-it/connector-javascript';
+import {
+    DefaultEnqueueTokenProvider,
+    IConnectorContextProvider,
+    ICryptoProvider,
+    IEnqueueTokenProvider,
+    INormalizationProvider,
+    DefaultNormalizationProvider,
+    IHttpRequest,
+    IHttpResponse,
+} from '@queue-it/connector-javascript';
+import { Token, Payload } from '@queue-it/queue-token';
 import { FastlyCryptoProvider } from './fastlyCryptoProvider';
 
-export function getHttpHandler(req: Request): FastlyHttpContextProvider {
-    return new FastlyHttpContextProvider(req);
+export function getHttpHandler(req: Request, clientIp: string = '', bodyString: string = ''): FastlyHttpContextProvider {
+    return new FastlyHttpContextProvider(req, clientIp, bodyString);
 }
 
 export class FastlyHttpContextProvider implements IConnectorContextProvider {
     isError: boolean = false;
-    private readonly req: FastlyHttpRequest;
-    private readonly res: FastlyHttpResponse;
+    private readonly _httpRequest: FastlyHttpRequest;
+    private readonly _httpResponse: FastlyHttpResponse;
+    private _enqueueTokenProvider: IEnqueueTokenProvider | null = null;
+    private readonly _normalizationProvider: INormalizationProvider;
+    private readonly _cryptoProvider: ICryptoProvider;
 
-    constructor(fReq: Request) {
-        this.req = new FastlyHttpRequest(fReq);
-        this.res = new FastlyHttpResponse();
+    constructor(fReq: Request, clientIp: string = '', bodyString: string = '') {
+        this._httpRequest = new FastlyHttpRequest(fReq, clientIp, bodyString);
+        this._httpResponse = new FastlyHttpResponse();
+        this._normalizationProvider = new DefaultNormalizationProvider();
+        this._cryptoProvider = new FastlyCryptoProvider();
     }
 
     getHttpRequest(): IHttpRequest {
-        return this.req;
+        return this._httpRequest;
     }
 
     getHttpResponse(): IHttpResponse {
-        return this.res;
+        return this._httpResponse;
     }
 
-    getCryptoProvider(): FastlyCryptoProvider {
-        return new FastlyCryptoProvider();
+    getCryptoProvider(): ICryptoProvider {
+        return this._cryptoProvider;
     }
 
-    getEnqueueTokenProvider(): null {
-        return null;
+    setEnqueueTokenProvider(
+        customerId: string,
+        secretKey: string,
+        validityTime: number,
+        clientIp: string,
+        withKey: boolean
+    ): void {
+        this._enqueueTokenProvider = new DefaultEnqueueTokenProvider(
+            customerId,
+            secretKey,
+            validityTime,
+            clientIp,
+            withKey,
+            Token,
+            Payload
+        );
+    }
+
+    setCustomEnqueueTokenProvider(provider: IEnqueueTokenProvider): void {
+        this._enqueueTokenProvider = provider;
+    }
+
+    getEnqueueTokenProvider(): IEnqueueTokenProvider | null {
+        return this._enqueueTokenProvider;
+    }
+
+    getNormalizationProvider(): INormalizationProvider {
+        return this._normalizationProvider;
     }
 
     getResponseHeaders(): Headers {
-        return (this.res as FastlyHttpResponse).getHeaders();
+        return this._httpResponse.getHeaders();
     }
 }
 
-export class FastlyHttpRequest implements IHttpRequest {
-    private parsedCookieDic: Map<string, string>
-    private bodyFetched: boolean = false;
-    private body: string = '';
+class FastlyHttpRequest implements IHttpRequest {
+    private _parsedCookieDic: Record<string, string> | null = null;
 
-    constructor(private baseReq: Request) {
-        this.parsedCookieDic = new Map();
-        this.bodyFetched = false;
-    }
+    constructor(private baseReq: Request, private _clientIp: string = '', private _bodyString: string = '') {}
 
-    private parseCookies(cookieValue: string): void {
-        const cookies = cookieValue.split(';');
-        for (let i = 0; i < cookies.length; i++) {
-            let cookieKV = cookies[i].split('=', 2);
-            if (cookieKV.length >= 2) {
-                this.parsedCookieDic.set(cookieKV[0].trim(), cookieKV[1].trim())
-            }
-        }
+    getUserAgent(): string {
+        return this.getHeader('user-agent');
     }
 
-    private handleBody(): void {
-        if (this.baseReq.bodyUsed || this.bodyFetched) {
-            return;
-        }
-        this.bodyFetched = true;
-        this.body = ''; // this.context.req.text()
+    getHeader(name: string): string {
+        if (name.toLowerCase() === 'x-queueit-clientip')
+            return this.getUserHostAddress();
+
+        return this.baseReq.headers.get(name) || '';
     }
 
     getAbsoluteUri(): string {
         return this.baseReq.url;
     }
 
-    getCookieValue(cookieKey: string): string | undefined {
-        if (this.parsedCookieDic.size == 0) {
-            this.parseCookies(this.getHeader('cookie'))
-        }
-        if (!this.parsedCookieDic.has(cookieKey)) return undefined;
-        const cookieVal = this.parsedCookieDic.get(cookieKey)!;
-        try {
-            return decodeURIComponent(cookieVal);
-        } catch {
-            return cookieVal;
-        }
+    getUserHostAddress(): string {
+        return this._clientIp || this.baseReq.headers.get('Fastly-Client-IP') || '';
     }
 
-    getHeader(name: string): string {
-        if (name.length == 0) return "";
-        if (!this.baseReq.headers.has(name)) {
-            return '';
+    getCookieValue(name: string): string | undefined {
+        if (!this._parsedCookieDic) {
+            this._parsedCookieDic = this._parseCookies(this.getHeader('cookie'));
         }
-        const value = this.baseReq.headers.get(name);
-        if (value == null) return '';
-        return value!;
-    }
 
-    getRequestBodyAsString(): string {
-        if (!this.bodyFetched) {
-            this.handleBody();
+        const cookieValue = this._parsedCookieDic[name];
+        if (cookieValue) {
+            try {
+                return decodeURIComponent(cookieValue);
+            } catch {
+                return;
+            }
         }
-        return this.body;
+
+        return;
     }
 
-    getUserAgent(): string {
-        return this.baseReq.headers.has('user-agent') ? this.baseReq.headers.get('user-agent')! : '';
+    getRequestBodyAsString(): string {
+        return this._bodyString;
     }
 
-    getUserHostAddress(): string {
-        return this.baseReq.headers.get('Fastly-Client-IP') ?? '';
+    private _parseCookies(cookieValue: string): Record<string, string> {
+        const parsedCookie: Record<string, string> = {};
+        cookieValue.split(';').forEach(function (cookie) {
+            if (cookie) {
+                const parts = cookie.split('=');
+                if (parts.length >= 2) parsedCookie[parts[0].trim()] = parts[1].trim();
+            }
+        });
+        return parsedCookie;
     }
 }
 
-export class FastlyHttpResponse implements IHttpResponse {
+class FastlyHttpResponse implements IHttpResponse {
     private readonly headers: Headers;
 
     constructor() {
         this.headers = new Headers();
     }
 
-    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: number, _isHttpOnly: boolean, _isSecure: boolean): void {
+    setCookie(
+        cookieName: string,
+        cookieValue: string,
+        domain: string,
+        expiration: number,
+        httpOnly: boolean,
+        isSecure: boolean
+    ): void {
         const expirationDate = new Date(expiration * 1000);
-        let setCookieString = cookieName + "=" + encodeURIComponent(cookieValue) + "; expires=" + expirationDate.toUTCString() + ";";
-        if (domain != "") {
-            setCookieString += " domain=" + domain + ";";
+
+        let setCookieString = `${cookieName}=${encodeURIComponent(cookieValue)}; expires=${expirationDate.toUTCString()};`;
+
+        if (domain) {
+            setCookieString += ` domain=${domain};`;
+        }
+
+        if (httpOnly) {
+            setCookieString += ' HttpOnly;';
+        }
+
+        if (isSecure) {
+            setCookieString += ' Secure;';
         }
-        setCookieString += " path=/;";
-        this.headers.set('set-cookie', setCookieString);
+
+        setCookieString += ' path=/';
+        this.headers.append('set-cookie', setCookieString);
     }
 
     getHeaders(): Headers {

package/src/helper.ts

@@ -1,5 +1,5 @@
 export class QueueITHelper {
-  static readonly KUP_VERSION: string = "fastly-2.0.3-beta.4";
+  static readonly KUP_VERSION: string = "fastly-4.4.3";
 
   static addKUPlatformVersion(redirectQueueUrl: string): string {
     return redirectQueueUrl + "&kupver=" + QueueITHelper.KUP_VERSION;

package/src/index.ts

@@ -1,3 +1,3 @@
-export {IntegrationDetails, IntegrationEndpointProvider, IntegrationEndpointCacheConfig, resolveIntegrationDetails} from "./integrationConfigProvider"
+export {IntegrationDetails, EnqueueTokenProviderFactory, IntegrationEndpointProvider, IntegrationEndpointCacheConfig, resolveIntegrationDetails} from "./integrationConfigProvider"
 export {onQueueITRequest, onQueueITResponse} from "./requestResponseHandler";
 export {RequestLogger} from "./helper";

package/src/integrationConfigProvider.ts

@@ -1,6 +1,15 @@
 import { ConfigStore } from "fastly:config-store";
+import { IEnqueueTokenProvider } from "@queue-it/connector-javascript";
 import { RequestLogger } from "./helper";
 
+export type EnqueueTokenProviderFactory = (
+  customerId: string,
+  secretKey: string,
+  validityTime: number,
+  clientIp: string,
+  withKey: boolean
+) => IEnqueueTokenProvider;
+
 export async function getIntegrationConfig(
   details: IntegrationDetails,
   endpointProvider: IntegrationEndpointProvider
@@ -46,7 +55,11 @@ const integrationCustomerId = "customerId",
   integrationSecret = "secret",
   integrationQueueItOrigin = "queueItOrigin",
   integrationDictionary = "IntegrationConfiguration",
-  workerHost = "workerHost";
+  workerHost = "workerHost",
+  enqueueTokenEnabledKey = "enqueueTokenEnabled",
+  enqueueTokenValidityTimeKey = "enqueueTokenValidityTime",
+  enqueueTokenKeyEnabledKey = "enqueueTokenKeyEnabled",
+  requestBodyEnabledKey = "requestBodyEnabled";
 
 export function resolveIntegrationDetails(): IntegrationDetails | null {
   const dict = new ConfigStore(integrationDictionary);
@@ -65,12 +78,40 @@ export function resolveIntegrationDetails(): IntegrationDetails | null {
     workerHostValue = workerHostVal;
   }
 
+  let enqueueTokenEnabled = true;
+  const enqueueTokenEnabledVal = dict.get(enqueueTokenEnabledKey);
+  if (enqueueTokenEnabledVal !== null) {
+    enqueueTokenEnabled = enqueueTokenEnabledVal.toLowerCase() === "true";
+  }
+
+  let enqueueTokenValidityTime = 240000;
+  const enqueueTokenValidityTimeVal = dict.get(enqueueTokenValidityTimeKey);
+  if (enqueueTokenValidityTimeVal !== null) {
+    enqueueTokenValidityTime = parseInt(enqueueTokenValidityTimeVal, 10);
+  }
+
+  let enqueueTokenKeyEnabled = false;
+  const enqueueTokenKeyEnabledVal = dict.get(enqueueTokenKeyEnabledKey);
+  if (enqueueTokenKeyEnabledVal !== null) {
+    enqueueTokenKeyEnabled = enqueueTokenKeyEnabledVal.toLowerCase() === "true";
+  }
+
+  let requestBodyEnabled = false;
+  const requestBodyEnabledVal = dict.get(requestBodyEnabledKey);
+  if (requestBodyEnabledVal !== null) {
+    requestBodyEnabled = requestBodyEnabledVal.toLowerCase() === "true";
+  }
+
   return new IntegrationDetails(
     dict.get(integrationQueueItOrigin)!,
     dict.get(integrationCustomerId)!,
     dict.get(integrationSecret)!,
     dict.get(integrationApiKey)!,
-    workerHostValue
+    workerHostValue,
+    enqueueTokenEnabled,
+    enqueueTokenValidityTime,
+    enqueueTokenKeyEnabled,
+    requestBodyEnabled
   );
 }
 
@@ -117,12 +158,26 @@ class MockLogger implements RequestLogger {
 }
 
 export class IntegrationDetails {
+  public enqueueTokenProviderFactory: EnqueueTokenProviderFactory | null = null;
+
+  /**
+   * The client IP address of the end user. In Fastly Compute, the client IP is not available
+   * via request headers (unlike Cloudflare's cf-connecting-ip or Akamai's True-Client-IP).
+   * Instead, it must be obtained from event.client.address in the fetch event handler and
+   * passed here. Used by the SDK for IP-based trigger matching and enqueue token generation.
+   */
+  public clientIp: string = '';
+
   constructor(
     public queueItOrigin: string,
     public customerId: string,
     public secretKey: string,
     public apiKey: string,
     public workerHost: string,
+    public enqueueTokenEnabled: boolean = true,
+    public enqueueTokenValidityTime: number = 240000,
+    public enqueueTokenKeyEnabled: boolean = false,
+    public requestBodyEnabled: boolean = false,
     public provider: IntegrationEndpointProvider = new QueueItIntegrationEndpointProvider(),
     public logger: RequestLogger = new MockLogger()
   ) {}

package/src/requestResponseHandler.ts

@@ -8,31 +8,11 @@ import {
   QueueItIntegrationEndpointProvider,
 } from "./integrationConfigProvider";
 
-function getParameterByName(url: string, name: string): string {
-  name = name.replace(/[\[\]]/g, '\\$&');
-  const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
-  const results = regex.exec(url);
-  if (!results) return '';
-  if (!results[2]) return '';
-  return results[2].replace(/\+/g, ' ');
-}
-
-function removeQueueItToken(url: string): string {
-  const pattern = new RegExp("([?&])(" + KnownUser.QueueITTokenKey + "=[^&]*)", 'gi');
-  const match = pattern.exec(url);
-  if (match === null) return url;
-  url = url.replaceAll(match[0], '');
-  return url;
-}
-
-function addNoCacheHeaders(res: Response): void {
-  res.headers.set('Cache-Control', 'no-cache, no-store, must-revalidate, max-age=0');
-  res.headers.set('Pragma', 'no-cache');
-  res.headers.set('Expires', 'Fri, 01 Jan 1990 00:00:00 GMT');
-}
-
 const QUEUEIT_FAILED_HEADERNAME = "x-queueit-failed";
+const QUEUEIT_CONNECTOR_EXECUTED_HEADER_NAME = "x-queueit-connector";
+
 let httpProvider: FastlyHttpContextProvider | null = null;
+let sendNoCacheHeaders: boolean = false;
 
 export async function onQueueITRequest(
   req: Request,
@@ -52,18 +32,52 @@ export async function onQueueITRequest(
     conf.provider == null
       ? new QueueItIntegrationEndpointProvider()
       : conf.provider;
-  httpProvider = getHttpHandler(req);
 
-  let integrationConfigJson = await getIntegrationConfig(conf, integrationProvider);
-  const requestUrl: string = conf.resolveWorkerRequestUrl(req.url);
+  let bodyString = '';
+  if (conf.requestBodyEnabled) {
+    bodyString = ((await req.clone().text()) || '').substring(0, 2048);
+  }
 
-  const queueItToken = getParameterByName(requestUrl, KnownUser.QueueITTokenKey);
-  const requestUrlWithoutToken: string = removeQueueItToken(requestUrl);
+  httpProvider = getHttpHandler(req, conf.clientIp, bodyString);
+  sendNoCacheHeaders = false;
+
+  if (conf.enqueueTokenEnabled) {
+    const clientIp = httpProvider.getHttpRequest().getUserHostAddress();
+    if (conf.enqueueTokenProviderFactory) {
+      httpProvider.setCustomEnqueueTokenProvider(
+        conf.enqueueTokenProviderFactory(
+          conf.customerId,
+          conf.secretKey,
+          conf.enqueueTokenValidityTime,
+          clientIp,
+          conf.enqueueTokenKeyEnabled
+        )
+      );
+    } else {
+      httpProvider.setEnqueueTokenProvider(
+        conf.customerId,
+        conf.secretKey,
+        conf.enqueueTokenValidityTime,
+        clientIp,
+        conf.enqueueTokenKeyEnabled
+      );
+    }
+  }
 
-  // The requestUrlWithoutToken is used to match Triggers and as the Target url (where to return the users to).
-  // It is therefor important that this is exactly the url of the users browsers. So, if your webserver is
-  // behind e.g. a load balancer that modifies the host name or port, reformat requestUrlWithoutToken before proceeding.
   try {
+    const integrationConfigJson = await getIntegrationConfig(conf, integrationProvider);
+    const requestUrl: string = conf.resolveWorkerRequestUrl(req.url);
+
+    const queueItToken = getQueueItToken(requestUrl, httpProvider);
+    const requestUrlWithoutToken = requestUrl.replace(
+      new RegExp("([?&])(" + KnownUser.QueueITTokenKey + "=[^&]*)", "i"),
+      ""
+    );
+
+    // The requestUrlWithoutToken is used to match Triggers and as the Target url (where to return the users to).
+    // It is therefor important that this is exactly the url of the users browsers. So, if your webserver is
+    // behind e.g. a load balancer that modifies the host name or port, reformat requestUrlWithoutToken before proceeding.
+
     const validationResult = await KnownUser.validateRequestByIntegrationConfig(
       requestUrlWithoutToken,
       queueItToken,
@@ -75,22 +89,23 @@ export async function onQueueITRequest(
 
     if (validationResult.doRedirect()) {
       if (validationResult.isAjaxResult) {
-        let response = new Response(null, {
+        const response = new Response(null, {
           status: 200,
           headers: httpProvider!.getResponseHeaders(),
         });
+        const headerKey = validationResult.getAjaxQueueRedirectHeaderKey();
+        const queueRedirectUrl = validationResult.getAjaxRedirectUrl();
+
         // In case of ajax call send the user to the queue by sending a custom queue-it header and redirecting user to queue from javascript
-        response.headers.set("Access-Control-Expose-Headers", validationResult.getAjaxQueueRedirectHeaderKey());
         response.headers.set(
-          validationResult.getAjaxQueueRedirectHeaderKey(),
-          QueueITHelper.addKUPlatformVersion(
-            validationResult.getAjaxRedirectUrl()
-          )
+          headerKey,
+          QueueITHelper.addKUPlatformVersion(queueRedirectUrl)
         );
-        addNoCacheHeaders(response);
+        response.headers.set("Access-Control-Expose-Headers", headerKey);
+        sendNoCacheHeaders = true;
         return response;
       } else {
-        let response = new Response(null, {
+        const response = new Response(null, {
           status: 302,
           headers: httpProvider!.getResponseHeaders(),
         });
@@ -99,47 +114,87 @@ export async function onQueueITRequest(
           "Location",
           QueueITHelper.addKUPlatformVersion(validationResult.redirectUrl)
         );
-        addNoCacheHeaders(response);
+        sendNoCacheHeaders = true;
         return response;
       }
     } else {
       // Request can continue - we remove queueittoken from querystring parameter to avoid sharing of user specific token
-      // Support mobile scenario adding the condition !validationResult.isAjaxResult
       if (
-        queueItToken != "" &&
-        !validationResult.isAjaxResult &&
-        validationResult.actionType == "Queue"
+        requestUrl !== requestUrlWithoutToken &&
+        validationResult.actionType === "Queue"
       ) {
-        let response = new Response(null, {
+        const response = new Response(null, {
           status: 302,
           headers: httpProvider!.getResponseHeaders(),
         });
         response.headers.set("Location", requestUrlWithoutToken);
-        addNoCacheHeaders(response);
+        sendNoCacheHeaders = true;
         return response;
       } else {
         // lets caller decide the next step, or just serve the request normally
         return null;
       }
     }
-  } catch {
+  } catch (e) {
+    if (console && console.log) {
+      console.log("ERROR:" + e);
+    }
     httpProvider!.isError = true;
+    return null;
   }
-
-  return null;
 }
 
-//Fill in the Queue-it headers
+// Fill in the Queue-it headers
 export function onQueueITResponse(res: Response): void {
-  const contextHeaders = httpProvider!.getResponseHeaders();
+  res.headers.set(QUEUEIT_CONNECTOR_EXECUTED_HEADER_NAME, "fastly");
+
+  if (httpProvider) {
+    const contextHeaders = httpProvider.getResponseHeaders();
+    for (const key of contextHeaders.keys()) {
+      if (key.length == 0) continue;
+      const value = contextHeaders.get(key);
+      if (value != null && value.length > 0)
+        res.headers.append(key, value);
+    }
+
+    if (httpProvider.isError) {
+      res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
+    }
+  }
+
+  if (sendNoCacheHeaders) {
+    addNoCacheHeaders(res);
+  }
+}
+
+function addNoCacheHeaders(res: Response): void {
+  res.headers.set('Cache-Control', 'no-cache, no-store, must-revalidate, max-age=0');
+  res.headers.set('Pragma', 'no-cache');
+  res.headers.set('Expires', 'Fri, 01 Jan 1990 00:00:00 GMT');
+}
 
-  if (httpProvider!.isError) {
-    res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
+function getQueueItToken(
+  requestUrl: string,
+  httpContext: FastlyHttpContextProvider
+): string {
+  const queueItToken = getParameterByName(requestUrl, KnownUser.QueueITTokenKey);
+  if (queueItToken) {
+    return queueItToken;
   }
-  for (const key of contextHeaders.keys()) {
-    if (key.length == 0) continue;
-    const value = contextHeaders.get(key);
-    if (value != null && value.length > 0)
-      res.headers.append(key, value);
+
+  const tokenHeaderName = `x-${KnownUser.QueueITTokenKey}`;
+  return httpContext.getHttpRequest().getHeader(tokenHeaderName);
+}
+
+function getParameterByName(url: string, name: string): string {
+  name = name.replace(/[\[\]]/g, '\\$&');
+  const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)');
+  const results = regex.exec(url);
+  if (!results) return '';
+  if (!results[2]) return '';
+  try {
+    return decodeURIComponent(results[2].replace(/\+/g, ' '));
+  } catch {
+    return results[2];
   }
 }