@speedkit/cli 2.4.1

package/dist/services/onboarding/fetch-events/speed-kit-install-html.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeedKitInstallHtml = void 0;
+const baqend_response_1 = require("../browser/baqend-response");
+/**
+ * Represents a class that handles the installation of Speed Kit HTML.
+ */
+class SpeedKitInstallHtml {
+    customerConfig;
+    browserContext;
+    speedKitInstallHtmlTemplate;
+    get patterns() {
+        let result = [];
+        for (const origin of this.customerConfig.origins) {
+            const pattern = [
+                {
+                    urlPattern: `${origin}${this.customerConfig.scope}speed-kit-install.html*`,
+                    resourceType: 'Document',
+                    requestStage: "Request"
+                },
+                {
+                    urlPattern: `${origin}${this.customerConfig.scope}speed-kit-install.html*`,
+                    resourceType: 'XHR',
+                    requestStage: "Request"
+                },
+                {
+                    urlPattern: `${origin}${this.customerConfig.scope}speed-kit-install.html*`,
+                    resourceType: 'Fetch',
+                    requestStage: "Request"
+                }
+            ];
+            result.push(...pattern);
+        }
+        return result;
+    }
+    constructor(customerConfig, browserContext, speedKitInstallHtmlTemplate) {
+        this.customerConfig = customerConfig;
+        this.browserContext = browserContext;
+        this.speedKitInstallHtmlTemplate = speedKitInstallHtmlTemplate;
+    }
+    async handle() {
+        return new baqend_response_1.BaqendResponse(this.speedKitInstallHtmlTemplate.render({
+            installPath: this.customerConfig.installPath,
+            domain: this.browserContext.domain,
+            swPath: this.customerConfig.swPath,
+        }));
+    }
+}
+exports.SpeedKitInstallHtml = SpeedKitInstallHtml;

package/dist/services/onboarding/fetch-events/speed-kit-install-js.d.ts

