@queue-it/fastly 1.0.1 → 1.0.3

package/README.md

@@ -1,129 +1,129 @@
-# KnownUser.V3.Fastly
-
-The Queue-it Security Framework ensures that end-users are not able to access your online application without first
-going through the queue for any and all �protected� areas and paths on your sites. The queue system is implemented by
-adding a server-side (request-level) integration that protects your online application by redirecting users to a waiting
-room according to web traffic settings in the Queue-it GO Platform. After the integration is complete, queue system
-behavior and operations are managed in Queue-it�s Go Platform and/or via the Queue-it Admin API.
-
-This Fastly Queue-it Connector SDK (aka, Queue-it�s server-side KnownUser connector) uses a Compute@Edge service to
-integrate Queue-it's functionality into Fastly's network.
-
-A Wasm service is required to utilize this connector.
-
-> You can find the latest released version [here](https://github.com/queueit/KnownUser.V3.Fastly/releases/latest).
-
-## Introduction
-
-When a user makes a request to your Fastly service our connector validates the request and if it is needed, it will
-redirect the user to the waiting room. After waiting in the waiting room, the queue engine will redirect the user back
-to your end attaching a query string parameter ( `queueittoken` ) containing some information about the user to the URL.
-The most important fields of the `queueittoken` are:
-
-- q - The user's unique queue identifier
-- ts - A timestamp of how long this redirect is valid
-- h - A hash of the token
-
-After the user returns from the queue, the connector will let the user continue his request to your backend ( without
-redirecting to the queue since the request has a valid queueittoken as query string) .
-
-## Installation
-
-There are two methods of installation:
-
-### As a standalone service
-
-- Go to the Fastly services page and create a new **Wasm** service.
-- Go to Domains and fill in the domain that you want your service to be reachable at. You may need to register a CNAME
-  record if you have your own domain.
-- Then click on *Origins* and add a new host that has the hostname of your origin server.  
-  You need to edit the Host and name it **origin**.
-- Create a second host that has the hostname of `{yourCustomerId}.queue-it.net` and name it **queue-it**.  
-  Edit the host, go to advanced options and fill in the same hostname in **Override host**
-- Go to **Dictionaries** and create a new dictionary named `IntegrationConfiguration`.  
-  Add the following items in the dictionary:
-    - customerId: Your customer ID
-    - apiKey: The API key for your account
-    - secret: Your KnownUserV3 secret
-    - queueItOrigin: The name of the queue-it host, in this case it's `queue-it`  
-      You can find these values in the Go Queue-It self-service platform.
-- Download the latest package from the releases page and unarchive it.
-- Edit the `fastly.toml` file and copy the ID of your service (you can see this by opening up the service in Fastly) and
-  replace __{YourServiceId}__ with it.
-- Archive the directory in the same format (tar.gz).
-- Go to `Package` in the Fastly service page and upload the package.
-- To finish up and deploy your service click on the **Activate** button.
-
-### Customizable service with the connector
-
-- Go to the Fastly services page and create a new **Wasm** service and copy it's ID.
-- Clone this repository and edit the fastly.toml file, make sure to set the `service_id` field to the ID you copied.
-- Then click on *Origins* and add a new host that has the hostname of your origin server.   
-  You can name the host **origin** or whatever you choose.
-- Create a host that has the hostname of `{yourCustomerId}.queue-it.net` and name it **queue-it**.    
-  Edit the host, go to advanced options and fill in the same hostname in **Override host**
-- Open up the service in Fastly and go to **Dictionaries** and create a new dictionary named `IntegrationConfiguration`
-  .  
-  Add the following items in the dictionary:
-    - customerId: Your customer ID
-    - apiKey: The API key for your account
-    - secret: Your KnownUserV3 secret
-    - queueItOrigin: The name of the queue-it origin, in this case it's `queue-it`  
-      You can find these values in the Go Queue-It self-service platform.
-- You need to add some code that uses this connector. Here is an example:
-
-```ts
-import {Fastly} from "@fastly/as-compute";
-import {onQueueITRequest, IntegrationDetails, onQueueITResponse} from "@queue-it/fastly";
-
-const req = Fastly.getClientRequest();
-
-// This is optional and can be null if it's specified in your Dictionary
-const integrationDetails = new IntegrationDetails(
-        "QueueItOriginName",
-        "CustomerId",
-        "SecretKey",
-        "ApiKey");
-let res = onQueueITRequest(req, integrationDetails);
-
-if (res != null) {
-    Fastly.respondWith(res!);
-} else {
-    const myOrigin = 'Ticketania';
-    const cacheOverride = new Fastly.CacheOverride();
-    const res = Fastly.fetch(req, {
-        backend: myOrigin,
-        cacheOverride,
-    }).wait();
-    onQueueITResponse(res);
-    Fastly.respondWith(res);
-} 
-```
-
-- Build and deploy the package running `fastly compute build` and `fastly compute deploy` in the same directory.
-- Create desired waiting room(s), triggers, and actions in the Go Queue-It self-service platform.  
-  Then, save/publish the configuration.
-
-## Providing the queue configuration
-
-The recommended way is to use the Go Queue-it self-service portal to setup the configuration. The configuration
-specifies a set of Triggers and Actions. A Trigger is an expression matching one, more or all URLs on your website. When
-a user enter your website and the URL matches a Trigger-expression the corresponding Action will be triggered. The
-Action specifies which waiting room the users should be send to. In this way you can specify which waiting room(s)
-should protect which page(s) on the fly without changing the server-side integration.
-
-## Protecting AJAX calls
-
-If you need to protect AJAX calls beside page loads you need to add the below JavaScript tags to your pages:
-
-```html
-
-<script type="text/javascript" src="//static.queue-it.net/script/queueclient.min.js"></script>
-<script
-        data-queueit-intercept-domain="{YOUR_CURRENT_DOMAIN}"
-        data-queueit-intercept="true"
-        data-queueit-c="{YOUR_CUSTOMER_ID}"
-        type="text/javascript"
-        src="//static.queue-it.net/script/queueconfigloader.min.js">
-</script>
-```
+# KnownUser.V3.Fastly
+
+The Queue-it Security Framework ensures that end-users are not able to access your online application without first
+going through the queue for any and all �protected� areas and paths on your sites. The queue system is implemented by
+adding a server-side (request-level) integration that protects your online application by redirecting users to a waiting
+room according to web traffic settings in the Queue-it GO Platform. After the integration is complete, queue system
+behavior and operations are managed in Queue-it�s Go Platform and/or via the Queue-it Admin API.
+
+This Fastly Queue-it Connector SDK (aka, Queue-it�s server-side KnownUser connector) uses a Compute@Edge service to
+integrate Queue-it's functionality into Fastly's network.
+
+A Wasm service is required to utilize this connector.
+
+> You can find the latest released version [here](https://github.com/queueit/KnownUser.V3.Fastly/releases/latest).
+
+## Introduction
+
+When a user makes a request to your Fastly service our connector validates the request and if it is needed, it will
+redirect the user to the waiting room. After waiting in the waiting room, the queue engine will redirect the user back
+to your end attaching a query string parameter ( `queueittoken` ) containing some information about the user to the URL.
+The most important fields of the `queueittoken` are:
+
+- q - The user's unique queue identifier
+- ts - A timestamp of how long this redirect is valid
+- h - A hash of the token
+
+After the user returns from the queue, the connector will let the user continue his request to your backend ( without
+redirecting to the queue since the request has a valid queueittoken as query string) .
+
+## Installation
+
+There are two methods of installation:
+
+### As a standalone service
+
+- Go to the Fastly services page and create a new **Wasm** service.
+- Go to Domains and fill in the domain that you want your service to be reachable at. You may need to register a CNAME
+  record if you have your own domain.
+- Then click on *Origins* and add a new host that has the hostname of your origin server.  
+  You need to edit the Host and name it **origin**.
+- Create a second host that has the hostname of `{yourCustomerId}.queue-it.net` and name it **queue-it**.  
+  Edit the host, go to advanced options and fill in the same hostname in **Override host**
+- Go to **Dictionaries** and create a new dictionary named `IntegrationConfiguration`.  
+  Add the following items in the dictionary:
+    - customerId: Your customer ID
+    - apiKey: The API key for your account
+    - secret: Your KnownUserV3 secret
+    - queueItOrigin: The name of the queue-it host, in this case it's `queue-it`  
+      You can find these values in the Go Queue-It self-service platform.
+- Download the latest package from the releases page and unarchive it.
+- Edit the `fastly.toml` file and copy the ID of your service (you can see this by opening up the service in Fastly) and
+  replace __{YourServiceId}__ with it.
+- Archive the directory in the same format (tar.gz).
+- Go to `Package` in the Fastly service page and upload the package.
+- To finish up and deploy your service click on the **Activate** button.
+
+### Customizable service with the connector
+
+- Go to the Fastly services page and create a new **Wasm** service and copy it's ID.
+- Clone this repository and edit the fastly.toml file, make sure to set the `service_id` field to the ID you copied.
+- Then click on *Origins* and add a new host that has the hostname of your origin server.   
+  You can name the host **origin** or whatever you choose.
+- Create a host that has the hostname of `{yourCustomerId}.queue-it.net` and name it **queue-it**.    
+  Edit the host, go to advanced options and fill in the same hostname in **Override host**
+- Open up the service in Fastly and go to **Dictionaries** and create a new dictionary named `IntegrationConfiguration`
+  .  
+  Add the following items in the dictionary:
+    - customerId: Your customer ID
+    - apiKey: The API key for your account
+    - secret: Your KnownUserV3 secret
+    - queueItOrigin: The name of the queue-it origin, in this case it's `queue-it`  
+      You can find these values in the Go Queue-It self-service platform.
+- You need to add some code that uses this connector. Here is an example:
+
+```ts
+import {Fastly} from "@fastly/as-compute";
+import {onQueueITRequest, IntegrationDetails, onQueueITResponse} from "@queue-it/fastly";
+
+const req = Fastly.getClientRequest();
+
+// This is optional and can be null if it's specified in your Dictionary
+const integrationDetails = new IntegrationDetails(
+        "QueueItOriginName",
+        "CustomerId",
+        "SecretKey",
+        "ApiKey");
+let res = onQueueITRequest(req, integrationDetails);
+
+if (res != null) {
+    Fastly.respondWith(res!);
+} else {
+    const myOrigin = 'Ticketania';
+    const cacheOverride = new Fastly.CacheOverride();
+    const res = Fastly.fetch(req, {
+        backend: myOrigin,
+        cacheOverride,
+    }).wait();
+    onQueueITResponse(res);
+    Fastly.respondWith(res);
+} 
+```
+
+- Build and deploy the package running `fastly compute build` and `fastly compute deploy` in the same directory.
+- Create desired waiting room(s), triggers, and actions in the Go Queue-It self-service platform.  
+  Then, save/publish the configuration.
+
+## Providing the queue configuration
+
+The recommended way is to use the Go Queue-it self-service portal to setup the configuration. The configuration
+specifies a set of Triggers and Actions. A Trigger is an expression matching one, more or all URLs on your website. When
+a user enter your website and the URL matches a Trigger-expression the corresponding Action will be triggered. The
+Action specifies which waiting room the users should be send to. In this way you can specify which waiting room(s)
+should protect which page(s) on the fly without changing the server-side integration.
+
+## Protecting AJAX calls
+
+If you need to protect AJAX calls beside page loads you need to add the below JavaScript tags to your pages:
+
+```html
+
+<script type="text/javascript" src="//static.queue-it.net/script/queueclient.min.js"></script>
+<script
+        data-queueit-intercept-domain="{YOUR_CURRENT_DOMAIN}"
+        data-queueit-intercept="true"
+        data-queueit-c="{YOUR_CUSTOMER_ID}"
+        type="text/javascript"
+        src="//static.queue-it.net/script/queueconfigloader.min.js">
+</script>
+```

package/assembly/contextProvider.ts

@@ -1,122 +1,122 @@
-import {IHttpContextProvider, IHttpRequest, IHttpResponse} from "./sdk/HttpContextProvider";
-import {Request, Fastly, Headers} from "@fastly/as-compute";
-import {decodeURIComponent, encodeURIComponent} from "./sdk/helpers/Uri";
-
-export function getHttpHandler(req: Request): FastlyHttpContextProvider {
-    return new FastlyHttpContextProvider(req);
-}
-
-export class FastlyHttpContextProvider implements IHttpContextProvider {
-    isError: bool = false;
-    private readonly req: FastlyHttpRequest;
-    // @ts-ignore
-    private readonly res: FastlyHttpResponse;
-
-    constructor(fReq: Request) {
-        this.req = new FastlyHttpRequest(fReq);
-        this.res = new FastlyHttpResponse();
-    }
-
-    getHttpRequest(): IHttpRequest {
-        return this.req;
-    }
-
-    getHttpResponse(): IHttpResponse {
-        return this.res;
-    }
-}
-
-export class FastlyHttpRequest implements IHttpRequest {
-    private parsedCookieDic: Map<string, string>
-    private bodyFetched: bool = false;
-    private body: string = '';
-
-    constructor(private baseReq: Request) {
-        this.parsedCookieDic = new Map();
-        this.bodyFetched = false;
-    }
-
-    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())
-            }
-        }
-    }
-
-    private handleBody(): void {
-        if (this.baseReq.bodyUsed || this.bodyFetched) {
-            return;
-        }
-        this.bodyFetched = true;
-        const rawBody: ArrayBuffer | null = null; // this.context.req.arrayBuffer();
-        if (rawBody == null) {
-            return;
-        }
-        if (rawBody!.byteLength == 0) {
-            return;
-        }
-
-        this.body = ''; // this.context.req.text()
-    }
-
-    getAbsoluteUri(): string {
-        return this.baseReq.url;
-    }
-
-    getCookieValue(cookieKey: string): string {
-        if (this.parsedCookieDic.keys().length == 0) {
-            this.parseCookies(this.getHeader('cookie'))
-        }
-        return this.parsedCookieDic.has(cookieKey) ? decodeURIComponent(this.parsedCookieDic.get(cookieKey)) : '';
-    }
-
-    getHeader(name: string): string {
-        if (name.length == 0) return "";
-        if (!this.baseReq.headers.has(name)) {
-            return '';
-        }
-        const value = this.baseReq.headers.get(name);
-        if (value == null) return '';
-        return value!;
-    }
-
-    getRequestBodyAsString(): string {
-        if (!this.bodyFetched) {
-            this.handleBody();
-        }
-        return this.body;
-    }
-
-    getUserAgent(): string {
-        return this.baseReq.headers.has('user-agent') ? this.baseReq.headers.get('user-agent')! : '';
-    }
-
-    getUserHostAddress(): string {
-        return Fastly.getClientIpAddressString();
-    }
-}
-
-export class FastlyHttpResponse implements IHttpResponse {
-    private readonly headers: Headers;
-
-    constructor() {
-        this.headers = new Headers();
-    }
-
-    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: i64): void {
-        const expirationDate = new Date(expiration * 1000);
-        let setCookieString = cookieName + "=" + encodeURIComponent(cookieValue) + "; expires=" + expirationDate.toUTCString() + ";";
-        if (domain != "") {
-            setCookieString += " domain=" + domain + ";";
-        }
-        setCookieString += " path=/;";
-        this.headers.set('set-cookie', setCookieString);
-    }
-
-    getHeaders(): Headers {
-        return this.headers;
-    }
-}
+import {IHttpContextProvider, IHttpRequest, IHttpResponse} from "./sdk/HttpContextProvider";
+import {Request, Fastly, Headers} from "@fastly/as-compute";
+import {decodeURIComponent, encodeURIComponent} from "./sdk/helpers/Uri";
+
+export function getHttpHandler(req: Request): FastlyHttpContextProvider {
+    return new FastlyHttpContextProvider(req);
+}
+
+export class FastlyHttpContextProvider implements IHttpContextProvider {
+    isError: bool = false;
+    private readonly req: FastlyHttpRequest;
+    // @ts-ignore
+    private readonly res: FastlyHttpResponse;
+
+    constructor(fReq: Request) {
+        this.req = new FastlyHttpRequest(fReq);
+        this.res = new FastlyHttpResponse();
+    }
+
+    getHttpRequest(): IHttpRequest {
+        return this.req;
+    }
+
+    getHttpResponse(): IHttpResponse {
+        return this.res;
+    }
+}
+
+export class FastlyHttpRequest implements IHttpRequest {
+    private parsedCookieDic: Map<string, string>
+    private bodyFetched: bool = false;
+    private body: string = '';
+
+    constructor(private baseReq: Request) {
+        this.parsedCookieDic = new Map();
+        this.bodyFetched = false;
+    }
+
+    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())
+            }
+        }
+    }
+
+    private handleBody(): void {
+        if (this.baseReq.bodyUsed || this.bodyFetched) {
+            return;
+        }
+        this.bodyFetched = true;
+        const rawBody: ArrayBuffer | null = null; // this.context.req.arrayBuffer();
+        if (rawBody == null) {
+            return;
+        }
+        if (rawBody!.byteLength == 0) {
+            return;
+        }
+
+        this.body = ''; // this.context.req.text()
+    }
+
+    getAbsoluteUri(): string {
+        return this.baseReq.url;
+    }
+
+    getCookieValue(cookieKey: string): string {
+        if (this.parsedCookieDic.keys().length == 0) {
+            this.parseCookies(this.getHeader('cookie'))
+        }
+        return this.parsedCookieDic.has(cookieKey) ? decodeURIComponent(this.parsedCookieDic.get(cookieKey)) : '';
+    }
+
+    getHeader(name: string): string {
+        if (name.length == 0) return "";
+        if (!this.baseReq.headers.has(name)) {
+            return '';
+        }
+        const value = this.baseReq.headers.get(name);
+        if (value == null) return '';
+        return value!;
+    }
+
+    getRequestBodyAsString(): string {
+        if (!this.bodyFetched) {
+            this.handleBody();
+        }
+        return this.body;
+    }
+
+    getUserAgent(): string {
+        return this.baseReq.headers.has('user-agent') ? this.baseReq.headers.get('user-agent')! : '';
+    }
+
+    getUserHostAddress(): string {
+        return Fastly.getClientIpAddressString();
+    }
+}
+
+export class FastlyHttpResponse implements IHttpResponse {
+    private readonly headers: Headers;
+
+    constructor() {
+        this.headers = new Headers();
+    }
+
+    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: i64): void {
+        const expirationDate = new Date(expiration * 1000);
+        let setCookieString = cookieName + "=" + encodeURIComponent(cookieValue) + "; expires=" + expirationDate.toUTCString() + ";";
+        if (domain != "") {
+            setCookieString += " domain=" + domain + ";";
+        }
+        setCookieString += " path=/;";
+        this.headers.set('set-cookie', setCookieString);
+    }
+
+    getHeaders(): Headers {
+        return this.headers;
+    }
+}

