@speedkit/cli 2.21.0 → 2.23.0

package/dist/services/cli/cli-service.js

@@ -2,68 +2,79 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliService = void 0;
 const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const prompts_1 = require("@inquirer/prompts"); // interactive prompts
+const prompts_1 = require("@inquirer/prompts");
+const chalk_1 = tslib_1.__importDefault(require("chalk")); // interactive prompts
 const core_1 = require("@oclif/core");
 const cli_service_model_1 = require("./cli-service-model");
 class CliService {
-    buffer = [];
+    quiet;
     style = chalk_1.default;
-    codeStyle(code) {
-        const padding = " ";
-        return this.style.bgGray.rgb(230, 126, 0)(`${padding}${code}${padding}`);
+    buffer = [];
+    progressBar;
+    constructor(quiet = false) {
+        this.quiet = quiet;
     }
-    write(message, buffered = false) {
+    code(code, buffered = false) {
+        code = `  ${code}  `;
         if (buffered) {
-            this.buffer.push(this.style.white(message));
+            this.buffer.push(this.style.bgBlack.white(code));
             return;
         }
-        core_1.ux.info(message);
+        core_1.ux.log(this.style.bgBlack.white(code));
     }
-    spacer() {
-        core_1.ux.info("");
+    codeStyle(code) {
+        const padding = " ";
+        return this.style.bgGray.rgb(230, 126, 0)(`${padding}${code}${padding}`);
     }
-    writeSuccess(message, buffered = false) {
+    comment(message, buffered = false) {
         if (buffered) {
-            this.buffer.push(this.style.green(message));
+            this.buffer.push(this.style.grey.italic(message));
             return;
         }
-        this.write(this.style.green(message));
+        this.write(this.style.grey.italic(message));
     }
-    writeWarning(message, buffered = false) {
-        if (buffered) {
-            this.buffer.push(this.style.yellow(message));
-            return;
+    async confirm(message, defaultAnswer = true) {
+        if (this.quiet) {
+            return defaultAnswer;
         }
-        this.write(this.style.yellow(message));
+        return (0, prompts_1.confirm)({
+            default: defaultAnswer,
+            message: this.getFormattedMessage(message),
+        });
     }
-    writeError(message, buffered = false) {
-        if (buffered) {
-            this.buffer.push(this.style.red(message));
+    endAction(status) {
+        if (this.quiet) {
             return;
         }
-        this.write(this.style.red(message));
-    }
-    comment(message, buffered = false) {
-        if (buffered) {
-            this.buffer.push(this.style.grey.italic(message));
-            return;
+        switch (status) {
+            case cli_service_model_1.CliActionStatus.COMPLETED: {
+                core_1.ux.action.stop(this.style.green(cli_service_model_1.CliActionStatus.COMPLETED));
+                break;
+            }
+            case cli_service_model_1.CliActionStatus.FAILED: {
+                core_1.ux.action.stop(this.style.red(cli_service_model_1.CliActionStatus.FAILED));
+                break;
+            }
+            case cli_service_model_1.CliActionStatus.SKIPPED: {
+                core_1.ux.action.stop(this.style.yellow(cli_service_model_1.CliActionStatus.SKIPPED));
+                break;
+            }
+            default: {
+                core_1.ux.action.stop();
+            }
         }
-        this.write(this.style.grey.italic(message));
     }
-    code(code, buffered = false) {
-        code = `  ${code}  `;
-        if (buffered) {
-            this.buffer.push(this.style.bgBlack.white(code));
-            return;
-        }
-        core_1.ux.log(this.style.bgBlack.white(code));
+    exit(code = 0) {
+        core_1.ux.exit(code);
     }
     async prompt(message, options) {
-        const { validator, defaultAnswer } = options;
+        if (this.quiet) {
+            return options?.defaultAnswer || "";
+        }
+        const { defaultAnswer, validator } = options;
         return (0, prompts_1.input)({
-            message: this.getFormattedMessage(message),
             default: defaultAnswer,
+            message: this.getFormattedMessage(message),
             validate: (input) => {
                 if (typeof validator !== "function")
                     return true;
@@ -75,50 +86,75 @@ class CliService {
             },
         });
     }
-    async confirm(message, defaultAnswer = true) {
-        return (0, prompts_1.confirm)({
-            message: this.getFormattedMessage(message),
-            default: defaultAnswer,
-        });
-    }
     async select(message, choices) {
         return (0, prompts_1.select)({
-            message: this.getFormattedMessage(message),
             choices,
+            message: this.getFormattedMessage(message),
         });
     }
+    spacer() {
+        core_1.ux.info("");
+    }
     startAction(message) {
+        if (this.quiet) {
+            return;
+        }
         core_1.ux.action.start(message);
     }
-    endAction(status) {
-        switch (status) {
-            case cli_service_model_1.CliActionStatus.COMPLETED: {
-                core_1.ux.action.stop(this.style.green(cli_service_model_1.CliActionStatus.COMPLETED));
-                break;
-            }
-            case cli_service_model_1.CliActionStatus.FAILED: {
-                core_1.ux.action.stop(this.style.red(cli_service_model_1.CliActionStatus.FAILED));
-                break;
-            }
-            case cli_service_model_1.CliActionStatus.SKIPPED: {
-                core_1.ux.action.stop(this.style.yellow(cli_service_model_1.CliActionStatus.SKIPPED));
-                break;
-            }
-            default: {
-                core_1.ux.action.stop();
-            }
+    startProgress(total, start = 0, payload, config) {
+        if (this.quiet) {
+            return;
         }
+        this.progressBar = core_1.ux.progress(config);
+        this.progressBar.start(total, start, payload);
+    }
+    stopProgress() {
+        if (this.quiet) {
+            return;
+        }
+        this.progressBar.stop();
+    }
+    table(data, columns, options) {
+        core_1.ux.table(data, columns, options);
+    }
+    updateProgress(current, payload) {
+        if (this.quiet) {
+            return;
+        }
+        this.progressBar.update(current, payload);
+    }
+    write(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.white(message));
+            return;
+        }
+        core_1.ux.info(message);
     }
     writeBuffer() {
         core_1.ux.log(this.buffer.join(`\n`));
         core_1.ux.log();
         this.buffer = [];
     }
-    table(data, columns, options) {
-        core_1.ux.table(data, columns, options);
+    writeError(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.red(message));
+            return;
+        }
+        this.write(this.style.red(message));
     }
-    exit(code = 0) {
-        core_1.ux.exit(code);
+    writeSuccess(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.green(message));
+            return;
+        }
+        this.write(this.style.green(message));
+    }
+    writeWarning(message, buffered = false) {
+        if (buffered) {
+            this.buffer.push(this.style.yellow(message));
+            return;
+        }
+        this.write(this.style.yellow(message));
     }
     getFormattedMessage(questionText) {
         return `${this.style.bold(questionText)}`;

package/dist/services/config-api/client.d.ts

@@ -1,16 +1,14 @@
-import RequestExtensionInterface from "./interface/request-extension-interface";
+import { EntityManager } from "baqend";
 import EntityManagerFactory from "./factory/entity-manager-factory";
+import RequestExtensionInterface from "./interface/request-extension-interface";
 export default class Client {
-    private readonly entityManagerFactory;
-    private readonly app;
     private readonly agent;
+    private readonly app;
+    private readonly entityManagerFactory;
     constructor(app: string, entityManagerFactory: EntityManagerFactory);
-    send(url: string, requestExtension?: RequestExtensionInterface): Promise<any>;
+    createRequest(requestExtension: RequestExtensionInterface): Promise<RequestInit>;
+    getEntityManager(): Promise<EntityManager>;
     getModule(moduleName: string): Promise<string>;
+    send(url: string, requestExtension?: RequestExtensionInterface): Promise<any>;
     setModule(moduleName: string, moduleCode: string): Promise<string>;
-    /**
-     * @param requestExtension
-     */
-    createRequest(requestExtension: RequestExtensionInterface): Promise<NonNullable<unknown>>;
-    private getEntityManager;
 }

package/dist/services/config-api/client.js

@@ -1,57 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const node_https_1 = require("node:https");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
+const node_https_1 = require("node:https");
 const race_1 = require("../../helpers/race");
 const REQUEST_TIMEOUT = 10_000;
 const CONTENT_TYPE = "application/json;charset=UTF-8";
 class Client {
-    entityManagerFactory;
-    app;
     agent;
+    app;
+    entityManagerFactory;
     constructor(app, entityManagerFactory) {
         this.app = app;
         this.entityManagerFactory = entityManagerFactory;
-        this.agent = new node_https_1.Agent({ rejectUnauthorized: false, keepAlive: true });
-    }
-    async send(url, requestExtension = {}) {
-        const response = await (0, node_fetch_1.default)(url, await this.createRequest(requestExtension));
-        if (response.status !== 200) {
-            const json = await response.json();
-            throw new Error(json.message);
-        }
-        return await response.json();
-    }
-    async getModule(moduleName) {
-        const entityManager = await this.getEntityManager();
-        return await entityManager.code.loadCode(moduleName, "module");
-    }
-    async setModule(moduleName, moduleCode) {
-        const entityManager = await this.getEntityManager();
-        return await entityManager.code.saveCode(moduleName, "module", moduleCode);
+        this.agent = new node_https_1.Agent({ keepAlive: true, rejectUnauthorized: false });
     }
-    /**
-     * @param requestExtension
-     */
     async createRequest(requestExtension) {
         const entityManager = await this.getEntityManager();
         const baseRequest = {
-            method: "GET",
             headers: {
+                "Content-Type": CONTENT_TYPE,
                 Host: `${this.app}.app.baqend.com`,
                 authorization: `BAT ${entityManager.token}`,
-                "Content-Type": CONTENT_TYPE,
             },
+            method: "GET",
             timeout: REQUEST_TIMEOUT,
         };
-        return Object.assign({}, (0, deepmerge_1.default)(baseRequest, requestExtension), {
-            agent: this.agent,
-        });
+        // @ts-expect-error agent seems not to be part of type RequestInit
+        return { ...(0, deepmerge_1.default)(baseRequest, requestExtension), agent: this.agent };
     }
     async getEntityManager() {
-        return await (0, race_1.race)(this.entityManagerFactory.getEntityManager(this.app));
+        return (0, race_1.race)(this.entityManagerFactory.getEntityManager(this.app));
+    }
+    async getModule(moduleName) {
+        const entityManager = await this.getEntityManager();
+        return entityManager.code.loadCode(moduleName, "module");
+    }
+    async send(url, requestExtension = {}) {
+        const requestInit = await this.createRequest(requestExtension);
+        const response = await fetch(url, requestInit);
+        if (response.status !== 200) {
+            const message = await response.json();
+            throw new Error(message);
+        }
+        return response.json();
+    }
+    async setModule(moduleName, moduleCode) {
+        const entityManager = await this.getEntityManager();
+        return entityManager.code.saveCode(moduleName, "module", moduleCode);
     }
 }
 exports.default = Client;

package/dist/services/customer-config/customer-config-service-model.d.ts

@@ -23,6 +23,7 @@ export interface CustomerConfigSettings {
     appName?: string;
     production?: EnvironmentConfig;
     staging?: EnvironmentConfig;
+    subRouteScope?: string;
     includeServiceWorker?: string;
     activateImageOptimisation?: boolean;
     removeLazyLoading?: boolean;

package/dist/services/customer-config/customer-config-service.js

@@ -161,7 +161,7 @@ class CustomerConfigService {
         }
     }
     async getConfigSettings() {
-        let { production, staging, includeServiceWorker, activateImageOptimisation, removeLazyLoading, addPreRendering, activateRumTracking, useGATracking, withGoogleOptimize, activateCfRocketLoaderWorkaround, isShopify, isShopware, isSalesforce, isPlentymarkets, shopifyId, } = {};
+        let { production, staging, subRouteScope, includeServiceWorker, activateImageOptimisation, removeLazyLoading, addPreRendering, activateRumTracking, useGATracking, withGoogleOptimize, activateCfRocketLoaderWorkaround, isShopify, isShopware, isSalesforce, isPlentymarkets, shopifyId, } = {};
         this.appName = await this.cli.prompt(`Enter SK App Name:`, {
             validator: (input) => /^[\da-z]+(?:-[\da-z]+)*$/.test(input) ? "" : "No valid kebab-case",
             defaultAnswer: this.appName,
@@ -199,6 +199,9 @@ class CustomerConfigService {
                 staging = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.STAGING, production.host.replace("www", "stg"));
             }
         }
+        if (await this.cli.confirm("Should SK only be active on specific sub-routes? (e.g. /de-de)", false)) {
+            subRouteScope = await this.cli.prompt("Enter one exemplary sub-route to scope to (without leading/trailing slashes):", { defaultAnswer: "de-de" });
+        }
         if (await this.cli.confirm("Is there a Service Worker which needs to be included?", false)) {
             includeServiceWorker = await this.cli.prompt("Enter path of Service Worker to be included:", { defaultAnswer: "/sw.js" });
         }
@@ -217,6 +220,7 @@ class CustomerConfigService {
             appName: this.appName,
             production,
             staging,
+            subRouteScope,
             includeServiceWorker,
             activateImageOptimisation,
             removeLazyLoading,

package/dist/services/customer-config/templates/config_SpeedKit.js.hbs

@@ -3,6 +3,9 @@
     // Production:
     {
       hosts: ["{{production.host}}"],
+{{#if subRouteScope}}
+      scopes: ["{{subRouteScope}}"],
+{{/if}}
       split: 0,
       splitTestId: "0vs100_20xx-xx-xx",
     },
@@ -11,6 +14,9 @@
     // Staging:
     {
       hosts: ["{{staging.host}}"],
+{{#if subRouteScope}}
+      scopes: ["{{subRouteScope}}"],
+{{/if}}
     },
 {{else}}
     // No Staging configured
@@ -100,7 +106,7 @@
         // – unless this has been explicitly requested!
         contentType: ["script", "style", "font"],
       },
-      
+
       // Shopify specific:
       {
         url: [
@@ -323,7 +329,14 @@
 
     // Lookup for matching enabled hosts config
     for (var i = 0; i < enabledHostsConfigs.length; i++) {
+{{#if subRouteScope}}
+      if (
+        enabledHostsConfigs[i].hosts.indexOf(currentHost) !== -1 &&
+        isCurrentScopeEnabled(enabledHostsConfigs[i].scopes)
+      ) {
+{{else}}
       if (enabledHostsConfigs[i].hosts.indexOf(currentHost) !== -1) {
+{{/if}}
         foundHostConfig = enabledHostsConfigs[i];
         break; // Break out of the loop once the config related to the host is found
       }
@@ -348,4 +361,25 @@
       };
     }
   }
+{{#if subRouteScope}}
+
+  function isCurrentScopeEnabled(enabledScopes) {
+    // Check if enabled scopes are provided
+    if (!enabledScopes) {
+      // If not: consider current scope as enabled due to no scoping
+      return true;
+    }
+
+    // Check if enabled scopes are provided as array
+    if (!Array.isArray(enabledScopes)) {
+      // If not: consider current scope as disabled due to faulty scoping
+      return false;
+    }
+
+    // Test if current scope matches enabled scopes
+    var pattern = "^/(" + enabledScopes.join("|") + ")/";
+    var regex = new RegExp(pattern);
+    return regex.test(location.pathname);
+  }
+{{/if}}
 })();

package/dist/services/customer-config/templates/config_customer.js.hbs

@@ -1,5 +1,5 @@
 /**
- * Shop System in use:
+ * Shop/Frontend system in use:
 {{#if isShopify}}
  * - Shopify
 {{else if isShopware}}
@@ -9,7 +9,7 @@
 {{else if isPlentymarkets}}
  * - Plentymarkets
 {{else}}
- * - TODO: enter name of shop system here... please
+ * - TODO: enter name of system in use
 {{/if}}
  */
 
@@ -25,7 +25,11 @@ const shared = {
 {{else}}
   swPath: "/wrapper-sw.js",
 {{/if}}
+{{#if subRouteScope}}
+  scope: "/{{subRouteScope}}/",
+{{else}}
   scope: "/",
+{{/if}}
 };
 
 const configs = {

package/dist/services/customer-config/templates/config_documentHandler.js.hbs

@@ -45,6 +45,11 @@ const lazyLoadList = [
 {{/unless}}
 const config = {
   rejectHTML({ db, {{#if addPreRendering}}document{{else}}html{{/if}}, variation, url, headers }) {
+    /* Use to configure guards to prevent e.g. error and captcha pages from being cached */
+    return false;
+  },
+  blacklistHTML({ db, {{#if addPreRendering}}document{{else}}html{{/if}}, variation, url, headers }) {
+    /* Use to configure guards to black-list e.g. specific page types */
     return false;
   },
   shouldTransform({ db, {{#if addPreRendering}}document{{else}}html{{/if}}, variation, url, headers }) {

package/dist/services/prewarm/assets/asset-api-client.d.ts

@@ -0,0 +1,13 @@
+export declare class AssetApiClient {
+    private authenticationToken;
+    private app;
+    private sortParameters;
+    private agent;
+    private rateLimit;
+    constructor(authenticationToken: string, app: string, sortParameters: boolean);
+    fetchURL(url: string, variation: string): Promise<Response>;
+    getRateLimit(): number;
+    reduceMaxRequestsPerSecond(): void;
+    private isValidUrl;
+    private setRateLimit;
+}

package/dist/services/prewarm/assets/asset-api-client.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetApiClient = void 0;
+const tslib_1 = require("tslib");
+const node_https_1 = require("node:https");
+const node_url_1 = require("node:url");
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const __1 = require("../");
+const normalize_1 = require("../../../helpers/normalize");
+const invalid_origin_error_1 = require("../error/invalid-origin-error");
+class AssetApiClient {
+    authenticationToken;
+    app;
+    sortParameters;
+    agent = new node_https_1.Agent({
+        keepAlive: true,
+        rejectUnauthorized: false,
+    });
+    rateLimit = __1.DEFAULT_MAX_REQUESTS_PER_SECOND;
+    constructor(authenticationToken, app, sortParameters) {
+        this.authenticationToken = authenticationToken;
+        this.app = app;
+        this.sortParameters = sortParameters;
+    }
+    async fetchURL(url, variation) {
+        this.isValidUrl(url);
+        const assetUrl = new node_url_1.URL((0, normalize_1.normalize)(url, this.sortParameters));
+        if (variation !== "DEFAULT" && variation !== "DESKTOP") {
+            assetUrl.searchParams.set("bqvariation", variation.toLowerCase());
+        }
+        assetUrl.searchParams.set("bqpass", "1");
+        return (0, node_fetch_1.default)(`https://${this.app}.app.baqend.com/v1/asset/${assetUrl.toString()}`, {
+            agent: this.agent,
+            headers: {
+                "Accept-Encoding": "gzip, deflate, br",
+                Origin: assetUrl.origin,
+                authorization: `BAT ${this.authenticationToken}`,
+            },
+            method: "HEAD",
+            timeout: __1.FETCH_TIMEOUT,
+        });
+    }
+    getRateLimit() {
+        return this.rateLimit;
+    }
+    reduceMaxRequestsPerSecond() {
+        this.setRateLimit(this.rateLimit * __1.RATE_LIMIT_MULTIPLICATOR);
+    }
+    isValidUrl(url) {
+        if (!node_url_1.URL.canParse(url)) {
+            throw new invalid_origin_error_1.InvalidOriginError(`Invalid url`);
+        }
+    }
+    setRateLimit(limit) {
+        this.rateLimit = limit > 1 ? Math.floor(limit) : 1;
+    }
+}
+exports.AssetApiClient = AssetApiClient;

package/dist/services/prewarm/assets/asset-item.d.ts

@@ -0,0 +1,14 @@
+import { AssetItemInterface, ItemStatus } from "../";
+import { AssetApiClient } from "./asset-api-client";
+export declare class AssetItem implements AssetItemInterface {
+    readonly url: string;
+    readonly variation: string;
+    readonly callback: (client: AssetApiClient, entry: AssetItemInterface) => Promise<void>;
+    error?: Error;
+    status: ItemStatus;
+    constructor(url: string, variation: string, callback: (client: AssetApiClient, entry: AssetItemInterface) => Promise<void>);
+    done(): void;
+    failed(): void;
+    retry(): void;
+    setError(error: Error): void;
+}

package/dist/services/prewarm/assets/asset-item.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetItem = void 0;
+const __1 = require("../");
+class AssetItem {
+    url;
+    variation;
+    callback;
+    error = null;
+    status = __1.ItemStatus.NEW;
+    constructor(url, variation, callback) {
+        this.url = url;
+        this.variation = variation;
+        this.callback = callback;
+    }
+    done() {
+        this.status = __1.ItemStatus.DONE;
+    }
+    failed() {
+        this.status = __1.ItemStatus.ERROR;
+    }
+    retry() {
+        this.status = __1.ItemStatus.RETRY;
+    }
+    setError(error) {
+        this.error = error;
+    }
+}
+exports.AssetItem = AssetItem;

package/dist/services/prewarm/assets/asset-list.d.ts

@@ -0,0 +1,14 @@
+import { AssetItemInterface, ItemStatus } from "../";
+export declare class AssetList {
+    private variations;
+    private elements;
+    constructor(variations: string[]);
+    addItem(item: AssetItemInterface): void;
+    getBatch(offset: number, limit: number): AssetItemInterface[];
+    getByStatus(status: ItemStatus): AssetItemInterface[];
+    getErrorCount(): number;
+    getErrors(): Error[];
+    getLength(): number;
+    getRetryCount(): number;
+    getSuccessCount(): number;
+}

package/dist/services/prewarm/assets/asset-list.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetList = void 0;
+const __1 = require("../");
+class AssetList {
+    variations;
+    elements = [];
+    constructor(variations) {
+        this.variations = variations;
+    }
+    addItem(item) {
+        this.elements.push(item);
+    }
+    getBatch(offset, limit) {
+        let batchLimit = offset + limit;
+        if (offset >= this.elements.length) {
+            return [];
+        }
+        if (batchLimit >= this.elements.length) {
+            batchLimit = this.elements.length;
+        }
+        return this.elements.slice(offset, batchLimit);
+    }
+    getByStatus(status) {
+        return this.elements.filter((element) => element.status === status);
+    }
+    getErrorCount() {
+        return this.getByStatus(__1.ItemStatus.ERROR).length;
+    }
+    getErrors() {
+        return this.getByStatus(__1.ItemStatus.ERROR).map((element) => element.error);
+    }
+    getLength() {
+        return this.elements.length;
+    }
+    getRetryCount() {
+        return this.getByStatus(__1.ItemStatus.RETRY).length;
+    }
+    getSuccessCount() {
+        return this.getByStatus(__1.ItemStatus.DONE).length;
+    }
+}
+exports.AssetList = AssetList;

package/dist/services/prewarm/csv-reader.d.ts

@@ -0,0 +1,5 @@
+export declare class CsvReader {
+    readPath(filePath: string): string[];
+    private cleanUpEntries;
+    private getEntries;
+}