@@ -0,0 +1,22 @@
+import Protocol from 'devtools-protocol';
+import { CDPSession } from 'puppeteer';
+import CustomerConfig from '../../integration-api/struct/customer-config';
+import { VirtualFile } from '../../integration-api/struct/virtual-file';
+import { AbortResponse } from '../browser/abort-response';
+import { FetchRequestPausedEventHandler } from '../onboarding-model';
+/**
+ * Intercepts the response for speedkit-install.js
+ * Returns a custom build install.js from local-files
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+export declare class SpeedKitInstallJs implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private installResource;
+    readonly patterns: Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, installResource: VirtualFile);
+    handle(event: Protocol.Fetch.RequestPausedEvent, client: CDPSession): Promise<AbortResponse | Partial<Protocol.Fetch.FulfillRequestRequest> | void>;
+    private extractConfigVersion;
+    private getContent;
+    private isValidResponse;
+}

package/dist/services/onboarding/fetch-events/speed-kit-install-js.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeedKitInstallJs = void 0;
+const abort_response_1 = require("../browser/abort-response");
+const baqend_response_1 = require("../browser/baqend-response");
+/**
+ * Intercepts the response for speedkit-install.js
+ * Returns a custom build install.js from local-files
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+class SpeedKitInstallJs {
+    customerConfig;
+    installResource;
+    patterns;
+    constructor(customerConfig, installResource) {
+        this.customerConfig = customerConfig;
+        this.installResource = installResource;
+        this.patterns = [
+            {
+                requestStage: 'Response',
+                urlPattern: `https://${this.customerConfig.appDomain}/v1/speedkit/install*`,
+            },
+        ];
+    }
+    async handle(event, client) {
+        if (!event.request.url.includes(this.customerConfig.appDomain)) {
+            console.log('abort:', event.request.url);
+            return new abort_response_1.AbortResponse('Aborted');
+        }
+        if (!this.isValidResponse(event)) {
+            return;
+        }
+        let installJs = this.installResource.getContent();
+        if (!this.customerConfig.forceInstall) {
+            const originBody = await this.getContent(client, event);
+            const configVersion = this.extractConfigVersion(originBody);
+            if (configVersion) {
+                installJs = installJs.replace(this.customerConfig.swPath, this.customerConfig.swPath + configVersion);
+            }
+        }
+        return new baqend_response_1.BaqendResponse(installJs, 'text/javascript; charset=utf-8', event.responseHeaders);
+    }
+    extractConfigVersion(originBody) {
+        const [, configVersion] = originBody.match(/sw:.*?(\?[^"]*)/) || [];
+        return configVersion;
+    }
+    async getContent(client, event) {
+        const { base64Encoded, body } = await client.send('Fetch.getResponseBody', { requestId: event.requestId });
+        if (base64Encoded) {
+            return Buffer.from(body, 'base64').toString('utf8');
+        }
+        return body;
+    }
+    isValidResponse(event) {
+        return event.responseHeaders
+            && event.responseStatusCode
+            && event.responseStatusCode > 199
+            && event.responseStatusCode < 300;
+    }
+}
+exports.SpeedKitInstallJs = SpeedKitInstallJs;

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

@@ -0,0 +1,21 @@
+import { CDPSession } from 'puppeteer';
+import { Protocol } from 'puppeteer-core';
+import { CliService } from '../../cli';
+import CustomerConfig from '../../integration-api/struct/customer-config';
+import { AbortResponse } from '../browser/abort-response';
+import { FetchRequestPausedEventHandler } from '../onboarding-model';
+import { Cache } from '../request-cache/cache';
+/**
+ * Intercepts v1/rum/pi requests,
+ * if request contains changeDetection, clear dh-cache for respective url
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+export declare class SpeedKitRumPiRequest implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private cache;
+    private cli;
+    readonly patterns: Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, cache: Cache, cli: CliService);
+    handle(event: Protocol.Fetch.RequestPausedEvent, _: CDPSession): Promise<AbortResponse | Partial<Protocol.Fetch.FulfillRequestRequest> | void>;
+}

package/dist/services/onboarding/fetch-events/speed-kit-rum-pi-request.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeedKitRumPiRequest = void 0;
+const safe_1 = require("../../../helpers/safe");
+/**
+ * Intercepts v1/rum/pi requests,
+ * if request contains changeDetection, clear dh-cache for respective url
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+class SpeedKitRumPiRequest {
+    customerConfig;
+    cache;
+    cli;
+    patterns;
+    constructor(customerConfig, cache, cli) {
+        this.customerConfig = customerConfig;
+        this.cache = cache;
+        this.cli = cli;
+        this.patterns = [
+            {
+                requestStage: 'Request',
+                urlPattern: `https://${this.customerConfig.appDomain}/v1/rum/pi*`,
+            },
+        ];
+    }
+    handle(event, _) {
+        if (!event.request.hasPostData) {
+            return;
+        }
+        const result = (0, safe_1.safe)(() => JSON.parse(event.request.postData));
+        if (result.success === false) {
+            return;
+        }
+        if (!('changeDetection' in result.data)) {
+            return;
+        }
+        const changeDetection = result.data.changeDetection;
+        this.cache.removeEntry(changeDetection.url);
+        this.cli.write(`changeDetection triggered for url: ${changeDetection.url} - cleared from dh-cache`);
+    }
+}
+exports.SpeedKitRumPiRequest = SpeedKitRumPiRequest;

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

@@ -0,0 +1,17 @@
+import Protocol from 'devtools-protocol';
+import { FileInterface } from '../../integration-api/integration-api-model';
+import CustomerConfig from '../../integration-api/struct/customer-config';
+import { FetchRequestPausedEventHandler } from '../onboarding-model';
+/**
+ * SpeedKitServiceWorkerJs class is responsible for handling fetch requests for the SpeedKit service worker.
+ * Injects serviceWorker from local file, if custom_sw is present.
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+export declare class SpeedKitServiceWorkerJs implements FetchRequestPausedEventHandler {
+    private customerConfig;
+    private serviceWorker;
+    readonly patterns: Protocol.Fetch.RequestPattern[];
+    constructor(customerConfig: CustomerConfig, serviceWorker: FileInterface);
+    handle(): Promise<Partial<Protocol.Fetch.FulfillRequestRequest>>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeedKitServiceWorkerJs = void 0;
+const baqend_response_1 = require("../browser/baqend-response");
+/**
+ * SpeedKitServiceWorkerJs class is responsible for handling fetch requests for the SpeedKit service worker.
+ * Injects serviceWorker from local file, if custom_sw is present.
+ *
+ * @implements FetchRequestPausedEventHandler
+ */
+class SpeedKitServiceWorkerJs {
+    customerConfig;
+    serviceWorker;
+    patterns;
+    constructor(customerConfig, serviceWorker) {
+        this.customerConfig = customerConfig;
+        this.serviceWorker = serviceWorker;
+        this.patterns = [{
+                requestStage: 'Request',
+                urlPattern: `https://${this.customerConfig.appDomain}/v1/speedkit/sw.js*`,
+            }];
+    }
+    async handle() {
+        return new baqend_response_1.BaqendResponse(this.serviceWorker.getContent(), 'text/javascript; charset=utf-8');
+    }
+}
+exports.SpeedKitServiceWorkerJs = SpeedKitServiceWorkerJs;

