@speedkit/cli 2.9.0 → 2.11.0

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 = {
-    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/',
+    "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/",
 };
 class SpeedKitInstallContext {
     customerConfig;
@@ -22,57 +22,69 @@ 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() {
+        return this.bundler.bundle({
+            basePaths: {},
+            entryPoints: {
+                "dynamicFetcher.js": this.files
+                    .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
+                    .getContent(),
+            },
+            logLevel: "verbose",
+            minify: false,
+            platform: "browser",
+            target: "es6",
+        });
+    }
     async getSpeedKitInstallJs() {
         const configJs = this.skTemplate.render({
             config: this.getConfigSpeedKit(),
+            df: this.files
+                .getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER)
+                .getContent(),
+            domain: this.customerConfig.domain,
             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(),
+            installPath: this.customerConfig.installPath,
         });
         return this.bundler.bundle({
             basePaths: IMPORT_PATHS,
-            entryPoints: {
-                '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: 'error',
             define: {
                 APP: JSON.stringify(this.customerConfig.app),
             },
+            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)
+                    .getContent(),
+            },
+            logLevel: "error",
         });
     }
     getConfigSpeedKit() {
-        const configString = this.files.getByName(files_1.INTEGRATION_FILES.CONFIG.SPEED_KIT).getContent();
+        const configString = this.files
+            .getByName(files_1.INTEGRATION_FILES.CONFIG.SPEED_KIT)
+            .getContent();
         if (!this.isLocalRuntime) {
             return configString;
         }
-        if (configString.includes('delayRacedOrigin')) {
-            return configString.replace(/delayRacedOrigin:[^,|\d](\d*)[^,]*,/, (config, value) => {
-                return config.replace(value, '100');
+        if (configString.includes("delayRacedOrigin")) {
+            return configString.replace(/delayRacedOrigin:[^\d,|](\d*)[^,]*,/, (config, value) => {
+                return config.replace(value, "100");
             });
         }
         return configString.replace(/window\.speedKit[^{]*=[^{]*{/, (configOpenTag) => {
             return configOpenTag + `\n delayRacedOrigin: 100,\n`;
         });
     }
-    /**
-     * 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: {},
-            entryPoints: { "dynamicFetcher.js": this.files.getByName(files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER).getContent() },
-            target: "es6",
-            logLevel: 'verbose',
-            minify: false,
-            platform: "browser",
-        });
-    }
 }
 exports.SpeedKitInstallContext = SpeedKitInstallContext;

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

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

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 util_1 = tslib_1.__importDefault(require("util"));
-const cli_1 = require("../../cli");
+const node_util_1 = tslib_1.__importDefault(require("node:util"));
 const safe_1 = require("../../../helpers/safe");
-const sleep = util_1.default.promisify(setTimeout);
+const cli_1 = require("../../cli");
+const sleep = node_util_1.default.promisify(setTimeout);
 class AthenaService {
     athena;
     cli;
@@ -18,13 +18,13 @@ class AthenaService {
         if (this.lastQueryResult.length > 0) {
             return this.lastQueryResult;
         }
-        let params = {
-            QueryString: queryString,
+        const params = {
             QueryExecutionContext: {
-                Database: "rum.pi"
+                Database: "rum.pi",
             },
+            QueryString: queryString,
         };
-        this.cli.startAction('[athena-query]: fetch result');
+        this.cli.startAction("[athena-query]: fetch result");
         const result = await (0, safe_1.safe)(this.fetchResult(params));
         if (result.success === true) {
             this.lastQueryResult = result.data;
@@ -34,37 +34,42 @@ class AthenaService {
         this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
         this.cli.writeError(result.error);
     }
+    getLastQueryResult() {
+        return this.lastQueryResult;
+    }
     async fetchResult(params) {
-        let request = await this.athena.startQueryExecution(params);
-        let queryStatus = await this.athena.getQueryExecution({ QueryExecutionId: request.QueryExecutionId });
-        while (queryStatus.QueryExecution.Status.State === "QUEUED" || queryStatus.QueryExecution.Status.State === "RUNNING") {
+        const request = await this.athena.startQueryExecution(params);
+        let queryStatus = await this.athena.getQueryExecution({
+            QueryExecutionId: request.QueryExecutionId,
+        });
+        while (queryStatus.QueryExecution.Status.State === "QUEUED" ||
+            queryStatus.QueryExecution.Status.State === "RUNNING") {
             await sleep(2000);
-            queryStatus = await this.athena.getQueryExecution({ QueryExecutionId: request.QueryExecutionId });
+            queryStatus = await this.athena.getQueryExecution({
+                QueryExecutionId: request.QueryExecutionId,
+            });
         }
         const queryParams = {
             QueryExecutionId: request.QueryExecutionId,
             // MaxResults: 10
         };
-        let queryResult = await this.athena.getQueryResults(queryParams);
+        const queryResult = await this.athena.getQueryResults(queryParams);
         // transform result and return it
-        let dataArray = [];
-        queryResult.ResultSet.Rows.forEach(recordRow => {
-            let object = {
-                params: recordRow.Data[0].VarCharValue,
-                potentialGain: recordRow.Data[1].VarCharValue,
-                cachedUrls: recordRow.Data[2].VarCharValue,
+        const dataArray = [];
+        for (const recordRow of queryResult.ResultSet.Rows) {
+            const object = {
                 PIs: recordRow.Data[3].VarCharValue,
+                cachedUrls: recordRow.Data[2].VarCharValue,
                 example1: recordRow.Data[4].VarCharValue,
                 example2: recordRow.Data[5].VarCharValue,
-                example3: recordRow.Data[6].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 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;
 }