@queue-it/fastly 2.0.2 → 2.0.3-beta.1

package/src/index.ts

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

package/src/integrationConfigProvider.ts

@@ -1,3 +1,4 @@
+import { ConfigStore } from "fastly:config-store";
 import { RequestLogger } from "./helper";
 
 export async function getIntegrationConfig(

package/src/requestResponseHandler.ts

@@ -1,131 +1,129 @@
-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 async function onQueueITRequest(
-  req: Request,
-  conf: IntegrationDetails | null = null
-): Promise<Response | null> {
-  if (conf == null) {
-    conf = resolveIntegrationDetails();
-  }
-  if (conf == null) {
-    return new Response("No integration details found.", {
-      headers: new Headers(),
-      status: 404,
-    });
-  }
-
-  const integrationProvider =
-    conf.provider == null
-      ? new QueueItIntegrationEndpointProvider()
-      : conf.provider;
-  QueueITHelper.configureKnownUserHashing();
-  httpProvider = getHttpHandler(req);
-
-  let integrationConfigJson = await 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(),
-      });
-      // 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(),
-      });
-      // 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(),
-      });
-      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();
-
-  if (httpProvider!.isError) {
-    res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
-  }
-  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);
-  }
-}
+import { KnownUser, Utils } from "@queue-it/connector-javascript";
+import { QueueITHelper } from "./helper";
+import { FastlyHttpContextProvider, getHttpHandler } from "./contextProvider";
+import {
+  getIntegrationConfig,
+  resolveIntegrationDetails,
+  IntegrationDetails,
+  QueueItIntegrationEndpointProvider,
+} from "./integrationConfigProvider";
+
+const QUEUEIT_FAILED_HEADERNAME = "x-queueit-failed";
+let httpProvider: FastlyHttpContextProvider | null = null;
+
+export async function onQueueITRequest(
+  req: Request,
+  conf: IntegrationDetails | null = null
+): Promise<Response | null> {
+  if (conf == null) {
+    conf = resolveIntegrationDetails();
+  }
+  if (conf == null) {
+    return new Response("No integration details found.", {
+      headers: new Headers(),
+      status: 404,
+    });
+  }
+
+  const integrationProvider =
+    conf.provider == null
+      ? new QueueItIntegrationEndpointProvider()
+      : conf.provider;
+  httpProvider = getHttpHandler(req);
+
+  let integrationConfigJson = await 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(),
+      });
+      // 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(),
+      });
+      // 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(),
+      });
+      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();
+
+  if (httpProvider!.isError) {
+    res.headers.append(QUEUEIT_FAILED_HEADERNAME, "true");
+  }
+  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);
+  }
+}

package/LICENSE

@@ -1,21 +0,0 @@
-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/src/sdk/HttpContextProvider.ts

@@ -1,23 +0,0 @@
-
-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: number): void;
-    getHeaders(): Headers;
-}
-
-export interface IHttpContextProvider {
-    getHttpRequest(): IHttpRequest;
-    getHttpResponse(): IHttpResponse;
-}
-
-export interface IDateTimeProvider {
-    getCurrentTime(): Date
-}

package/src/sdk/IntegrationConfig/CustomerIntegrationDecodingHandler.ts

