@queue-it/fastly 1.0.3 → 1.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Queue-it
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,129 +1,91 @@
-# 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
+
+Before getting started please read the [documentation](https://github.com/queueit/Documentation/tree/main/edge-connectors) to get acquainted with edge connectors.
+
+This Fastly Queue-it Connector (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).
+
+## 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 file (release-package.tar.gz) 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},
+        {workerHost});
+let res = onQueueITRequest(req, integrationDetails);
+*/
+
+let res = onQueueITRequest(req, null);
+
+if (res != null) {
+    Fastly.respondWith(res!);
+} else {
+    const myOrigin = 'origin';
+    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.

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

@@ -2,7 +2,7 @@ import { Utils } from "./sdk/QueueITHelpers";
 import { hmacString } from "./sdk/helpers/crypto";
 
 export class QueueITHelper {
-  static readonly KUP_VERSION: string = "fastly-1.0.3";
+  static readonly KUP_VERSION: string = "fastly-1.0.4";
 
   static configureKnownUserHashing(): void {
     Utils.generateSHA256Hash = hmacString;

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/requestResponseHandler.ts

@@ -1,136 +1,137 @@
-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!);
-  }
-}
+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("Access-Control-Expose-Headers", validationResult.getAjaxQueueRedirectHeaderKey());
+      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/assembly/sdk/UserInQueueService.ts

@@ -3,7 +3,7 @@ import {ActionTypes, RequestValidationResult, QueueEventConfig, CancelEventConfi
 import {StateInfo, UserInQueueStateCookieRepository} from './UserInQueueStateCookieRepository'
 
 export class UserInQueueService {
-    static readonly SDK_VERSION: string = "v3-asmscrpt-" + "3.6.0";
+    static readonly SDK_VERSION: string = "v3-asmscrpt-3.6.1";
 
     constructor(private userInQueueStateRepository: UserInQueueStateCookieRepository) {
     }

package/package.json

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