@speedkit/cli 2.22.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/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;
+}

package/dist/services/prewarm/csv-reader.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CsvReader = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const read_csv_error_1 = require("./error/read-csv-error");
+const ENCODING = "utf8";
+const LINE_BREAK = /\r?\n/;
+class CsvReader {
+    readPath(filePath) {
+        try {
+            const entries = this.getEntries(filePath);
+            return this.cleanUpEntries(entries);
+        }
+        catch (error) {
+            throw new read_csv_error_1.ReadCsvError(error.message, [
+                "check arguments for correct filePath",
+            ]);
+        }
+    }
+    cleanUpEntries(entries) {
+        return entries
+            .map((entry) => {
+            return /^"[^"]+"/.test(entry) ? entry.slice(1, -1) : entry;
+        })
+            .filter(Boolean);
+    }
+    getEntries(filePath) {
+        const fileContent = node_fs_1.default.readFileSync(node_path_1.default.resolve(filePath), ENCODING);
+        return fileContent.split(LINE_BREAK);
+    }
+}
+exports.CsvReader = CsvReader;

package/dist/services/prewarm/error/invalid-origin-error.d.ts

@@ -0,0 +1,2 @@
+export declare class InvalidOriginError extends Error {
+}

package/dist/services/prewarm/error/invalid-origin-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidOriginError = void 0;
+class InvalidOriginError extends Error {
+}
+exports.InvalidOriginError = InvalidOriginError;

package/dist/services/prewarm/error/read-csv-error.d.ts

@@ -0,0 +1,8 @@
+import { PrettyPrintableError } from "@oclif/core/lib/errors";
+export declare class ReadCsvError extends Error implements PrettyPrintableError {
+    readonly message: string;
+    readonly suggestions?: string[];
+    readonly ref?: string;
+    readonly code = "SK_CLI_CSV_READ";
+    constructor(message: string, suggestions?: string[], ref?: string);
+}

package/dist/services/prewarm/error/read-csv-error.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadCsvError = void 0;
+class ReadCsvError extends Error {
+    message;
+    suggestions;
+    ref;
+    code = "SK_CLI_CSV_READ";
+    constructor(message, suggestions, 
+    // eslint-disable-next-line unicorn/prevent-abbreviations
+    ref) {
+        super(message);
+        this.message = message;
+        this.suggestions = suggestions;
+        this.ref = ref;
+    }
+}
+exports.ReadCsvError = ReadCsvError;

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

@@ -0,0 +1,3 @@
+export * from "./pre-warm-service";
+export * from "./pre-warm-factory";
+export * from "./pre-warm-model";

package/dist/services/prewarm/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./pre-warm-service"), exports);
+tslib_1.__exportStar(require("./pre-warm-factory"), exports);
+tslib_1.__exportStar(require("./pre-warm-model"), exports);

package/dist/services/prewarm/pre-warm-factory.d.ts

@@ -0,0 +1,8 @@
+import { PreWarmContext, PreWarmService } from "./";
+export declare class PreWarmFactory {
+    private context;
+    constructor(context: PreWarmContext);
+    getService(): Promise<PreWarmService>;
+    private getUrls;
+    private getVariations;
+}

package/dist/services/prewarm/pre-warm-factory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreWarmFactory = void 0;
+const tslib_1 = require("tslib");
+const cli_1 = require("../cli");
+const config_api_context_1 = tslib_1.__importDefault(require("../config-api/context/config-api-context"));
+const config_api_service_factory_1 = tslib_1.__importDefault(require("../config-api/factory/config-api-service-factory"));
+const _1 = require("./");
+const asset_api_client_1 = require("./assets/asset-api-client");
+const csv_reader_1 = require("./csv-reader");
+class PreWarmFactory {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async getService() {
+        const cli = new cli_1.CliServiceFactory(new cli_1.CliContext(this.context.quiet)).getService();
+        const configApi = new config_api_service_factory_1.default(new config_api_context_1.default(this.context.app)).getService();
+        const entityManager = await configApi.client.getEntityManager();
+        const csvReader = new csv_reader_1.CsvReader();
+        const assetApiClient = new asset_api_client_1.AssetApiClient(entityManager.token, this.context.app, this.context.keepParameterSorting);
+        const urls = this.getUrls(csvReader);
+        const variations = this.getVariations(csvReader);
+        return new _1.PreWarmService(assetApiClient, cli, urls, variations);
+    }
+    getUrls(csvReader) {
+        return csvReader.readPath(this.context.path);
+    }
+    getVariations(csvReader) {
+        let variations = _1.DEFAULT_VARIATION;
+        if (this.context.variation) {
+            variations = this.context.variation.split(_1.VARIATION_SEPARATOR);
+        }
+        if (this.context.variationPath) {
+            variations = csvReader.readPath(this.context.variationPath);
+        }
+        return variations;
+    }
+}
+exports.PreWarmFactory = PreWarmFactory;