package/dist/services/onboarding/file-events/fileWatcher.d.ts

@@ -0,0 +1,28 @@
+import { CliService } from "../../cli";
+import { Page } from "puppeteer";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import { DocumentHandlerServer } from "../../document-handler-runtime/document-handler-server";
+import { Cache } from "../request-cache/cache";
+import { ConfigFileInterface, FileListInterface } from "../../integration-api/integration-api-model";
+import { BrowserContext } from "../onboarding-model";
+/**
+ * Add different callbacks that will be executed if a local file is changed.
+ */
+export declare class FileWatcher {
+    private cli;
+    private customerConfig;
+    private files;
+    private documentHandler;
+    private browserContext;
+    private cache;
+    constructor(cli: CliService, customerConfig: CustomerConfig, files: FileListInterface, documentHandler: DocumentHandlerServer, browserContext: BrowserContext, cache: Cache);
+    addCallbackOnFileChange(page: Page, serviceWorkerReinstallCallback: (file: ConfigFileInterface) => Promise<void>): void;
+    private handleServiceWorkerDependencies;
+    private handleGenericConfigFiles;
+    private handleDynamicStyles;
+    private onChangeServiceWorkerCallback;
+    private onChangeConfigFileCallback;
+    private onChangeDynamicStyleCallback;
+    private clearPageFunction;
+    private clearServiceWorker;
+}