@@ -1,57 +0,0 @@
-import {
-    CustomerIntegration,
-    IntegrationConfigModel,
-    TriggerModel,
-    TriggerPart
-} from "./IntegrationConfigModel";
-
-export class CustomerIntegrationDecodingHandler {
-    static deserialize(integrationsConfigString: string): CustomerIntegration {
-        const result = new CustomerIntegration();
-        if (!integrationsConfigString) return result;
-
-        const parsed = JSON.parse(integrationsConfigString);
-        result.Version = parsed.Version ?? 0;
-        result.Description = parsed.Description ?? '';
-
-        if (Array.isArray(parsed.Integrations)) {
-            result.Integrations = parsed.Integrations.map((item: any) => {
-                const model = new IntegrationConfigModel();
-                model.Name = item.Name ?? '';
-                model.EventId = item.EventId ?? '';
-                model.CookieDomain = item.CookieDomain ?? '';
-                model.LayoutName = item.LayoutName ?? '';
-                model.Culture = item.Culture ?? '';
-                model.ExtendCookieValidity = item.ExtendCookieValidity ?? false;
-                model.CookieValidityMinute = item.CookieValidityMinute ?? 0;
-                model.QueueDomain = item.QueueDomain ?? '';
-                model.RedirectLogic = item.RedirectLogic ?? '';
-                model.ForcedTargetUrl = item.ForcedTargetUrl ?? '';
-                model.ActionType = item.ActionType ?? '';
-
-                model.Triggers = (item.Triggers ?? []).map((trigger: any) => {
-                    const t = new TriggerModel();
-                    t.LogicalOperator = trigger.LogicalOperator ?? '';
-                    t.TriggerParts = (trigger.TriggerParts ?? []).map((part: any) => {
-                        const tp = new TriggerPart();
-                        tp.ValidatorType = part.ValidatorType ?? '';
-                        tp.Operator = part.Operator ?? '';
-                        tp.ValueToCompare = part.ValueToCompare ?? '';
-                        tp.ValuesToCompare = part.ValuesToCompare ?? [];
-                        tp.IsNegative = part.IsNegative ?? false;
-                        tp.IsIgnoreCase = part.IsIgnoreCase ?? false;
-                        tp.UrlPart = part.UrlPart ?? '';
-                        tp.CookieName = part.CookieName ?? '';
-                        tp.HttpHeaderName = part.HttpHeaderName ?? '';
-                        return tp;
-                    });
-                    return t;
-                });
-
-                return model;
-            });
-        }
-
-        return result;
-    }
-}

package/src/sdk/IntegrationConfig/IntegrationConfigHelpers.ts

