@speedkit/cli 2.10.0 → 2.11.0

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 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"));
+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");
 class Dashboard {
     customerConfig;
     paramQueryBuilder;
@@ -22,57 +22,69 @@ class Dashboard {
     }
     async getResponse(request) {
         const url = new URL(request.url);
-        if (url.pathname === '/') {
-            const filePath = path_1.default.join(__dirname, './frontend-dist', 'index.html');
-            const content = (0, fs_1.readFileSync)(filePath, { encoding: 'utf-8' });
+        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" });
             return new baqend_response_1.BaqendResponse(content);
         }
-        if (url.pathname.startsWith('/assets/')) {
-            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';
+        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" });
+            let contentType = "application/javascript; charset=UTF-8";
+            if (url.pathname.includes(".css")) {
+                contentType = "text/css";
             }
             return new baqend_response_1.BaqendResponse(content, contentType);
         }
-        if (url.pathname.startsWith('/query/create')) {
-            return new baqend_response_1.BaqendResponse(JSON.stringify({ query: this.paramQueryBuilder.getQuery() }), 'application/json; charset=UTF-8');
+        if (url.pathname.startsWith("/query/create")) {
+            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.postData;
+        if (url.pathname.startsWith("/query/execute")) {
+            const { postData } = request;
             const data = JSON.parse(postData);
             const response = await (0, safe_1.safe)(this.athenaClient.executeQuery(data.query));
             if (response.success === true) {
-                return new baqend_response_1.BaqendResponse(JSON.stringify(response.data), 'application/json; charset=UTF-8');
+                return new baqend_response_1.BaqendResponse(JSON.stringify(response.data), "application/json; charset=UTF-8");
             }
-            return new baqend_response_1.BaqendResponse(response.error, null, [{ name: 'x-error', value: response.error }], 500);
+            return new baqend_response_1.BaqendResponse(response.error, null, [{ name: "x-error", value: response.error }], 500);
         }
-        if (url.pathname.startsWith('/query/download')) {
+        if (url.pathname.startsWith("/query/download")) {
             const result = this.athenaClient.getLastQueryResult();
             result.shift();
-            const csv = json2csv_1.default.parse(result, { fields: ['params', 'potentialGain', 'cachedUrls', 'PIs', 'example1', 'example2', 'example3'] });
-            return new baqend_response_1.BaqendResponse(csv, 'application/csv', [{
-                    name: 'Content-disposition',
-                    value: `attachment; filename=parameter-${this.customerConfig.app}.csv`
-                }]);
+            const csv = json2csv_1.default.parse(result, {
+                fields: [
+                    "params",
+                    "potentialGain",
+                    "cachedUrls",
+                    "PIs",
+                    "example1",
+                    "example2",
+                    "example3",
+                ],
+            });
+            return new baqend_response_1.BaqendResponse(csv, "application/csv", [
+                {
+                    name: "Content-disposition",
+                    value: `attachment; filename=parameter-${this.customerConfig.app}.csv`,
+                },
+            ]);
         }
-        if (url.pathname.startsWith('/api/config')) {
-            return new baqend_response_1.BaqendResponse(JSON.stringify(this.customerConfig), 'application/json; charset=UTF-8');
+        if (url.pathname.startsWith("/api/config")) {
+            return new baqend_response_1.BaqendResponse(JSON.stringify(this.customerConfig), "application/json; charset=UTF-8");
         }
-        if (url.pathname.startsWith('/diff')) {
-            const postData = request.postData;
+        if (url.pathname.startsWith("/diff")) {
+            const { postData } = request;
             const data = JSON.parse(postData);
-            return await this.requestDiffService.postDiff(data.url, data.params);
+            return this.requestDiffService.postDiff(data.url, data.params);
         }
-        if (url.pathname.startsWith('/cache/get')) {
+        if (url.pathname.startsWith("/cache/get")) {
             const response = [];
-            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');
+            for (const [url, baqendResponse] of this.cache.getAll()) {
+                response.push({ response: baqendResponse, url });
+            }
+            return new baqend_response_1.BaqendResponse(JSON.stringify(response), "application/json; charset=UTF-8");
         }
-        return new baqend_response_1.BaqendResponse('Not implemented');
+        return new baqend_response_1.BaqendResponse("Not implemented");
     }
 }
 exports.Dashboard = Dashboard;

package/dist/services/onboarding/dashboard/param-query-builder.d.ts

@@ -1,5 +1,5 @@
-import { ConfigFileInterface } from '../../integration-api/integration-api-model';
-import CustomerConfig from '../../integration-api/struct/customer-config';
+import { ConfigFileInterface } from "../../integration-api/integration-api-model";
+import CustomerConfig from "../../integration-api/struct/customer-config";
 export declare class ParamQueryBuilder {
     private customerConfig;
     private speedKitConfigFile;

package/dist/services/onboarding/dashboard/param-query-builder.js

@@ -12,8 +12,8 @@ class ParamQueryBuilder {
     }
     buildParameterQuery(app, parameterFilter, whitelistedFilter, blacklistedFilter, parameterReplaceFilter) {
         const nowMinusOneMonth = new Date(new Date().setMonth(new Date().getMonth() - 1, new Date().getDate()));
-        const monthString = `${nowMinusOneMonth.getMonth() + 1 < 10 ? '0' : ''}${nowMinusOneMonth.getMonth() + 1}`;
-        const dateString = `${nowMinusOneMonth.getDate() < 10 ? '0' : ''}${nowMinusOneMonth.getDate()}`;
+        const monthString = `${nowMinusOneMonth.getMonth() + 1 < 10 ? "0" : ""}${nowMinusOneMonth.getMonth() + 1}`;
+        const dateString = `${nowMinusOneMonth.getDate() < 10 ? "0" : ""}${nowMinusOneMonth.getDate()}`;
         const date = `${nowMinusOneMonth.getFullYear()}-${monthString}-${dateString}`;
         return `
 with urlWithParams as (

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,59 +1,63 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestDiffService = void 0;
-const baqend_response_1 = require("../browser/baqend-response");
 const safe_1 = require("../../../helpers/safe");
+const baqend_response_1 = require("../browser/baqend-response");
 class RequestDiffService {
     diffService;
     constructor(diffService) {
         this.diffService = diffService;
     }
     async postDiff(url, parametersString) {
-        const params = parametersString.replace('[', '').replace(']', '').split((',')).map(param => {
+        const params = parametersString
+            .replace("[", "")
+            .replace("]", "")
+            .split(",")
+            .map((param) => {
             return param.trim();
         });
         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({ status: 'success', isIdentical: result.data }), 'application/json; charset=UTF-8');
+            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: '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();
+        return new baqend_response_1.BaqendResponse(JSON.stringify({ error: result.error, status: "error" }), "application/json; charset=UTF-8", null, 500);
     }
     createUrlsForDiff(urlWithParam, params) {
         const url = new URL(urlWithParam);
-        const search_params = url.searchParams;
+        const { searchParams } = url;
         for (const param of params) {
-            search_params.delete(param);
+            searchParams.delete(param);
         }
-        url.search = search_params.toString();
+        url.search = searchParams.toString();
         const urlWithoutParam = url.toString();
-        console.log('With-----');
+        console.log("With-----");
         console.log(urlWithParam);
-        console.log('Without-----');
+        console.log("Without-----");
         console.log(urlWithoutParam);
-        console.log('-----');
+        console.log("-----");
         // TODO: Insert the content
         return {
             urlWithParam,
-            urlWithoutParam
+            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 { FetchRequestPausedEventHandler } from "./onboarding-model";
-import { Protocol } from "puppeteer-core";
 import { CDPSession, Target } from "puppeteer";
+import { Protocol } from "puppeteer-core";
 import { CliService } from "../cli";
-import CustomerConfig from "../integration-api/struct/customer-config";
 import ConfigApiService from "../config-api/config-api-service";
+import CustomerConfig from "../integration-api/struct/customer-config";
+import { FetchRequestPausedEventHandler } from "./onboarding-model";
 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 onFetchRequestPaused;
-    getAuthPattern(): Protocol.Fetch.RequestPattern[];
     private onFetchAuthRequired;
-    sendDefaultAuthBehaviour(browserClient: CDPSession, requestId: string): Promise<void>;
+    private onFetchRequestPaused;
 }

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;
 }