package/dist/services/onboarding/file-events/fileWatcher.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWatcher = void 0;
+const safe_1 = require("../../../helpers/safe");
+const virtual_file_1 = require("../../integration-api/struct/virtual-file");
+const files_1 = require("../../../models/files");
+/**
+ * Add different callbacks that will be executed if a local file is changed.
+ */
+class FileWatcher {
+    cli;
+    customerConfig;
+    files;
+    documentHandler;
+    browserContext;
+    cache;
+    constructor(cli, customerConfig, files, documentHandler, browserContext, cache) {
+        this.cli = cli;
+        this.customerConfig = customerConfig;
+        this.files = files;
+        this.documentHandler = documentHandler;
+        this.browserContext = browserContext;
+        this.cache = cache;
+    }
+    addCallbackOnFileChange(page, serviceWorkerReinstallCallback) {
+        const installResource = this.files.getByName(files_1.INTEGRATION_FILES.BUILD.INSTALL);
+        this.handleServiceWorkerDependencies(page, installResource, serviceWorkerReinstallCallback);
+        this.handleGenericConfigFiles(page, installResource);
+        this.handleDynamicStyles(page);
+    }
+    handleServiceWorkerDependencies(page, installResource, serviceWorkerReinstallCallback) {
+        // add watcher to serviceWorker related files
+        const serviceWorkerDependencies = [files_1.INTEGRATION_FILES.CONFIG.SPEED_KIT, files_1.INTEGRATION_FILES.CONFIG.LOAD_HANDLER, files_1.INTEGRATION_FILES.CUSTOM.LOADER, files_1.INTEGRATION_FILES.CUSTOM.SW];
+        for (const dependency of serviceWorkerDependencies) {
+            if (!this.files.hasFile(dependency)) {
+                continue;
+            }
+            const file = this.files.getByName(dependency);
+            if (file.type === virtual_file_1.VirtualFile) {
+                continue;
+            }
+            file.onChange(async (file) => {
+                const result = await (0, safe_1.safe)(this.onChangeServiceWorkerCallback(file, page, installResource, serviceWorkerReinstallCallback));
+                if (result.success === false) {
+                    this.cli.writeError(`error after fileChange: ${file.name}: ${result.error}`);
+                }
+            });
+        }
+    }
+    handleGenericConfigFiles(page, installResource) {
+        // add watcher to configFiles
+        const generalConfigFiles = [files_1.INTEGRATION_FILES.CONFIG.DYNAMIC_BLOCKS, files_1.INTEGRATION_FILES.CONFIG.DOCUMENT_HANDLER, files_1.INTEGRATION_FILES.CUSTOM.DYNAMIC_FETCHER, files_1.INTEGRATION_FILES.CUSTOM.DOCUMENT_HANDLER];
+        for (const configFile of generalConfigFiles) {
+            if (!this.files.hasFile(configFile)) {
+                continue;
+            }
+            const file = this.files.getByName(configFile);
+            if (file.type === virtual_file_1.VirtualFile) {
+                continue;
+            }
+            file.onChange(async (file) => {
+                const result = await (0, safe_1.safe)(this.onChangeConfigFileCallback(page, installResource, file));
+                if (result.success === false) {
+                    this.cli.writeError(`error after fileChange: ${file.name}: ${result.error}`);
+                }
+            });
+        }
+    }
+    handleDynamicStyles(page) {
+        if (!this.files.hasFile(files_1.INTEGRATION_FILES.CONFIG.DYNAMIC_STYLES)) {
+            return;
+        }
+        // add watcher that will instantly add changes to current page
+        this.files.getByName(files_1.INTEGRATION_FILES.CONFIG.DYNAMIC_STYLES).onChange(async (file) => {
+            const result = await (0, safe_1.safe)(this.onChangeDynamicStyleCallback(file, page));
+            if (result.success === false) {
+                this.cli.writeError(`error after fileChange: ${file.name}: ${result.error}`);
+            }
+        });
+    }
+    async onChangeServiceWorkerCallback(file, page, installResource, serviceWorkerReinstallCallback) {
+        this.cli.writeWarning(`changed file: ${file.name} (reinstall serviceWorker)`);
+        // clear speed-kit-service-worker-caches and uninstall serviceWorker
+        await this.clearPageFunction(page);
+        await this.clearServiceWorker(page);
+        // rebuild installResource
+        await installResource.buildContent();
+        // tell puppeteer to reinstall serviceworker on next navigate
+        await serviceWorkerReinstallCallback(file);
+    }
+    async onChangeConfigFileCallback(page, installResource, file) {
+        await this.clearPageFunction(page);
+        await this.documentHandler.buildDocumentHandler();
+        this.cache.clear();
+        await installResource.buildContent();
+        this.cli.writeWarning(`changed file: ${file.name}`);
+    }
+    async onChangeDynamicStyleCallback(file, page) {
+        this.cli.writeWarning(`changed file: ${file.name} (update styles on page)`);
+        const escapedStyles = encodeURI(file.getContent());
+        function updateStyles(styles) {
+            const styleElement = document.querySelector('#speed-kit-df-styles');
+            if (styleElement) {
+                styleElement.textContent = decodeURI(styles);
+            }
+        }
+        const evaluateResult = await (0, safe_1.safe)(page.evaluate(`(${updateStyles.toString()})("${escapedStyles}");`));
+        if (evaluateResult.success === false) {
+            this.cli.writeError(evaluateResult.error);
+        }
+        const clearPageResult = await (0, safe_1.safe)(this.clearPageFunction(page));
+        if (clearPageResult.success === false) {
+            this.cli.writeError(clearPageResult.error);
+        }
+        await this.documentHandler.buildDocumentHandler();
+        this.cache.clear();
+    }
+    async clearPageFunction(page) {
+        const client = await page.target().createCDPSession();
+        const cacheResponse = await client.send('CacheStorage.requestCacheNames', { securityOrigin: this.browserContext.domain });
+        for (const cache of cacheResponse.caches) {
+            if (cache.cacheName.includes('baqend')) {
+                await client.send('CacheStorage.deleteCache', { cacheId: cache.cacheId });
+            }
+        }
+    }
+    async clearServiceWorker(page) {
+        const client = await page.target().createCDPSession();
+        await client.send('ServiceWorker.enable');
+        await client.send('ServiceWorker.unregister', { scopeURL: `https://${this.customerConfig.domain}` });
+    }
+}
+exports.FileWatcher = FileWatcher;

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

@@ -0,0 +1,3 @@
+export { OnboardingContext } from './onboarding-model';
+export * from './onboarding-service';
+export * from './onboarding-service-factory';

package/dist/services/onboarding/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnboardingContext = void 0;
+const tslib_1 = require("tslib");
+var onboarding_model_1 = require("./onboarding-model");
+Object.defineProperty(exports, "OnboardingContext", { enumerable: true, get: function () { return onboarding_model_1.OnboardingContext; } });
+tslib_1.__exportStar(require("./onboarding-service"), exports);
+tslib_1.__exportStar(require("./onboarding-service-factory"), exports);

package/dist/services/onboarding/onboarding-model.d.ts