@@ -1,230 +0,0 @@
-import * as IntegrationModels from './IntegrationConfigModel'
-import {KnownUserException} from '../Models'
-import {IHttpRequest} from '../HttpContextProvider'
-
-export interface IIntegrationEvaluator {
-    getMatchedIntegrationConfig(
-        customerIntegration: IntegrationModels.CustomerIntegration,
-        currentPageUrl: string,
-        request: IHttpRequest): IntegrationModels.IntegrationConfigModelResult | null;
-}
-
-export class IntegrationEvaluator implements IIntegrationEvaluator {
-    public getMatchedIntegrationConfig(
-        customerIntegration: IntegrationModels.CustomerIntegration,
-        currentPageUrl: string,
-        request: IHttpRequest | null): IntegrationModels.IntegrationConfigModelResult | null {
-
-        if (request == null)
-            return new IntegrationModels.IntegrationConfigModelResult(null, new KnownUserException("request is null"));
-
-        if (customerIntegration == null)
-            return new IntegrationModels.IntegrationConfigModelResult(null, new KnownUserException("customerIntegration is null"));
-
-        for (let i = 0; i < customerIntegration.Integrations.length; i++) {
-            let integration = customerIntegration.Integrations[i];
-            for (let t = 0; t < integration.Triggers.length; t++) {
-                let trigger = integration.Triggers[t];
-                if (this.evaluateTrigger(trigger, currentPageUrl, request)) {
-                    return new IntegrationModels.IntegrationConfigModelResult(integration, null);
-                }
-            }
-        }
-        return null;
-    }
-
-    private evaluateTrigger(trigger: IntegrationModels.TriggerModel, currentPageUrl: string, request: IHttpRequest): boolean {
-        if (trigger.LogicalOperator == IntegrationModels.LogicalOperatorType.Or) {
-            for (let i = 0; i < trigger.TriggerParts.length; i++) {
-                let part = trigger.TriggerParts[i];
-                if (this.evaluateTriggerPart(part, currentPageUrl, request))
-                    return true;
-            }
-            return false;
-        } else {
-            for (let i = 0; i < trigger.TriggerParts.length; i++) {
-                let part = trigger.TriggerParts[i];
-                let matched = this.evaluateTriggerPart(part, currentPageUrl, request);
-                if (!matched)
-                    return false;
-            }
-            return true;
-        }
-    }
-
-    private evaluateTriggerPart(triggerPart: IntegrationModels.TriggerPart, currentPageUrl: string, request: IHttpRequest): boolean {
-        if (triggerPart.ValidatorType == IntegrationModels.ValidatorType.UrlValidator) {
-            return UrlValidatorHelper.evaluate(triggerPart, currentPageUrl);
-        } else if (triggerPart.ValidatorType == IntegrationModels.ValidatorType.CookieValidator) {
-            return CookieValidatorHelper.evaluate(triggerPart, request);
-        } else if (triggerPart.ValidatorType == IntegrationModels.ValidatorType.UserAgentValidator) {
-            return UserAgentValidatorHelper.evaluate(triggerPart, request.getUserAgent());
-        } else if (triggerPart.ValidatorType == IntegrationModels.ValidatorType.HttpHeaderValidator) {
-            return HttpHeaderValidatorHelper.evaluate(triggerPart, request.getHeader(triggerPart.HttpHeaderName));
-        } else if (triggerPart.ValidatorType == IntegrationModels.ValidatorType.RequestBodyValidator) {
-            return RequestBodyValidatorHelper.evaluate(triggerPart, request.getRequestBodyAsString());
-        } else {
-            return false;
-        }
-    }
-}
-
-export class UrlValidatorHelper {
-    public static evaluate(triggerPart: IntegrationModels.TriggerPart, url: string): boolean {
-        let urlpart = this.getUrlPart(triggerPart, url);
-        return ComparisonOperatorHelper.evaluate(
-            triggerPart.Operator,
-            triggerPart.IsNegative,
-            triggerPart.IsIgnoreCase,
-            urlpart,
-            triggerPart.ValueToCompare,
-            triggerPart.ValuesToCompare);
-    }
-
-    private static getUrlPart(triggerPart: IntegrationModels.TriggerPart, url: string): string {
-        if (triggerPart.UrlPart == IntegrationModels.UrlPartType.PagePath) {
-            return this.getPathFromUrl(url);
-        } else if (triggerPart.UrlPart == IntegrationModels.UrlPartType.PageUrl) {
-            return url;
-        } else if (triggerPart.UrlPart == IntegrationModels.UrlPartType.HostName) {
-            return this.getHostNameFromUrl(url);
-        } else {
-            return "";
-        }
-    }
-
-    public static getHostNameFromUrl(url: string): string {
-        let urlx = new URL(url);
-        return urlx.host;
-    }
-
-    public static getPathFromUrl(url: string): string {
-        let urlx = new URL(url);
-        return urlx.pathname;
-    }
-}
-
-export class CookieValidatorHelper {
-    public static evaluate(triggerPart: IntegrationModels.TriggerPart, request: IHttpRequest): boolean {
-        return ComparisonOperatorHelper.evaluate(triggerPart.Operator,
-            triggerPart.IsNegative,
-            triggerPart.IsIgnoreCase,
-            this.getCookie(triggerPart.CookieName, request),
-            triggerPart.ValueToCompare,
-            triggerPart.ValuesToCompare);
-    }
-
-    private static getCookie(cookieName: string, request: IHttpRequest): string {
-        return request.getCookieValue(cookieName);
-    }
-}
-
-export class UserAgentValidatorHelper {
-    public static evaluate(triggerPart: IntegrationModels.TriggerPart, userAgent: string): boolean {
-
-        return ComparisonOperatorHelper.evaluate(triggerPart.Operator,
-            triggerPart.IsNegative,
-            triggerPart.IsIgnoreCase,
-            userAgent,
-            triggerPart.ValueToCompare,
-            triggerPart.ValuesToCompare);
-    }
-}
-
-export class RequestBodyValidatorHelper {
-    public static evaluate(triggerPart: IntegrationModels.TriggerPart, bodyString: string): boolean {
-
-        return ComparisonOperatorHelper.evaluate(triggerPart.Operator,
-            triggerPart.IsNegative,
-            triggerPart.IsIgnoreCase,
-            bodyString,
-            triggerPart.ValueToCompare,
-            triggerPart.ValuesToCompare);
-    }
-}
-
-export class HttpHeaderValidatorHelper {
-    public static evaluate(triggerPart: IntegrationModels.TriggerPart, headerValue: string): boolean {
-        return ComparisonOperatorHelper.evaluate(triggerPart.Operator,
-            triggerPart.IsNegative,
-            triggerPart.IsIgnoreCase,
-            headerValue,
-            triggerPart.ValueToCompare,
-            triggerPart.ValuesToCompare);
-    }
-}
-
-export class ComparisonOperatorHelper {
-    public static evaluate(opt: string,
-                           isNegative: boolean,
-                           isIgnoreCase: boolean,
-                           value: string,
-                           valueToCompare: string,
-                           valuesToCompare: Array<string> | null): boolean {
-        if (valuesToCompare == null) {
-            valuesToCompare = new Array<string>();
-        }
-        if (opt == IntegrationModels.ComparisonOperatorType.EqualS) {
-            return ComparisonOperatorHelper.equalS(value, valueToCompare, isNegative, isIgnoreCase);
-        } else if (opt == IntegrationModels.ComparisonOperatorType.Contains) {
-            return ComparisonOperatorHelper.contains(value, valueToCompare, isNegative, isIgnoreCase);
-        } else if (opt == IntegrationModels.ComparisonOperatorType.EqualsAny) {
-            return ComparisonOperatorHelper.equalsAny(value, valuesToCompare, isNegative, isIgnoreCase);
-        } else if (opt == IntegrationModels.ComparisonOperatorType.ContainsAny) {
-            return ComparisonOperatorHelper.containsAny(value, valuesToCompare, isNegative, isIgnoreCase);
-        } else {
-            return false;
-        }
-    }
-
-    private static contains(value: string, valueToCompare: string, isNegative: boolean, ignoreCase: boolean): boolean {
-        if (valueToCompare == "*" && value != "")
-            return true;
-
-        let evaluation = false;
-
-        if (ignoreCase)
-            evaluation = value.toUpperCase().indexOf(valueToCompare.toUpperCase()) != -1;
-        else
-            evaluation = value.indexOf(valueToCompare) != -1;
-
-        if (isNegative)
-            return !evaluation;
-        else
-            return evaluation;
-    }
-
-    private static equalS(value: string, valueToCompare: string, isNegative: boolean, ignoreCase: boolean): boolean {
-        let evaluation = false;
-
-        if (ignoreCase)
-            evaluation = value.toUpperCase() == valueToCompare.toUpperCase();
-        else
-            evaluation = value == valueToCompare;
-
-        if (isNegative)
-            return !evaluation;
-        else
-            return evaluation;
-    }
-
-    private static equalsAny(value: string, valuesToCompare: Array<string>, isNegative: boolean, isIgnoreCase: boolean): boolean {
-        for (let i = 0; i < valuesToCompare.length; i++) {
-            let valueToCompare = valuesToCompare[i];
-            if (ComparisonOperatorHelper.equalS(value, valueToCompare, false, isIgnoreCase))
-                return !isNegative;
-        }
-
-        return isNegative;
-    }
-
-    private static containsAny(value: string, valuesToCompare: Array<string>, isNegative: boolean, isIgnoreCase: boolean): boolean {
-        for (let i = 0; i < valuesToCompare.length; i++) {
-            let valueToCompare = valuesToCompare[i];
-            if (ComparisonOperatorHelper.contains(value, valueToCompare, false, isIgnoreCase))
-                return !isNegative;
-        }
-
-        return isNegative;
-    }
-}