package/assembly/helper.ts

@@ -1,18 +1,18 @@
-import {Utils} from "./sdk/QueueITHelpers";
-import {hmacString} from "./sdk/helpers/crypto";
+import { Utils } from "./sdk/QueueITHelpers";
+import { hmacString } from "./sdk/helpers/crypto";
 
 export class QueueITHelper {
-    static readonly KUP_VERSION: string = "fastly-1.0.0";
+  static readonly KUP_VERSION: string = "fastly-1.0.3";
 
-    static configureKnownUserHashing(): void {
-        Utils.generateSHA256Hash = hmacString;
-    }
+  static configureKnownUserHashing(): void {
+    Utils.generateSHA256Hash = hmacString;
+  }
 
-    static addKUPlatformVersion(redirectQueueUrl: string): string {
-        return redirectQueueUrl + "&kupver=" + QueueITHelper.KUP_VERSION;
-    }
+  static addKUPlatformVersion(redirectQueueUrl: string): string {
+    return redirectQueueUrl + "&kupver=" + QueueITHelper.KUP_VERSION;
+  }
 }
 
 export interface RequestLogger {
-    log(message: string): void;
+  log(message: string): void;
 }

package/assembly/index.ts

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

package/assembly/integrationConfigProvider.ts

@@ -1,110 +1,146 @@
-import {Fastly, Headers, Request} from "@fastly/as-compute";
-import {RequestLogger} from "./helper";
-
-export function getIntegrationConfig(details: IntegrationDetails, endpointProvider: IntegrationEndpointProvider): string {
-    const headers = new Headers();
-    headers.set('api-key', details.apiKey);
-    headers.set('host', endpointProvider.getHostname(details.customerId));
-    const request = new Request(endpointProvider.getEndpoint(details.customerId), {
-        method: 'GET', body: null, headers: headers
-    })
-    let cacheOverride = new Fastly.CacheOverride();
-    let cacheConf = endpointProvider.getCacheConfig();
-    if (cacheConf.maxAge != -1) {
-        cacheOverride.setTTL(cacheConf.maxAge);
+import { Fastly, Headers, Request } from "@fastly/as-compute";
+import { RequestLogger } from "./helper";
+
+export function getIntegrationConfig(
+  details: IntegrationDetails,
+  endpointProvider: IntegrationEndpointProvider
+): string {
+  const headers = new Headers();
+  headers.set("api-key", details.apiKey);
+  headers.set("host", endpointProvider.getHostname(details.customerId));
+  const request = new Request(
+    endpointProvider.getEndpoint(details.customerId),
+    {
+      method: "GET",
+      body: null,
+      headers: headers,
     }
-    if (cacheConf.staleWhileRevalidate != -1) {
-        cacheOverride.setSWR(cacheConf.staleWhileRevalidate);
-    }
-
-    let beresp = Fastly.fetch(request, {
-        backend: details.queueItOrigin,
-        cacheOverride: cacheOverride
-    }).wait();
-
-    if (!(details.logger instanceof MockLogger)) {
-        let cacheState = beresp.headers.get('x-cache');
-        let hits = beresp.headers.get('x-cache-hits');
-        if (hits == null) hits = '-1';
-        if (cacheState == null) cacheState = 'n';
-        details.logger.log("IgnFetch:" + cacheState! + ":" + hits!);
-    }
-
-    if (beresp.status != 200) {
-        return '';
-    }
-    return beresp.text();
+  );
+  let cacheOverride = new Fastly.CacheOverride();
+  let cacheConf = endpointProvider.getCacheConfig();
+  if (cacheConf.maxAge != -1) {
+    cacheOverride.setTTL(cacheConf.maxAge);
+  }
+  if (cacheConf.staleWhileRevalidate != -1) {
+    cacheOverride.setSWR(cacheConf.staleWhileRevalidate);
+  }
+
+  let beresp = Fastly.fetch(request, {
+    backend: details.queueItOrigin,
+    cacheOverride: cacheOverride,
+  }).wait();
+
+  if (!(details.logger instanceof MockLogger)) {
+    let cacheState = beresp.headers.get("x-cache");
+    let hits = beresp.headers.get("x-cache-hits");
+    if (hits == null) hits = "-1";
+    if (cacheState == null) cacheState = "n";
+    details.logger.log("IgnFetch:" + cacheState! + ":" + hits!);
+  }
+
+  if (beresp.status != 200) {
+    return "";
+  }
+  return beresp.text();
 }
 
 const integrationCustomerId = "customerId",
-    integrationApiKey = 'apiKey',
-    integrationSecret = 'secret',
-    integrationQueueItOrigin = 'queueItOrigin',
-    integrationDictionary = "IntegrationConfiguration";
+  integrationApiKey = "apiKey",
+  integrationSecret = "secret",
+  integrationQueueItOrigin = "queueItOrigin",
+  integrationDictionary = "IntegrationConfiguration",
+  workerHost = "workerHost";
 
 export function resolveIntegrationDetails(): IntegrationDetails | null {
-    const dict = new Fastly.Dictionary(integrationDictionary);
-    if (!dict.contains(integrationCustomerId)
-        || !dict.contains(integrationApiKey)
-        || !dict.contains(integrationSecret)
-        || !dict.contains(integrationQueueItOrigin)) {
-        return null;
-    }
-
-    return new IntegrationDetails(
-        dict.get(integrationQueueItOrigin)!,
-        dict.get(integrationCustomerId)!,
-        dict.get(integrationSecret)!,
-        dict.get(integrationApiKey)!)
+  const dict = new Fastly.Dictionary(integrationDictionary);
+  if (
+    !dict.contains(integrationCustomerId) ||
+    !dict.contains(integrationApiKey) ||
+    !dict.contains(integrationSecret) ||
+    !dict.contains(integrationQueueItOrigin)
+  ) {
+    return null;
+  }
+
+  let workerHostValue = "";
+  if (dict.contains(workerHost)) {
+    workerHostValue = dict.get(workerHost)!;
+  }
+
+  return new IntegrationDetails(
+    dict.get(integrationQueueItOrigin)!,
+    dict.get(integrationCustomerId)!,
+    dict.get(integrationSecret)!,
+    dict.get(integrationApiKey)!,
+    workerHostValue
+  );
 }
 
 export class IntegrationEndpointCacheConfig {
-    maxAge: i16 = -1;
-    staleWhileRevalidate: i16 = -1;
+  maxAge: i16 = -1;
+  staleWhileRevalidate: i16 = -1;
 }
 
 export interface IntegrationEndpointProvider {
-    getHostname(customerId: string): string;
+  getHostname(customerId: string): string;
 
-    getEndpoint(customerId: string): string;
+  getEndpoint(customerId: string): string;
 
-    getCacheConfig(): IntegrationEndpointCacheConfig;
+  getCacheConfig(): IntegrationEndpointCacheConfig;
 }
 
-export class QueueItIntegrationEndpointProvider implements IntegrationEndpointProvider {
-    private readonly cacheConfig: IntegrationEndpointCacheConfig;
-
-    constructor() {
-        this.cacheConfig = new IntegrationEndpointCacheConfig();
-        this.cacheConfig.maxAge = 60 * 5;
-        this.cacheConfig.staleWhileRevalidate = 60 * 5;
-    }
-
-    getCacheConfig(): IntegrationEndpointCacheConfig {
-        return this.cacheConfig;
-    }
-
-    getHostname(customerId: string): string {
-        return customerId + ".queue-it.net";
-    }
-
-    getEndpoint(customerId: string): string {
-        const host = this.getHostname(customerId);
-        return "https://" + host + "/status/integrationconfig/secure/" + customerId;
-    }
+export class QueueItIntegrationEndpointProvider
+  implements IntegrationEndpointProvider
+{
+  private readonly cacheConfig: IntegrationEndpointCacheConfig;
+
+  constructor() {
+    this.cacheConfig = new IntegrationEndpointCacheConfig();
+    this.cacheConfig.maxAge = 60 * 5;
+    this.cacheConfig.staleWhileRevalidate = 60 * 5;
+  }
+
+  getCacheConfig(): IntegrationEndpointCacheConfig {
+    return this.cacheConfig;
+  }
+
+  getHostname(customerId: string): string {
+    return customerId + ".queue-it.net";
+  }
+
+  getEndpoint(customerId: string): string {
+    const host = this.getHostname(customerId);
+    return "https://" + host + "/status/integrationconfig/secure/" + customerId;
+  }
 }
 
 class MockLogger implements RequestLogger {
-    log(message: string): void {
-    }
+  log(message: string): void {}
 }
 
 export class IntegrationDetails {
-    constructor(public queueItOrigin: string,
-                public customerId: string,
-                public secretKey: string,
-                public apiKey: string,
-                public provider: IntegrationEndpointProvider = new QueueItIntegrationEndpointProvider(),
-                public logger: RequestLogger = new MockLogger()) {
+  constructor(
+    public queueItOrigin: string,
+    public customerId: string,
+    public secretKey: string,
+    public apiKey: string,
+    public workerHost: string,
+    public provider: IntegrationEndpointProvider = new QueueItIntegrationEndpointProvider(),
+    public logger: RequestLogger = new MockLogger()
+  ) {}
+
+  resolveWorkerRequestUrl(pureUrl: string): string {
+    if (this.workerHost == "") {
+      return pureUrl;
     }
+    const protoEnding = pureUrl.indexOf("://") + 3;
+    const protocol = pureUrl.substr(0, protoEnding);
+    const urlWithoutProto = pureUrl.substr(protoEnding);
+    const pathAndQuery =
+      urlWithoutProto.indexOf("/") != -1
+        ? urlWithoutProto.substr(urlWithoutProto.indexOf("/"))
+        : "";
+    const rewrittenUrl = protocol + this.workerHost + pathAndQuery;
+    return rewrittenUrl;
+  }
 }

package/assembly/requestResponseHandler.ts

@@ -1,104 +1,136 @@
-import {Request, Response, Headers} from "@fastly/as-compute";
-import {KnownUser} from "./sdk/KnownUser";
-import {QueueITHelper} from "./helper";
-import {FastlyHttpContextProvider, getHttpHandler} from "./contextProvider";
-import {
-    getIntegrationConfig,
-    resolveIntegrationDetails,
-    IntegrationDetails,
-    QueueItIntegrationEndpointProvider
-} from "./integrationConfigProvider"
-import {Utils} from "./sdk/QueueITHelpers";
-
-const QUEUEIT_FAILED_HEADERNAME = 'x-queueit-failed';
-let httpProvider: FastlyHttpContextProvider | null = null;
-
-export function onQueueITRequest(req: Request, conf: IntegrationDetails | null = null): Response | null {
-    if (conf == null) {
-        conf = resolveIntegrationDetails();
-    }
-    if (conf == null) {
-        return new Response(String.UTF8.encode("No integration details found."), {
-            headers: new Headers(),
-            status: 404,
-            url: ''
-        });
-    }
-
-    const integrationProvider = conf.provider == null ? new QueueItIntegrationEndpointProvider() : conf.provider;
-    QueueITHelper.configureKnownUserHashing();
-    httpProvider = getHttpHandler(req);
-
-    let integrationConfigJson = getIntegrationConfig(conf, integrationProvider);
-    const requestUrl: string = req.url;
-    const queueItToken = Utils.getParameterByName(requestUrl, KnownUser.QueueITTokenKey);
-    const requestUrlWithoutToken: string = Utils.removeQueueItToken(requestUrl);
-    // 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 validationResultPair = KnownUser.validateRequestByIntegrationConfig(requestUrlWithoutToken, queueItToken, integrationConfigJson,
-        conf.customerId, conf.secretKey, httpProvider!);
-
-    if (validationResultPair.first != null &&
-        validationResultPair.first!.doRedirect()) {
-        const validationResult = validationResultPair.first!;
-
-        if (validationResult.isAjaxResult) {
-            let response = new Response(null, {
-                status: 200,
-                headers: httpProvider!.getHttpResponse().getHeaders(),
-                url: ''
-            });
-            // 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(validationResult.getAjaxQueueRedirectHeaderKey(), QueueITHelper.addKUPlatformVersion(validationResult.getAjaxRedirectUrl()));
-            Utils.addNoCacheHeaders(response);
-            return response;
-        } else {
-            let response = new Response(null, {
-                status: 302,
-                headers: httpProvider!.getHttpResponse().getHeaders(),
-                url: ''
-            });
-            // Send the user to the queue - either because hash was missing or because is was invalid
-            response.headers.set('Location', QueueITHelper.addKUPlatformVersion(validationResult.redirectUrl));
-            Utils.addNoCacheHeaders(response);
-            return response;
-        }
-    } else if (validationResultPair.first != null) {
-        const validationResult = validationResultPair.first!;
-        // Request can continue - we remove queueittoken form querystring parameter to avoid sharing of user specific token
-        // Support mobile scenario adding the condition !validationResult.isAjaxResult
-        if (queueItToken != '' && !validationResult.isAjaxResult && validationResult.actionType == 'Queue') {
-            let response = new Response(null, {
-                status: 302,
-                headers: httpProvider!.getHttpResponse().getHeaders(),
-                url: requestUrlWithoutToken
-            });
-            response.headers.set('Location', requestUrlWithoutToken);
-            Utils.addNoCacheHeaders(response);
-            return response;
-        } else {
-            // lets caller decide the next step, or just serve the request normally
-            return null;
-        }
-    } else if (validationResultPair.second != null) {
-        httpProvider!.isError = true;
-    }
-
-    return null;
-}
-
-//Fill in the Queue-it headers
-export function onQueueITResponse(res: Response): void {
-    const contextHeaders = httpProvider!.getHttpResponse().getHeaders();
-    const contextHeaderKeys = contextHeaders.keys();
-
-    if (httpProvider!.isError) {
-        res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
-    }
-    for (let i = 0; i < contextHeaderKeys.length; i++) {
-        if (contextHeaderKeys[i].length == 0) continue;
-        let value = contextHeaders.get(contextHeaderKeys[i]);
-        if (value != null && value!.length > 0) res.headers.set(contextHeaderKeys[i], value!);
-    }
-}
+import { Request, Response, Headers } from "@fastly/as-compute";
+import { KnownUser } from "./sdk/KnownUser";
+import { QueueITHelper } from "./helper";
+import { FastlyHttpContextProvider, getHttpHandler } from "./contextProvider";
+import {
+  getIntegrationConfig,
+  resolveIntegrationDetails,
+  IntegrationDetails,
+  QueueItIntegrationEndpointProvider,
+} from "./integrationConfigProvider";
+import { Utils } from "./sdk/QueueITHelpers";
+
+const QUEUEIT_FAILED_HEADERNAME = "x-queueit-failed";
+let httpProvider: FastlyHttpContextProvider | null = null;
+
+export function onQueueITRequest(
+  req: Request,
+  conf: IntegrationDetails | null = null
+): Response | null {
+  if (conf == null) {
+    conf = resolveIntegrationDetails();
+  }
+  if (conf == null) {
+    return new Response(String.UTF8.encode("No integration details found."), {
+      headers: new Headers(),
+      status: 404,
+      url: "",
+    });
+  }
+
+  const integrationProvider =
+    conf.provider == null
+      ? new QueueItIntegrationEndpointProvider()
+      : conf.provider;
+  QueueITHelper.configureKnownUserHashing();
+  httpProvider = getHttpHandler(req);
+
+  let integrationConfigJson = getIntegrationConfig(conf, integrationProvider);
+  const requestUrl: string = conf.resolveWorkerRequestUrl(req.url);
+
+  const queueItToken = Utils.getParameterByName(
+    requestUrl,
+    KnownUser.QueueITTokenKey
+  );
+  const requestUrlWithoutToken: string = Utils.removeQueueItToken(requestUrl);
+
+  // 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 validationResultPair = KnownUser.validateRequestByIntegrationConfig(
+    requestUrlWithoutToken,
+    queueItToken,
+    integrationConfigJson,
+    conf.customerId,
+    conf.secretKey,
+    httpProvider!
+  );
+
+  if (
+    validationResultPair.first != null &&
+    validationResultPair.first!.doRedirect()
+  ) {
+    const validationResult = validationResultPair.first!;
+
+    if (validationResult.isAjaxResult) {
+      let response = new Response(null, {
+        status: 200,
+        headers: httpProvider!.getHttpResponse().getHeaders(),
+        url: "",
+      });
+      // 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(
+        validationResult.getAjaxQueueRedirectHeaderKey(),
+        QueueITHelper.addKUPlatformVersion(
+          validationResult.getAjaxRedirectUrl()
+        )
+      );
+      Utils.addNoCacheHeaders(response);
+      return response;
+    } else {
+      let response = new Response(null, {
+        status: 302,
+        headers: httpProvider!.getHttpResponse().getHeaders(),
+        url: "",
+      });
+      // Send the user to the queue - either because hash was missing or because is was invalid
+      response.headers.set(
+        "Location",
+        QueueITHelper.addKUPlatformVersion(validationResult.redirectUrl)
+      );
+      Utils.addNoCacheHeaders(response);
+      return response;
+    }
+  } else if (validationResultPair.first != null) {
+    const validationResult = validationResultPair.first!;
+    // Request can continue - we remove queueittoken form querystring parameter to avoid sharing of user specific token
+    // Support mobile scenario adding the condition !validationResult.isAjaxResult
+    if (
+      queueItToken != "" &&
+      !validationResult.isAjaxResult &&
+      validationResult.actionType == "Queue"
+    ) {
+      let response = new Response(null, {
+        status: 302,
+        headers: httpProvider!.getHttpResponse().getHeaders(),
+        url: requestUrlWithoutToken,
+      });
+      response.headers.set("Location", requestUrlWithoutToken);
+      Utils.addNoCacheHeaders(response);
+      return response;
+    } else {
+      // lets caller decide the next step, or just serve the request normally
+      return null;
+    }
+  } else if (validationResultPair.second != null) {
+    httpProvider!.isError = true;
+  }
+
+  return null;
+}
+
+//Fill in the Queue-it headers
+export function onQueueITResponse(res: Response): void {
+  const contextHeaders = httpProvider!.getHttpResponse().getHeaders();
+  const contextHeaderKeys = contextHeaders.keys();
+
+  if (httpProvider!.isError) {
+    res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
+  }
+  for (let i = 0; i < contextHeaderKeys.length; i++) {
+    if (contextHeaderKeys[i].length == 0) continue;
+    let value = contextHeaders.get(contextHeaderKeys[i]);
+    if (value != null && value!.length > 0)
+      res.headers.append(contextHeaderKeys[i], value!);
+  }
+}

package/assembly/sdk/HttpContextProvider.ts

@@ -1,24 +1,24 @@
-import { Headers } from "@fastly/as-compute";
-
-export interface IHttpRequest {
-    getUserAgent(): string;
-    getHeader(name: string): string;
-    getAbsoluteUri(): string;
-    getUserHostAddress(): string;
-    getCookieValue(cookieKey: string): string;
-    getRequestBodyAsString(): string;
-}
-
-export interface IHttpResponse {
-    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: i64): void;
-    getHeaders(): Headers;
-}
-
-export interface IHttpContextProvider {
-    getHttpRequest(): IHttpRequest;
-    getHttpResponse(): IHttpResponse;
-}
-
-export interface IDateTimeProvider {
-    getCurrentTime(): Date
-}
+import { Headers } from "@fastly/as-compute";
+
+export interface IHttpRequest {
+    getUserAgent(): string;
+    getHeader(name: string): string;
+    getAbsoluteUri(): string;
+    getUserHostAddress(): string;
+    getCookieValue(cookieKey: string): string;
+    getRequestBodyAsString(): string;
+}
+
+export interface IHttpResponse {
+    setCookie(cookieName: string, cookieValue: string, domain: string, expiration: i64): void;
+    getHeaders(): Headers;
+}
+
+export interface IHttpContextProvider {
+    getHttpRequest(): IHttpRequest;
+    getHttpResponse(): IHttpResponse;
+}
+
+export interface IDateTimeProvider {
+    getCurrentTime(): Date
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@queue-it/fastly",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Queue-it connector for Fastly",
   "main": "assembly/index.ts",
   "ascMain": "assembly/index.ts",