@@ -0,0 +1,30 @@
+import { Protocol } from "puppeteer-core";
+import { CDPSession } from "puppeteer";
+import { AbortResponse } from "./browser/abort-response";
+export declare class BrowserContext {
+    readonly domain: string;
+    readonly chromeFlags?: string[];
+    readonly browserArgs: string[];
+    readonly chromePath: string;
+    startParameterDashboard: boolean;
+    constructor(domain: string, chromeFlags?: string[]);
+}
+export interface FetchRequestPausedEventHandler {
+    readonly patterns: Protocol.Fetch.RequestPattern[];
+    handle(event: Protocol.Fetch.RequestPausedEvent, client: CDPSession): Promise<Partial<Protocol.Fetch.FulfillRequestRequest> | AbortResponse | void>;
+}
+export declare class OnboardingContext {
+    readonly customerPath: string;
+    readonly configName: string;
+    readonly local: boolean;
+    readonly verboseLevel?: boolean;
+    readonly DEFAULT_SW_PATH = "https://www.baqend.com/speed-kit/latest/sw.js";
+    readonly DEFAULT_SNIPPET_PATH = "https://www.baqend.com/speed-kit/latest/snippet.js";
+    readonly DEFAULT_DF_PATH = "https://www.baqend.com/speed-kit/latest/dynamic-fetcher.js";
+    constructor(customerPath: string, configName: string, local: boolean, verboseLevel?: boolean);
+}
+export type awsCredentials = {
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+};

package/dist/services/onboarding/onboarding-model.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnboardingContext = exports.BrowserContext = void 0;
+const tslib_1 = require("tslib");
+const dotenv = tslib_1.__importStar(require("dotenv"));
+dotenv.config();
+const DEFAULT_BROWSER_ARGS = [
+    '--enable-features=NetworkService',
+    '--no-first-run',
+    '--disable-infobars',
+];
+if (process.env.SPEED_KIT_EXTENSION_PATH) {
+    DEFAULT_BROWSER_ARGS.push(`--load-extension=${process.env.SPEED_KIT_EXTENSION_PATH}`, `--disable-extensions-except=${process.env.SPEED_KIT_EXTENSION_PATH}`);
+}
+if (process.env.CHROME_USER_PROFILE_PATH) {
+    DEFAULT_BROWSER_ARGS.push(`--user-data-dir=${process.env.CHROME_USER_PROFILE_PATH}`);
+}
+class BrowserContext {
+    domain;
+    chromeFlags;
+    browserArgs;
+    chromePath;
+    startParameterDashboard = false;
+    constructor(domain, chromeFlags) {
+        this.domain = domain;
+        this.chromeFlags = chromeFlags;
+        this.domain = domain;
+        this.chromeFlags = chromeFlags || [];
+        this.chromePath = process.env.CHROME_PATH;
+        this.browserArgs = [
+            ...DEFAULT_BROWSER_ARGS,
+            `--unsafely-treat-insecure-origin-as-secure=${domain}`,
+            ...this.chromeFlags,
+        ];
+    }
+}
+exports.BrowserContext = BrowserContext;
+class OnboardingContext {
+    customerPath;
+    configName;
+    local;
+    verboseLevel;
+    DEFAULT_SW_PATH = 'https://www.baqend.com/speed-kit/latest/sw.js';
+    DEFAULT_SNIPPET_PATH = 'https://www.baqend.com/speed-kit/latest/snippet.js';
+    DEFAULT_DF_PATH = 'https://www.baqend.com/speed-kit/latest/dynamic-fetcher.js';
+    constructor(customerPath, configName, local, verboseLevel) {
+        this.customerPath = customerPath;
+        this.configName = configName;
+        this.local = local;
+        this.verboseLevel = verboseLevel;
+    }
+}
+exports.OnboardingContext = OnboardingContext;

package/dist/services/onboarding/onboarding-service-factory.d.ts

@@ -0,0 +1,16 @@
+import { OnboardingService } from "./onboarding-service";
+import { OnboardingContext } from "./onboarding-model";
+import { UserCliConfig } from "../../helpers/cli-config";
+export declare class OnboardingServiceFactory {
+    private readonly context;
+    private cliConfig;
+    constructor(context: OnboardingContext, cliConfig: UserCliConfig);
+    getService(): Promise<OnboardingService>;
+    private getUrlForTest;
+    private buildInstallResource;
+    private getFetchEventHandler;
+    private getIntegrationFiles;
+    private getConfigApi;
+    private getAthenaClient;
+    private getCredentials;
+}