@speedkit/cli 2.9.0 → 2.11.0

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 abort_response_1 = require("./browser/abort-response");
+const safe_1 = require("../../helpers/safe");
 const cli_1 = require("../cli");
 const login_error_1 = tslib_1.__importDefault(require("../config-api/error/login-error"));
-const safe_1 = require("../../helpers/safe");
+const abort_response_1 = require("./browser/abort-response");
 class FetchEventHandler {
     browserFetchEvents;
     customerConfig;
@@ -18,23 +18,39 @@ 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', {
+        await browserClient.send("Fetch.enable", {
             handleAuthRequests: true,
-            //see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#type-RequestPattern
-            patterns: this.browserFetchEvents.flatMap(handler => {
-                return handler.patterns;
-            }).concat(this.getAuthPattern()),
+            // see: https://chromedevtools.github.io/devtools-protocol/tot/Fetch#type-RequestPattern
+            patterns: [
+                ...this.browserFetchEvents.flatMap((handler) => {
+                    return handler.patterns;
+                }),
+                ...this.getAuthPattern(),
+            ],
         });
-        browserClient.on('Fetch.authRequired', async (event) => {
+        browserClient.on("Fetch.authRequired", async (event) => {
             const response = await (0, safe_1.safe)(this.onFetchAuthRequired(event, browserClient));
             if (response.success === true) {
                 return response.data;
             }
             this.cli.writeError(response.error);
         });
-        browserClient.on('Fetch.requestPaused', async (event) => {
+        browserClient.on("Fetch.requestPaused", async (event) => {
             const response = await (0, safe_1.safe)(this.onFetchRequestPaused(event, browserClient));
             if (response.success === true) {
                 return;
@@ -48,9 +64,17 @@ 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))) {
+        return fetchEventHandler.patterns.some((pattern) => {
+            if (!new RegExp(pattern.urlPattern).test(url)) {
                 return false;
             }
             if (pattern.requestStage !== requestStage) {
@@ -59,65 +83,30 @@ 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() {
-        let 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) => { return event.request.url.includes(origin); }) || !this.client) {
+        if (!this.customerConfig.origins.some((origin) => {
+            return event.request.url.includes(origin);
+        }) ||
+            !this.client) {
             this.cli.writeWarning(`incorrect origin for auth request: -> ${this.customerConfig.origins.join("|")}`);
             return { response: "Default" };
         }
-        this.cli.startAction('wait for credentials from server-config');
+        this.cli.startAction("wait for credentials from server-config");
         const serverConfigResponse = await (0, safe_1.safe)(this.client.getServerConfig());
         if (serverConfigResponse.success === true) {
             const config = JSON.parse(serverConfigResponse.data);
             const authUrlOrigin = new URL(event.request.url).origin;
             for (const auth of config.speedKit.authentications) {
-                if (auth.uri.includes(authUrlOrigin) && auth.type === event.authChallenge.scheme) {
-                    await browserClient.send('Fetch.continueWithAuth', {
-                        requestId: event.requestId,
+                if (auth.uri.includes(authUrlOrigin) &&
+                    auth.type === event.authChallenge.scheme) {
+                    await browserClient.send("Fetch.continueWithAuth", {
                         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}`);
@@ -143,12 +132,33 @@ class FetchEventHandler {
         this.cli.writeError(`error providing auth: ${JSON.stringify(serverConfigResponse.errorObj)}`);
         await this.sendDefaultAuthBehaviour(browserClient, event.requestId);
     }
-    async sendDefaultAuthBehaviour(browserClient, requestId) {
-        await browserClient.send('Fetch.continueWithAuth', {
-            requestId,
-            authChallengeResponse: {
-                response: "Default"
+    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", {
+            requestId,
         });
     }
 }

package/dist/services/onboarding/fetch-events/customer-domain-document-response.d.ts

@@ -1,8 +1,8 @@
-import Protocol from 'devtools-protocol';
-import { FetchRequestPausedEventHandler } from "../onboarding-model";
-import CustomerConfig from "../../integration-api/struct/customer-config";
+import Protocol from "devtools-protocol";
 import { CDPSession } from "puppeteer";
 import { ConfigFileInterface } from "../../integration-api/integration-api-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
 /**
  * Intercepts any request to the customersOrigin and equivalent requests to baqendAssetApi
  * @implements {FetchRequestPausedEventHandler}
@@ -11,14 +11,14 @@ export declare class CustomerDomainDocumentResponse implements FetchRequestPause
     private customerConfig;
     private configDynamicBlock;
     private configDynamicStyles;
-    get patterns(): Protocol.Fetch.RequestPattern[];
     constructor(customerConfig: CustomerConfig, configDynamicBlock: ConfigFileInterface, configDynamicStyles: ConfigFileInterface);
+    get patterns(): Protocol.Fetch.RequestPattern[];
     handle(event: Protocol.Fetch.RequestPausedEvent, client: CDPSession): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | void>;
-    private isValidHtmlContent;
-    private isValidResponse;
-    private isHtmlContentHeader;
     private getHtmlContent;
+    private isHtmlContentHeader;
     private isSpeedKitResponse;
-    private rewriteInstallResource;
+    private isValidHtmlContent;
+    private isValidResponse;
     private rewriteHtmlToLocalConfig;
+    private rewriteInstallResource;
 }

package/dist/services/onboarding/fetch-events/customer-domain-document-response.js

@@ -10,45 +10,45 @@ class CustomerDomainDocumentResponse {
     customerConfig;
     configDynamicBlock;
     configDynamicStyles;
+    constructor(customerConfig, configDynamicBlock, configDynamicStyles) {
+        this.customerConfig = customerConfig;
+        this.configDynamicBlock = configDynamicBlock;
+        this.configDynamicStyles = configDynamicStyles;
+    }
     get patterns() {
-        let result = [];
+        const result = [];
         for (const origin of this.customerConfig.origins) {
             const pattern = [
                 {
+                    requestStage: "Response",
+                    resourceType: "Document",
                     urlPattern: `${origin}*`,
-                    resourceType: 'Document',
-                    requestStage: "Response"
                 },
                 {
+                    requestStage: "Response",
+                    resourceType: "Fetch",
                     urlPattern: `${origin}*`,
-                    resourceType: 'Fetch',
-                    requestStage: "Response"
                 },
                 {
+                    requestStage: "Response",
+                    resourceType: "XHR",
                     urlPattern: `${origin}*`,
-                    resourceType: 'XHR',
-                    requestStage: "Response"
                 },
                 {
+                    requestStage: "Response",
+                    resourceType: "Fetch",
                     urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
-                    resourceType: 'Fetch',
-                    requestStage: "Response"
                 },
                 {
-                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                    requestStage: "Response",
                     resourceType: "XHR",
-                    requestStage: "Response"
-                }
+                    urlPattern: `https://${this.customerConfig.appDomain}/v1/asset/${origin}*`,
+                },
             ];
             result.push(...pattern);
         }
         return result;
     }
-    constructor(customerConfig, configDynamicBlock, configDynamicStyles) {
-        this.customerConfig = customerConfig;
-        this.configDynamicBlock = configDynamicBlock;
-        this.configDynamicStyles = configDynamicStyles;
-    }
     async handle(event, client) {
         if (!this.isValidResponse(event)) {
             return;
@@ -68,51 +68,53 @@ class CustomerDomainDocumentResponse {
         }
         return new origin_response_1.OriginResponse(text, event.responseHeaders, event.responseStatusCode);
     }
-    isValidHtmlContent(text) {
-        return text.includes('<html');
-    }
-    isValidResponse(event) {
-        return event.responseHeaders &&
-            event.responseStatusCode &&
-            event.responseStatusCode > 199 &&
-            event.responseStatusCode < 300;
-    }
-    isHtmlContentHeader(responseHeaders) {
-        const contentType = responseHeaders.filter(headerRecord => {
-            return headerRecord.name.toLowerCase() === 'content-type';
-        })?.[0]?.['value'];
-        return contentType && contentType.includes('text/html');
-    }
     async getHtmlContent(client, event) {
-        const contentType = event.responseHeaders.filter(headerRecord => {
-            return headerRecord.name.toLowerCase() === 'content-type';
-        })?.[0]?.['value'] || '';
-        const charset = contentType.split('charset=')?.[1];
-        const { body, base64Encoded } = await client.send('Fetch.getResponseBody', { requestId: event.requestId });
+        const contentType = event.responseHeaders.find((headerRecord) => {
+            return headerRecord.name.toLowerCase() === "content-type";
+        })?.value || "";
+        const charset = contentType.split("charset=")?.[1];
+        const { base64Encoded, body } = await client.send("Fetch.getResponseBody", {
+            requestId: event.requestId,
+        });
         if (base64Encoded) {
             // todo get encodingHeader for target encoding
-            return Buffer.from(body, 'base64').toString(charset || 'utf-8');
+            return Buffer.from(body, "base64").toString(charset || "utf8");
         }
         return body;
     }
+    isHtmlContentHeader(responseHeaders) {
+        const contentType = responseHeaders.find((headerRecord) => {
+            return headerRecord.name.toLowerCase() === "content-type";
+        })?.value;
+        return contentType && contentType.includes("text/html");
+    }
     isSpeedKitResponse(text) {
-        return text.includes('speed-kit-dynamic');
+        return text.includes("speed-kit-dynamic");
     }
-    rewriteInstallResource(text) {
-        text = text.replace(/<script(?:.(?!<\/script>))*app\.baqend\.com\/v1\/speedkit\/install.js(?:.|(?!<\/script>))*<\/script>/, '');
-        return text.replace(/<\s*head\b[^>]*>/, (head) => {
-            return `${head}\n<script src="${this.customerConfig.installPath}" ${this.customerConfig.installParams}></script>`;
-        });
+    isValidHtmlContent(text) {
+        return text.includes("<html");
+    }
+    isValidResponse(event) {
+        return (event.responseHeaders &&
+            event.responseStatusCode &&
+            event.responseStatusCode > 199 &&
+            event.responseStatusCode < 300);
     }
     rewriteHtmlToLocalConfig(html) {
-        const DF_CONFIG_PATTERN = /(<script[^>]* id="speed-kit-df-config"[^>]*>)([\s\S]*?)(<\/script>)/g;
-        const DF_STYLES_PATTERN = /(<style[^>]* id="speed-kit-df-styles"[^>]*>)(?:(?!<\/style>)[\s\S])*(<\/style>)/g;
-        html = html.replace(DF_CONFIG_PATTERN, (_, tag, body, end) => {
-            const injectedConfig = body.match(/window\.dynamicBlockConfig\.appName\s=.*$/s) ?? [''];
+        const DF_CONFIG_PATTERN = /(<script[^>]* id="speed-kit-df-config"[^>]*>)([\S\s]*?)(<\/script>)/g;
+        const DF_STYLES_PATTERN = /(<style[^>]* id="speed-kit-df-styles"[^>]*>)(?:(?!<\/style>)[\S\s])*(<\/style>)/g;
+        html = html.replaceAll(DF_CONFIG_PATTERN, (_, tag, body, end) => {
+            const injectedConfig = body.match(/window\.dynamicBlockConfig\.appName\s=.*$/s) ?? [""];
             return `${tag}${this.configDynamicBlock.getContent()}${injectedConfig[0]}${end}`;
         });
-        html = html.replace(DF_STYLES_PATTERN, (_, tag, end) => `${tag}${this.configDynamicStyles.getContent()}${end}`);
+        html = html.replaceAll(DF_STYLES_PATTERN, (_, tag, end) => `${tag}${this.configDynamicStyles.getContent()}${end}`);
         return html;
     }
+    rewriteInstallResource(text) {
+        text = text.replace(/<script(?:.(?!<\/script>))*app\.baqend\.com\/v1\/speedkit\/install.js(?:.|(?!<\/script>))*<\/script>/, "");
+        return text.replace(/<\s*head\b[^>]*>/, (head) => {
+            return `${head}\n<script src="${this.customerConfig.installPath}" ${this.customerConfig.installParams}></script>`;
+        });
+    }
 }
 exports.CustomerDomainDocumentResponse = CustomerDomainDocumentResponse;

package/dist/services/onboarding/fetch-events/customer-service-worker-js.d.ts

@@ -1,6 +1,6 @@
-import Protocol from 'devtools-protocol';
-import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import Protocol from "devtools-protocol";
 import CustomerConfig from "../../integration-api/struct/customer-config";
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
 /**
  * Intercepts request to /wrapper-sw.js
  *
@@ -8,7 +8,7 @@ import CustomerConfig from "../../integration-api/struct/customer-config";
  */
 export declare class CustomerServiceWorkerJs implements FetchRequestPausedEventHandler {
     private customerConfig;
-    get patterns(): Protocol.Fetch.RequestPattern[];
     constructor(customerConfig: CustomerConfig);
+    get patterns(): Protocol.Fetch.RequestPattern[];
     handle(): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
 }

package/dist/services/onboarding/fetch-events/customer-service-worker-js.js

@@ -9,22 +9,22 @@ const baqend_response_1 = require("../browser/baqend-response");
  */
 class CustomerServiceWorkerJs {
     customerConfig;
+    constructor(customerConfig) {
+        this.customerConfig = customerConfig;
+    }
     get patterns() {
-        let result = [];
+        const result = [];
         for (const origin of this.customerConfig.origins) {
             result.push({
+                requestStage: "Request",
                 urlPattern: `${origin}${this.customerConfig.swPath}*`,
-                requestStage: "Request"
             });
         }
         return result;
     }
-    constructor(customerConfig) {
-        this.customerConfig = customerConfig;
-    }
     async handle() {
         const wrapperSwCode = `importScripts(\`https://${this.customerConfig.appDomain}/v1/speedkit/sw.js\${location.search}\`); // skonboarding`;
-        return new baqend_response_1.BaqendResponse(wrapperSwCode, 'text/javascript; charset=utf-8');
+        return new baqend_response_1.BaqendResponse(wrapperSwCode, "text/javascript; charset=utf-8");
     }
 }
 exports.CustomerServiceWorkerJs = CustomerServiceWorkerJs;

package/dist/services/onboarding/fetch-events/dashboard-request.d.ts

@@ -1,6 +1,6 @@
-import Protocol from 'devtools-protocol';
-import { FetchRequestPausedEventHandler } from "../onboarding-model";
+import Protocol from "devtools-protocol";
 import { Dashboard } from "../dashboard";
+import { FetchRequestPausedEventHandler } from "../onboarding-model";
 /**
  * The DashboardRequest class represents a request handler for the dashboard.
  * Handle all the requests on the secondTab(http://skonboarding.local)

package/dist/services/onboarding/fetch-events/dashboard-request.js

@@ -11,19 +11,19 @@ class DashboardRequest {
     dashboard;
     patterns = [
         {
+            requestStage: "Request",
             urlPattern: `http://skonboarding.local*`,
-            requestStage: "Request"
         },
         {
+            requestStage: "Request",
             urlPattern: `https://skonboarding.local*`,
-            requestStage: "Request"
         },
     ];
     constructor(dashboard) {
         this.dashboard = dashboard;
     }
     async handle(event) {
-        return await this.dashboard.getResponse(event.request);
+        return this.dashboard.getResponse(event.request);
     }
 }
 exports.DashboardRequest = DashboardRequest;

package/dist/services/onboarding/fetch-events/speed-kit-asset-request.d.ts

@@ -1,10 +1,10 @@
 import Protocol from "devtools-protocol";
-import { FetchRequestPausedEventHandler, SpeedKitServerConfig } from "../onboarding-model";
-import CustomerConfig from "../../integration-api/struct/customer-config";
+import { CliService } from "../../cli";
 import { DocumentHandlerServer } from "../../document-handler-runtime/document-handler-server";
+import CustomerConfig from "../../integration-api/struct/customer-config";
 import { AbortResponse } from "../browser/abort-response";
+import { FetchRequestPausedEventHandler, SpeedKitServerConfig } from "../onboarding-model";
 import { Cache } from "../request-cache/cache";
-import { CliService } from "../../cli";
 /**
  * Handles fetch requests for Speed Kit assets and returns customized responses.
  */
@@ -14,15 +14,15 @@ export declare class SpeedKitAssetRequest implements FetchRequestPausedEventHand
     private cache;
     private cli;
     private speedKitServerConfig?;
-    get patterns(): Protocol.Fetch.RequestPattern[];
     constructor(customerConfig: CustomerConfig, documentHandler: DocumentHandlerServer, cache: Cache, cli: CliService, speedKitServerConfig?: SpeedKitServerConfig);
-    handle(event: Protocol.Fetch.RequestPausedEvent): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | AbortResponse>;
-    private getCachedResponse;
+    get patterns(): Protocol.Fetch.RequestPattern[];
+    handle(event: Protocol.Fetch.RequestPausedEvent): Promise<AbortResponse | Partial<Protocol.Fetch.FulfillRequestRequest>>;
     private buildCustomHeaders;
     private createResponseFromLocalDocumentHandler;
     private getAssetUrl;
+    private getCachedResponse;
     private isHtmlContentHeader;
     private isValidHtmlContent;
-    private rewriteInstallResource;
     private prepareOriginRequest;
+    private rewriteInstallResource;
 }