@speedkit/cli 2.14.0 → 2.14.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.14.2](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v2.14.1...v2.14.2) (2024-03-20)
+
+
+### Bug Fixes
+
+* **onboarding:** do not minify installResource ([c426acd](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/c426acd27347b2ea349a73e530e1ea6070d80e77))
+
+## [2.14.1](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v2.14.0...v2.14.1) (2024-03-20)
+
+
+### Bug Fixes
+
+* **onboarding:** undo perfectionist sorting ([db3ba2e](https://gitlab.orestes.info/baqend/speed-kit-cli/commit/db3ba2ec7395ab84a7e795e5c10f3f463148a97c))
+
 # [2.14.0](https://gitlab.orestes.info/baqend/speed-kit-cli/compare/v2.13.0...v2.14.0) (2024-03-18)
 
 

package/README.md

@@ -21,7 +21,7 @@ $ npm install -g @speedkit/cli
 $ sk COMMAND
 running command...
 $ sk (--version)
-@speedkit/cli/2.14.0 linux-x64 node-v20.11.1
+@speedkit/cli/2.14.2 linux-x64 node-v20.11.1
 $ sk --help [COMMAND]
 USAGE
   $ sk COMMAND

package/dist/services/onboarding/browser/baqend-response.d.ts

@@ -1,12 +1,12 @@
 import Protocol from "devtools-protocol";
 export declare class BaqendResponse implements Partial<Protocol.Fetch.FulfillRequestRequest> {
-    readonly body: string;
     readonly requestId?: string;
     readonly responseCode: number;
+    readonly body: string;
     responseHeaders: Protocol.Fetch.HeaderEntry[];
-    private contentLength;
     private contentType;
+    private contentLength;
     constructor(body: string, contentType?: string, headers?: Protocol.Fetch.HeaderEntry[], status?: number);
-    protected addCustomHeaders(headers?: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[];
     setHeader(name: string, value: string): void;
+    protected addCustomHeaders(headers?: Protocol.Fetch.HeaderEntry[]): Protocol.Fetch.HeaderEntry[];
 }

package/dist/services/onboarding/browser/baqend-response.js

@@ -8,12 +8,12 @@ const DEFAULT_HEADERS = [
 const DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8";
 const DEFAULT_STATUS = 200;
 class BaqendResponse {
-    body;
     requestId;
     responseCode;
+    body;
     responseHeaders;
-    contentLength;
     contentType;
+    contentLength;
     constructor(body, contentType, headers, status) {
         this.responseCode = status || DEFAULT_STATUS;
         this.contentType = contentType || DEFAULT_CONTENT_TYPE;
@@ -24,6 +24,15 @@ class BaqendResponse {
         this.contentLength = body.length;
         this.body = Buffer.from(body).toString("base64");
     }
+    setHeader(name, value) {
+        for (const header of this.responseHeaders) {
+            if (header.name === name) {
+                header.value = value;
+                return;
+            }
+        }
+        this.responseHeaders.push({ name, value });
+    }
     addCustomHeaders(headers) {
         if (!headers?.find((o) => o.name === "Cache-Control")) {
             headers.push({
@@ -44,17 +53,9 @@ class BaqendResponse {
         if (!headers?.find((o) => o.name === "Content-Type")) {
             headers.push({ name: "Content-Type", value: String(this.contentType) });
         }
-        headers.push({ name: "via", value: "sk-onboarding" }, { name: "Service-Worker-Allowed", value: "/" });
+        headers.push({ name: "via", value: "sk-onboarding" });
+        headers.push({ name: "Service-Worker-Allowed", value: "/" });
         return headers;
     }
-    setHeader(name, value) {
-        for (const header of this.responseHeaders) {
-            if (header.name === name) {
-                header.value = value;
-                return;
-            }
-        }
-        this.responseHeaders.push({ name, value });
-    }
 }
 exports.BaqendResponse = BaqendResponse;

package/dist/services/onboarding/config-renderer/speed-kit-install-context.d.ts

@@ -1,7 +1,7 @@
+import { InstallSpeedKitJsTemplate } from "../templates/install-speed-kit-js-template";
+import CustomerConfig from "../../integration-api/struct/customer-config";
 import { BundleService } from "../../bundler";
 import { FileListInterface } from "../../integration-api/integration-api-model";
-import CustomerConfig from "../../integration-api/struct/customer-config";
-import { InstallSpeedKitJsTemplate } from "../templates/install-speed-kit-js-template";
 export declare class SpeedKitInstallContext {
     private customerConfig;
     private configName;
@@ -10,6 +10,8 @@ export declare class SpeedKitInstallContext {
     private skTemplate;
     private isLocalRuntime;
     constructor(customerConfig: CustomerConfig, configName: string, files: FileListInterface, bundler: BundleService, skTemplate: InstallSpeedKitJsTemplate, isLocalRuntime?: boolean);
+    getSpeedKitInstallJs(): Promise<string>;
+    private getConfigSpeedKit;
     /**
      * Fetches and returns the latest dynamic fetcher from the code repository. If a new version is available online it is
      * downloaded and cached, otherwise the fetcher id returned from cache. The resulting module gets minified afterwards.
@@ -17,6 +19,4 @@ export declare class SpeedKitInstallContext {
      * @returns {Promise<string>} a Promise which resolves to the latest dynamic fetcher
      */
     bundleDynamicFetcher(): Promise<string>;
-    private getConfigSpeedKit;
-    getSpeedKitInstallJs(): Promise<string>;
 }

package/dist/services/onboarding/config-renderer/speed-kit-install-context.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SpeedKitInstallContext = void 0;
 const files_1 = require("../../../models/files");
 const IMPORT_PATHS = {
-    "predictive-preloading": "https://www.baqend.com/speed-kit-predictive-preloading/latest/",
     rum: "https://www.baqend.com/rum/latest/",
     "speed-kit": "https://www.baqend.com/speed-kit/latest/",
+    "predictive-preloading": "https://www.baqend.com/speed-kit-predictive-preloading/latest/",
 };
 class SpeedKitInstallContext {
     customerConfig;
@@ -22,24 +22,33 @@ class SpeedKitInstallContext {
         this.skTemplate = skTemplate;
         this.isLocalRuntime = isLocalRuntime;
     }
-    /**
-     * Fetches and returns the latest dynamic fetcher from the code repository. If a new version is available online it is
-     * downloaded and cached, otherwise the fetcher id returned from cache. The resulting module gets minified afterwards.
-     *
-     * @returns {Promise<string>} a Promise which resolves to the latest dynamic fetcher
-     */
-    async bundleDynamicFetcher() {
+    async getSpeedKitInstallJs() {
+        const configJs = this.skTemplate.render({
+            config: this.getConfigSpeedKit(),
+            forceInstall: this.customerConfig.forceInstall,
+            installPath: this.customerConfig.installPath,
+            installParams: this.customerConfig.installParams,
+            domain: this.customerConfig.domain,
+            df: this.files
+                .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
+                .getContent(),
+        });
         return this.bundler.bundle({
-            basePaths: {},
+            basePaths: IMPORT_PATHS,
             entryPoints: {
-                "dynamicFetcher.js": this.files
-                    .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
+                "rum.js": this.files
+                    .getByName(files_1.INTEGRATION_FILES.CONFIG.LOAD_HANDLER)
+                    .getContent(),
+                "config.js": configJs,
+                "loader.js": this.files
+                    .getByName(files_1.INTEGRATION_FILES.CUSTOM.LOADER)
                     .getContent(),
             },
-            logLevel: "verbose",
+            logLevel: "error",
             minify: false,
-            platform: "browser",
-            target: "es6",
+            define: {
+                APP: JSON.stringify(this.customerConfig.app),
+            },
         });
     }
     getConfigSpeedKit() {
@@ -50,7 +59,7 @@ class SpeedKitInstallContext {
             return configString;
         }
         if (configString.includes("delayRacedOrigin")) {
-            return configString.replace(/delayRacedOrigin:[^\d,|](\d*)[^,]*,/, (config, value) => {
+            return configString.replace(/delayRacedOrigin:[^,|\d](\d*)[^,]*,/, (config, value) => {
                 return config.replace(value, "100");
             });
         }
@@ -58,32 +67,24 @@ class SpeedKitInstallContext {
             return configOpenTag + `\n delayRacedOrigin: 100,\n`;
         });
     }
-    async getSpeedKitInstallJs() {
-        const configJs = this.skTemplate.render({
-            config: this.getConfigSpeedKit(),
-            forceInstall: this.customerConfig.forceInstall,
-            installPath: this.customerConfig.installPath,
-            installParams: this.customerConfig.installParams,
-            domain: this.customerConfig.domain,
-            df: this.files
-                .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
-                .getContent(),
-        });
+    /**
+     * Fetches and returns the latest dynamic fetcher from the code repository. If a new version is available online it is
+     * downloaded and cached, otherwise the fetcher id returned from cache. The resulting module gets minified afterwards.
+     *
+     * @returns {Promise<string>} a Promise which resolves to the latest dynamic fetcher
+     */
+    async bundleDynamicFetcher() {
         return this.bundler.bundle({
-            basePaths: IMPORT_PATHS,
-            define: {
-                APP: JSON.stringify(this.customerConfig.app),
-            },
+            basePaths: {},
             entryPoints: {
-                "config.js": configJs,
-                "loader.js": this.files
-                    .getByName(files_1.INTEGRATION_FILES.CUSTOM.LOADER)
-                    .getContent(),
-                "rum.js": this.files
-                    .getByName(files_1.INTEGRATION_FILES.CONFIG.LOAD_HANDLER)
+                "dynamicFetcher.js": this.files
+                    .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
                     .getContent(),
             },
-            logLevel: "error",
+            target: "es6",
+            logLevel: "verbose",
+            minify: false,
+            platform: "browser",
         });
     }
 }

package/dist/services/onboarding/dashboard/athena-service.d.ts

@@ -6,6 +6,6 @@ export declare class AthenaService {
     private lastQueryResult;
     constructor(athena: Athena, cli: CliService);
     executeQuery(queryString: string): Promise<unknown[]>;
-    getLastQueryResult(): unknown[];
     private fetchResult;
+    getLastQueryResult(): unknown[];
 }

package/dist/services/onboarding/dashboard/athena-service.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AthenaService = void 0;
 const tslib_1 = require("tslib");
-const node_util_1 = tslib_1.__importDefault(require("node:util"));
-const safe_1 = require("../../../helpers/safe");
+const util_1 = tslib_1.__importDefault(require("util"));
 const cli_1 = require("../../cli");
-const sleep = node_util_1.default.promisify(setTimeout);
+const safe_1 = require("../../../helpers/safe");
+const sleep = util_1.default.promisify(setTimeout);
 class AthenaService {
     athena;
     cli;
@@ -19,10 +19,10 @@ class AthenaService {
             return this.lastQueryResult;
         }
         const params = {
+            QueryString: queryString,
             QueryExecutionContext: {
                 Database: "rum.pi",
             },
-            QueryString: queryString,
         };
         this.cli.startAction("[athena-query]: fetch result");
         const result = await (0, safe_1.safe)(this.fetchResult(params));
@@ -34,9 +34,6 @@ class AthenaService {
         this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
         this.cli.writeError(result.error);
     }
-    getLastQueryResult() {
-        return this.lastQueryResult;
-    }
     async fetchResult(params) {
         const request = await this.athena.startQueryExecution(params);
         let queryStatus = await this.athena.getQueryExecution({
@@ -56,20 +53,23 @@ class AthenaService {
         const queryResult = await this.athena.getQueryResults(queryParams);
         // transform result and return it
         const dataArray = [];
-        for (const recordRow of queryResult.ResultSet.Rows) {
+        queryResult.ResultSet.Rows.forEach((recordRow) => {
             const object = {
-                PIs: recordRow.Data[3].VarCharValue,
+                params: recordRow.Data[0].VarCharValue,
+                potentialGain: recordRow.Data[1].VarCharValue,
                 cachedUrls: recordRow.Data[2].VarCharValue,
+                PIs: recordRow.Data[3].VarCharValue,
                 example1: recordRow.Data[4].VarCharValue,
                 example2: recordRow.Data[5].VarCharValue,
                 example3: recordRow.Data[6].VarCharValue,
-                params: recordRow.Data[0].VarCharValue,
-                potentialGain: recordRow.Data[1].VarCharValue,
             };
             // into an array....
             dataArray.push(object);
-        }
+        });
         return dataArray;
     }
+    getLastQueryResult() {
+        return this.lastQueryResult;
+    }
 }
 exports.AthenaService = AthenaService;

package/dist/services/onboarding/dashboard/index.d.ts

@@ -1,10 +1,10 @@
+import { BaqendResponse } from "../browser/baqend-response";
 import { Protocol } from "devtools-protocol";
+import { ParamQueryBuilder } from "./param-query-builder";
 import CustomerConfig from "../../integration-api/struct/customer-config";
-import { BaqendResponse } from "../browser/baqend-response";
-import { Cache } from "../request-cache/cache";
 import { AthenaService } from "./athena-service";
-import { ParamQueryBuilder } from "./param-query-builder";
 import { RequestDiffService } from "./request-diff-service";
+import { Cache } from "../request-cache/cache";
 export declare class Dashboard {
     private customerConfig;
     private paramQueryBuilder;

package/dist/services/onboarding/dashboard/index.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Dashboard = void 0;
 const tslib_1 = require("tslib");
-const json2csv_1 = tslib_1.__importDefault(require("json2csv"));
-const node_fs_1 = require("node:fs");
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const safe_1 = require("../../../helpers/safe");
 const baqend_response_1 = require("../browser/baqend-response");
+const fs_1 = require("fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+const safe_1 = require("../../../helpers/safe");
+const json2csv_1 = tslib_1.__importDefault(require("json2csv"));
 class Dashboard {
     customerConfig;
     paramQueryBuilder;
@@ -23,13 +23,13 @@ class Dashboard {
     async getResponse(request) {
         const url = new URL(request.url);
         if (url.pathname === "/") {
-            const filePath = node_path_1.default.join(__dirname, "./frontend-dist", "index.html");
-            const content = (0, node_fs_1.readFileSync)(filePath, { encoding: "utf8" });
+            const filePath = path_1.default.join(__dirname, "./frontend-dist", "index.html");
+            const content = (0, fs_1.readFileSync)(filePath, { encoding: "utf-8" });
             return new baqend_response_1.BaqendResponse(content);
         }
         if (url.pathname.startsWith("/assets/")) {
-            const filePath = node_path_1.default.join(__dirname, "./frontend-dist", url.pathname);
-            const content = (0, node_fs_1.readFileSync)(filePath, { encoding: "utf8" });
+            const filePath = path_1.default.join(__dirname, "./frontend-dist", url.pathname);
+            const content = (0, fs_1.readFileSync)(filePath, { encoding: "utf-8" });
             let contentType = "application/javascript; charset=UTF-8";
             if (url.pathname.includes(".css")) {
                 contentType = "text/css";
@@ -40,7 +40,7 @@ class Dashboard {
             return new baqend_response_1.BaqendResponse(JSON.stringify({ query: this.paramQueryBuilder.getQuery() }), "application/json; charset=UTF-8");
         }
         if (url.pathname.startsWith("/query/execute")) {
-            const { postData } = request;
+            const postData = request.postData;
             const data = JSON.parse(postData);
             const response = await (0, safe_1.safe)(this.athenaClient.executeQuery(data.query));
             if (response.success === true) {
@@ -73,15 +73,15 @@ class Dashboard {
             return new baqend_response_1.BaqendResponse(JSON.stringify(this.customerConfig), "application/json; charset=UTF-8");
         }
         if (url.pathname.startsWith("/diff")) {
-            const { postData } = request;
+            const postData = request.postData;
             const data = JSON.parse(postData);
-            return this.requestDiffService.postDiff(data.url, data.params);
+            return await this.requestDiffService.postDiff(data.url, data.params);
         }
         if (url.pathname.startsWith("/cache/get")) {
             const response = [];
-            for (const [url, baqendResponse] of this.cache.getAll()) {
-                response.push({ response: baqendResponse, url });
-            }
+            Array.from(this.cache.getAll()).forEach(([url, baqendResponse]) => {
+                response.push({ url, response: baqendResponse });
+            });
             return new baqend_response_1.BaqendResponse(JSON.stringify(response), "application/json; charset=UTF-8");
         }
         return new baqend_response_1.BaqendResponse("Not implemented");

package/dist/services/onboarding/dashboard/request-diff-service.d.ts

@@ -4,8 +4,8 @@ export declare class RequestDiffService {
     private diffService;
     constructor(diffService: DiffService);
     postDiff(url: string, parametersString: string): Promise<BaqendResponse>;
-    private createUrlsForDiff;
     private diffLocal;
     private doOriginVsContentDiff;
     private fetchHtml;
+    private createUrlsForDiff;
 }

package/dist/services/onboarding/dashboard/request-diff-service.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestDiffService = void 0;
-const safe_1 = require("../../../helpers/safe");
 const baqend_response_1 = require("../browser/baqend-response");
+const safe_1 = require("../../../helpers/safe");
 class RequestDiffService {
     diffService;
     constructor(diffService) {
@@ -19,17 +19,34 @@ class RequestDiffService {
         const { urlWithParam, urlWithoutParam } = this.createUrlsForDiff(url, params);
         const result = await (0, safe_1.safe)(this.diffLocal(urlWithParam, urlWithoutParam));
         if (result.success === true) {
-            return new baqend_response_1.BaqendResponse(JSON.stringify({ isIdentical: result.data, status: "success" }), "application/json; charset=UTF-8");
+            return new baqend_response_1.BaqendResponse(JSON.stringify({ status: "success", isIdentical: result.data }), "application/json; charset=UTF-8");
         }
-        return new baqend_response_1.BaqendResponse(JSON.stringify({ error: result.error, status: "error" }), "application/json; charset=UTF-8", null, 500);
+        return new baqend_response_1.BaqendResponse(JSON.stringify({ status: "error", error: result.error }), "application/json; charset=UTF-8", null, 500);
+    }
+    async diffLocal(urlWithParam, urlWithoutParam) {
+        const htmlWithParam = await this.fetchHtml(urlWithParam);
+        const htmlWithoutParam = await this.fetchHtml(urlWithoutParam);
+        const paramsFilePath = await this.diffService.writeContentToTemporalFile("params", htmlWithParam);
+        const pureFilePath = await this.diffService.writeContentToTemporalFile("pure", htmlWithoutParam);
+        return await this.diffService.executeDiff(paramsFilePath, pureFilePath);
+    }
+    async doOriginVsContentDiff(url, content) {
+        const html = await this.fetchHtml(url);
+        const origin = await this.diffService.writeContentToTemporalFile("origin", html);
+        const local = await this.diffService.writeContentToTemporalFile("content", content);
+        return await this.diffService.executeDiff(local, origin);
+    }
+    async fetchHtml(url) {
+        const response = await fetch(url);
+        return await response.text();
     }
     createUrlsForDiff(urlWithParam, params) {
         const url = new URL(urlWithParam);
-        const { searchParams } = url;
+        const search_params = url.searchParams;
         for (const param of params) {
-            searchParams.delete(param);
+            search_params.delete(param);
         }
-        url.search = searchParams.toString();
+        url.search = search_params.toString();
         const urlWithoutParam = url.toString();
         console.log("With-----");
         console.log(urlWithParam);
@@ -42,22 +59,5 @@ class RequestDiffService {
             urlWithoutParam,
         };
     }
-    async diffLocal(urlWithParam, urlWithoutParam) {
-        const htmlWithParam = await this.fetchHtml(urlWithParam);
-        const htmlWithoutParam = await this.fetchHtml(urlWithoutParam);
-        const paramsFilePath = await this.diffService.writeContentToTemporalFile("params", htmlWithParam);
-        const pureFilePath = await this.diffService.writeContentToTemporalFile("pure", htmlWithoutParam);
-        return this.diffService.executeDiff(paramsFilePath, pureFilePath);
-    }
-    async doOriginVsContentDiff(url, content) {
-        const html = await this.fetchHtml(url);
-        const origin = await this.diffService.writeContentToTemporalFile("origin", html);
-        const local = await this.diffService.writeContentToTemporalFile("content", content);
-        return this.diffService.executeDiff(local, origin);
-    }
-    async fetchHtml(url) {
-        const response = await fetch(url);
-        return response.text();
-    }
 }
 exports.RequestDiffService = RequestDiffService;

package/dist/services/onboarding/fetch-event-handler.d.ts

@@ -1,19 +1,19 @@
-import { CDPSession, Target } from "puppeteer";
+import { FetchRequestPausedEventHandler } from "./onboarding-model";
 import { Protocol } from "puppeteer-core";
+import { CDPSession, Target } from "puppeteer";
 import { CliService } from "../cli";
-import ConfigApiService from "../config-api/config-api-service";
 import CustomerConfig from "../integration-api/struct/customer-config";
-import { FetchRequestPausedEventHandler } from "./onboarding-model";
+import ConfigApiService from "../config-api/config-api-service";
 export declare class FetchEventHandler {
     private browserFetchEvents;
     private customerConfig;
     private cli;
     private client?;
     constructor(browserFetchEvents: FetchRequestPausedEventHandler[], customerConfig: CustomerConfig, cli: CliService, client?: ConfigApiService);
-    getAuthPattern(): Protocol.Fetch.RequestPattern[];
     handleRequestFetchEvents(target: Target): Promise<void>;
-    sendDefaultAuthBehaviour(browserClient: CDPSession, requestId: string): Promise<void>;
     private canHandlePattern;
-    private onFetchAuthRequired;
     private onFetchRequestPaused;
+    getAuthPattern(): Protocol.Fetch.RequestPattern[];
+    private onFetchAuthRequired;
+    sendDefaultAuthBehaviour(browserClient: CDPSession, requestId: string): Promise<void>;
 }

package/dist/services/onboarding/fetch-event-handler.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FetchEventHandler = void 0;
 const tslib_1 = require("tslib");
 const puppeteer_core_1 = require("puppeteer-core");
-const safe_1 = require("../../helpers/safe");
+const abort_response_1 = require("./browser/abort-response");
 const cli_1 = require("../cli");
 const login_error_1 = tslib_1.__importDefault(require("../config-api/error/login-error"));
-const abort_response_1 = require("./browser/abort-response");
+const safe_1 = require("../../helpers/safe");
 class FetchEventHandler {
     browserFetchEvents;
     customerConfig;
@@ -18,24 +18,11 @@ class FetchEventHandler {
         this.cli = cli;
         this.client = client;
     }
-    getAuthPattern() {
-        const result = [];
-        for (const origin of this.customerConfig.origins) {
-            const pattern = [
-                {
-                    requestStage: "Request",
-                    urlPattern: `${origin}*`,
-                },
-            ];
-            result.push(...pattern);
-        }
-        return result;
-    }
     async handleRequestFetchEvents(target) {
         const browserClient = await target.createCDPSession();
         await browserClient.send("Fetch.enable", {
             handleAuthRequests: true,
-            // see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#type-RequestPattern
+            //see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#type-RequestPattern
             patterns: [
                 ...this.browserFetchEvents.flatMap((handler) => {
                     return handler.patterns;
@@ -64,14 +51,6 @@ class FetchEventHandler {
             this.cli.writeError(JSON.stringify(response.errorObj));
         });
     }
-    async sendDefaultAuthBehaviour(browserClient, requestId) {
-        await browserClient.send("Fetch.continueWithAuth", {
-            authChallengeResponse: {
-                response: "Default",
-            },
-            requestId,
-        });
-    }
     canHandlePattern(fetchEventHandler, url, resourceType, requestStage) {
         return fetchEventHandler.patterns.some((pattern) => {
             if (!new RegExp(pattern.urlPattern).test(url)) {
@@ -83,6 +62,48 @@ class FetchEventHandler {
             return !pattern.resourceType || pattern.resourceType === resourceType;
         });
     }
+    async onFetchRequestPaused(event, browserClient) {
+        const requestId = event.requestId;
+        for (const fetchEvent of this.browserFetchEvents) {
+            // check if current request could be handled
+            if (!this.canHandlePattern(fetchEvent, event.request.url, event.resourceType, event.responseHeaders ? "Response" : "Request")) {
+                continue;
+            }
+            const response = await fetchEvent.handle(event, browserClient);
+            if (!response) {
+                continue;
+            }
+            if (response instanceof abort_response_1.AbortResponse) {
+                await browserClient.send("Fetch.failRequest", {
+                    requestId: requestId,
+                    errorReason: response.errorReason,
+                });
+                return;
+            }
+            await browserClient.send("Fetch.fulfillRequest", {
+                ...response,
+                requestId,
+            });
+            return;
+        }
+        //see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#method-continueRequest
+        await browserClient.send("Fetch.continueRequest", {
+            requestId: requestId,
+        });
+    }
+    getAuthPattern() {
+        const result = [];
+        for (const origin of this.customerConfig.origins) {
+            const pattern = [
+                {
+                    urlPattern: `${origin}*`,
+                    requestStage: "Request",
+                },
+            ];
+            result.push(...pattern);
+        }
+        return result;
+    }
     async onFetchAuthRequired(event, browserClient) {
         this.cli.writeWarning(`auth requested for ${event.request.url}`);
         if (!this.customerConfig.origins.some((origin) => {
@@ -101,12 +122,12 @@ class FetchEventHandler {
                 if (auth.uri.includes(authUrlOrigin) &&
                     auth.type === event.authChallenge.scheme) {
                     await browserClient.send("Fetch.continueWithAuth", {
+                        requestId: event.requestId,
                         authChallengeResponse: {
-                            password: auth.password,
                             response: "ProvideCredentials",
                             username: auth.user,
+                            password: auth.password,
                         },
-                        requestId: event.requestId,
                     });
                     this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
                     this.cli.writeSuccess(`auth provided for ${event.request.url}`);
@@ -132,33 +153,12 @@ class FetchEventHandler {
         this.cli.writeError(`error providing auth: ${JSON.stringify(serverConfigResponse.errorObj)}`);
         await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
     }
-    async onFetchRequestPaused(event, browserClient) {
-        const { request: { url: requestUrl }, requestId, resourceType, responseHeaders, } = event;
-        for (const fetchEvent of this.browserFetchEvents) {
-            // check if current request could be handled
-            if (!this.canHandlePattern(fetchEvent, requestUrl, resourceType, responseHeaders ? "Response" : "Request")) {
-                continue;
-            }
-            const response = await fetchEvent.handle(event, browserClient);
-            if (!response) {
-                continue;
-            }
-            if (response instanceof abort_response_1.AbortResponse) {
-                await browserClient.send("Fetch.failRequest", {
-                    errorReason: response.errorReason,
-                    requestId,
-                });
-                return;
-            }
-            await browserClient.send("Fetch.fulfillRequest", {
-                ...response,
-                requestId,
-            });
-            return;
-        }
-        // see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#method-continueRequest
-        await browserClient.send("Fetch.continueRequest", {
+    async sendDefaultAuthBehaviour(browserClient, requestId) {
+        await browserClient.send("Fetch.continueWithAuth", {
             requestId,
+            authChallengeResponse: {
+                response: "Default",
+            },
         });
     }
 }