@speedkit/cli 2.4.1

package/dist/commands/prewarm.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const core_2 = require("@oclif/core");
+const cli_1 = require("baqend/cli");
+const cli_parameters_1 = require("../models/cli-parameters");
+const logging_helper_1 = require("../helpers/logging-helper");
+const prewarm_service_1 = tslib_1.__importDefault(require("../services/prewarm-service"));
+const { URL } = require('url');
+const fs = require('fs');
+class Prewarm extends core_1.Command {
+    static description = 'Pre-warm Fastly';
+    static args = {
+        [cli_parameters_1.CLIParameters.AppName]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.AppName,
+            required: true,
+            description: 'The customer app name', // help description
+        }),
+        [cli_parameters_1.CLIParameters.Path]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.Path,
+            required: true,
+            description: 'path to prewarmFile', // help description
+        }),
+    };
+    static flags = {
+        [cli_parameters_1.CLIParameters.Variation]: core_1.Flags.string({ char: cli_parameters_1.CLIParametersChar.Variation, default: 'DEFAULT' }),
+        [cli_parameters_1.CLIParameters.VariationPath]: core_1.Flags.string({ char: cli_parameters_1.CLIParametersChar.VariationPath, exclusive: [cli_parameters_1.CLIParameters.Variation] }),
+        [cli_parameters_1.CLIParameters.Delay]: core_1.Flags.integer({ char: cli_parameters_1.CLIParametersChar.Delay, default: 0, description: 'Request delay in ms' }),
+        [cli_parameters_1.CLIParameters.KeepParameterSorting]: core_1.Flags.boolean({ char: cli_parameters_1.CLIParametersChar.KeepParameterSorting, default: false, description: 'Prevents alphabetical sorting of the URL parameters' }),
+    };
+    static examples = [
+        "for a single variation:",
+        `$ sk prewarm <${cli_parameters_1.CLIParameters.AppName}> <${cli_parameters_1.CLIParameters.Path}> -${cli_parameters_1.CLIParametersChar.Variation} <${cli_parameters_1.CLIParameters.Variation}> -${cli_parameters_1.CLIParametersChar.Delay} <${cli_parameters_1.CLIParameters.Delay}> -${cli_parameters_1.CLIParametersChar.KeepParameterSorting}`,
+        `$ sk prewarm ${cli_parameters_1.CLIParametersExample.AppName} ${cli_parameters_1.CLIParametersExample.Path} -${cli_parameters_1.CLIParametersChar.Variation} ${cli_parameters_1.CLIParametersExample.Variation} -${cli_parameters_1.CLIParametersChar.Delay} ${cli_parameters_1.CLIParametersExample.Delay} -${cli_parameters_1.CLIParametersChar.KeepParameterSorting}`,
+        "",
+        "for a list of variations:",
+        `$ sk prewarm <${cli_parameters_1.CLIParameters.AppName}> <${cli_parameters_1.CLIParameters.Path}> -${cli_parameters_1.CLIParametersChar.Path} <${cli_parameters_1.CLIParameters.VariationPath}> -${cli_parameters_1.CLIParametersChar.Delay} <${cli_parameters_1.CLIParameters.Delay}> -${cli_parameters_1.CLIParametersChar.KeepParameterSorting}`,
+        `$ sk prewarm ${cli_parameters_1.CLIParametersExample.AppName} ${cli_parameters_1.CLIParametersExample.Path} -${cli_parameters_1.CLIParametersChar.Path} ${cli_parameters_1.CLIParametersExample.VariationPath} -${cli_parameters_1.CLIParametersChar.Delay} ${cli_parameters_1.CLIParametersExample.Delay} -${cli_parameters_1.CLIParametersChar.KeepParameterSorting}`,
+    ];
+    async run() {
+        const { args: { app, path }, flags: { variation, variationPath, delay, keepParameterSorting } } = await this.parse(Prewarm);
+        const sortParameters = !keepParameterSorting;
+        const db = await cli_1.account.login({ app });
+        const urls = this.loadAssets(path);
+        const variations = variationPath ? this.loadVariations(variationPath) : [variation];
+        await this.prewarmVariations(variations, urls, app, db.token, delay, sortParameters);
+    }
+    /**
+     * Pre-warms a list of URLs with the given variations.
+     *
+     * @param variations - Variations to be prewarmed.
+     * @param urls - The URLs to be prewarmed.
+     * @param app - The baqend app to prewarm on.
+     * @param token - The baqend token to authorize the user.
+     * @param delay - The delay between requests in ms.
+     * @param sortParameters - Activates alphabetical sorting of the URL parameters.
+     */
+    async prewarmVariations(variations, urls, app, token, delay, sortParameters) {
+        const progress = core_2.ux.progress();
+        const chunks = prewarm_service_1.default.chunk(urls, 5);
+        let fetches = [];
+        progress.start(urls.length * variations.length, 0);
+        for (const chunk of chunks) {
+            for (const entry of chunk) {
+                if (delay)
+                    await this.sleep(delay);
+                for (const variation of variations) {
+                    try {
+                        if (entry) {
+                            fetches.push(prewarm_service_1.default.fetchURL(entry.url, entry.origin, variation, app, token, sortParameters));
+                        }
+                    }
+                    catch (error) {
+                        (0, logging_helper_1.logError)(error);
+                    }
+                }
+            }
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                await Promise.all(fetches);
+            }
+            catch (error) {
+                (0, logging_helper_1.logWarning)(error);
+            }
+            progress.increment(fetches.length);
+            fetches = [];
+        }
+        progress.stop();
+    }
+    loadAssets(path, origin = '') {
+        const data = fs.readFileSync(path, 'utf8');
+        const entries = data.split(/\r?\n/);
+        return entries.map(entry => {
+            entry = /^"[^"]+"/.test(entry) ? entry.slice(1, -1) : entry;
+            try {
+                return {
+                    url: entry,
+                    origin: origin || new URL(entry).origin,
+                };
+            }
+            catch (error) {
+                (0, logging_helper_1.logWarning)(`Error loading asset for URL: ${entry}`, error);
+            }
+            return null;
+        });
+    }
+    /**
+     * Extracts variations line by line from a given file.
+     * @param path - path to the csv containing variations
+     */
+    loadVariations(path) {
+        let variations = [];
+        const data = fs.readFileSync(path, 'utf8');
+        const entries = data.split(/\r?\n/);
+        entries.forEach(entry => {
+            if (entry !== "") {
+                variations.push(entry);
+            }
+        });
+        return variations;
+    }
+    async sleep(ms) {
+        return new Promise(res => setTimeout(res, ms));
+    }
+}
+exports.default = Prewarm;

package/dist/commands/pull.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Pull extends Command {
+    static description: string;
+    static args: {
+        customerPath: import("@oclif/core/lib/interfaces").Arg<string, {
+            exists?: boolean;
+        }>;
+    };
+    static flags: {
+        configName: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/pull.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const cli_parameters_1 = require("../models/cli-parameters");
+const pull_1 = require("../services/pull");
+const cli_config_1 = require("../helpers/cli-config");
+class Pull extends core_1.Command {
+    static description = 'Pull the specified customer config from orestes';
+    static args = cli_parameters_1.CLI_CUSTOMER_CONFIG;
+    static flags = {
+        ...cli_parameters_1.CLI_CONFIG_NAME,
+    };
+    static examples = [
+        `$ sk pull <${cli_parameters_1.CLIParameters.CustomerPath}>`,
+        `$ sk pull ${cli_parameters_1.CLIParametersExample.CustomerPath} -${cli_parameters_1.CLIParametersChar.ConfigName} ${cli_parameters_1.CLIParametersExample.ConfigName}`,
+    ];
+    async run() {
+        const { args: { customerPath }, flags: { configName } } = await this.parse(Pull);
+        const pullContext = new pull_1.PullContext(customerPath, configName);
+        const pullService = await new pull_1.PullServiceFactory(pullContext, new cli_config_1.CliConfig(this.config).load()).buildService();
+        await pullService.run();
+    }
+}
+exports.default = Pull;

package/dist/commands/wpt-launcher.d.ts

@@ -0,0 +1,21 @@
+import { Command } from '@oclif/core';
+export default class WptLauncher extends Command {
+    static description: string;
+    static args: {
+        urls: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        testId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        cookies: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        mobile: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    static localhostUrl: string;
+    run(): Promise<void>;
+    isMobile(mobile: string): boolean;
+    getViewPortSize(isMobile: boolean): string;
+    allResourceUrls(urls: string): Array<string>;
+    getResourceOrigin(urlsArr: Array<string>): string;
+    postScript(script: string): Promise<{}>;
+}

package/dist/commands/wpt-launcher.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const core_2 = require("@oclif/core");
+const cli_parameters_1 = require("../models/cli-parameters");
+const logging_helper_1 = require("../helpers/logging-helper");
+const fetch = require('node-fetch');
+class WptLauncher extends core_1.Command {
+    static description = 'Analyze the performance impact that Speed Kit has compared to the original version.';
+    static args = {
+        [cli_parameters_1.CLIParameters.Urls]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.Urls,
+            required: true, // make the arg required with `required: true`
+        }),
+        [cli_parameters_1.CLIParameters.TestId]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.TestId,
+            required: true, // make the arg required with `required: true`
+        }),
+    };
+    static flags = {
+        [cli_parameters_1.CLIParameters.Cookies]: core_1.Flags.string({ default: '', char: cli_parameters_1.CLIParametersChar.Cookies }),
+        [cli_parameters_1.CLIParameters.Mobile]: core_1.Flags.string({ default: 'no', char: cli_parameters_1.CLIParametersChar.Mobile }),
+        [cli_parameters_1.CLIParameters.Group]: core_1.Flags.string({ default: 'A', char: cli_parameters_1.CLIParametersChar.Group }),
+    };
+    static examples = [
+        `$ sk wpt-launcher <${cli_parameters_1.CLIParameters.Urls}> <${cli_parameters_1.CLIParameters.TestId}> -${cli_parameters_1.CLIParametersChar.Group} <${cli_parameters_1.CLIParameters.Group}> -${cli_parameters_1.CLIParametersChar.Mobile} <${cli_parameters_1.CLIParameters.Mobile}> -${cli_parameters_1.CLIParametersChar.Cookies} <${cli_parameters_1.CLIParameters.Cookies}>`,
+        `$ sk wpt-launcher ${cli_parameters_1.CLIParametersExample.Urls} ${cli_parameters_1.CLIParametersExample.TestId} -${cli_parameters_1.CLIParametersChar.Group} ${cli_parameters_1.CLIParametersExample.Group} -${cli_parameters_1.CLIParametersChar.Mobile} ${cli_parameters_1.CLIParametersExample.Mobile} -${cli_parameters_1.CLIParametersChar.Cookies} ${cli_parameters_1.CLIParametersExample.Cookies}`,
+    ];
+    static localhostUrl = 'http://localhost:8888/orange.html';
+    async run() {
+        const { args: { urls, testId }, flags: { group, mobile, cookies } } = await this.parse(WptLauncher);
+        const resourceOrigin = this.getResourceOrigin(this.allResourceUrls(urls));
+        let script = `setViewportSize ${this.getViewPortSize(this.isMobile(mobile))}
+                    navigate ${resourceOrigin}/wrapper-sw.js
+                    setCookie ${resourceOrigin}/ ${cookies}
+                    exec localStorage.setItem('baqend-speedkit-ab-test-info', encodeURIComponent(JSON.stringify({group:${group},testId:${testId})));
+                    navigate ${resourceOrigin}
+                    navigate ${WptLauncher.localhostUrl}`;
+        this.allResourceUrls(urls).forEach(url => {
+            script += `\n navigate ${url}`;
+        });
+        const postscript = await this.postScript(script);
+        const currentTestIdUrl = `http://wpt.baqend.com/results.php?test=${postscript.wptTestId}`;
+        if (!currentTestIdUrl) {
+            (0, logging_helper_1.logError)('Getting testId failed, ' + currentTestIdUrl);
+            core_2.ux.exit(1);
+        }
+        this.log('testUrl: ', currentTestIdUrl);
+        core_2.ux.exit(0);
+    }
+    // ---------------------- services----------------
+    isMobile(mobile) {
+        return mobile === 'y' || mobile === 'Y' || mobile === 'yes' || mobile === 'Yes' || mobile === 'YES';
+    }
+    getViewPortSize(isMobile) {
+        if (isMobile) {
+            return '375 667'; // mobile
+        }
+        return '1500 1300'; // desktop
+    }
+    allResourceUrls(urls) {
+        const urlsArr = urls.split(',');
+        if (urlsArr.length > 0) {
+            return urlsArr;
+        }
+        // eslint-disable-next-line unicorn/error-message
+        throw new Error('urls must not be null');
+    }
+    getResourceOrigin(urlsArr) {
+        return new URL(urlsArr[0]).origin;
+    }
+    // ---------------- wpt launcher --------------------------
+    async postScript(script) {
+        const urlPath = 'https://makefast.app.baqend.com/v1/code/testAPI';
+        const res = await fetch(urlPath, { body: JSON.stringify({ script }), method: 'POST' });
+        return res.json();
+    }
+}
+exports.default = WptLauncher;

package/dist/helpers/CustomerConfig.d.ts

@@ -0,0 +1,51 @@
+import { InstallConfigs } from '../models/install';
+export declare const SPEED_KIT_INSTALL_PATH: string;
+export declare const INSTALLATION_PROPERTIES: InstallConfigs<string>;
+type Params = {
+    [param: string]: any;
+};
+type MultiConfigParams = {
+    [configName: string]: Params;
+};
+export declare class CustomerConfig implements InstallConfigs<ConfigFile | null> {
+    readonly name: string;
+    readonly domain: string;
+    readonly config: ConfigFile | null;
+    readonly app?: string;
+    readonly appDomain: string;
+    readonly dynamicFetcher: ConfigFile | null;
+    readonly dynamicFetcherConfig: ConfigFile | null;
+    readonly customStyle: ConfigFile | null;
+    readonly custom: ConfigFile | null;
+    readonly sw: ConfigFile | null;
+    readonly loader: ConfigFile | null;
+    readonly documentHandler: ConfigFile | null;
+    readonly documentHandlerConfig: ConfigFile | null;
+    readonly popConfig: ConfigFile | null;
+    readonly installPath: string;
+    readonly installParams?: string;
+    readonly forceInstall: boolean;
+    readonly bypassDeactivation: boolean;
+    readonly scope: string;
+    readonly swPath: string;
+    readonly origins?: string[];
+    readonly chromeFlags: string[];
+    readonly globalWhitelist: ConfigFile;
+    readonly globalBlacklist: ConfigFile;
+    static loadConfig(dir: string): Promise<MultiConfigParams | Params>;
+    static loadCustomer(dir: string, configName: string): Promise<CustomerConfig>;
+    constructor(params: Params, configFiles: InstallConfigs<ConfigFile | null> & {
+        globalWhitelist: any;
+        globalBlacklist: any;
+        popConfig: any;
+    });
+}
+export declare class ConfigFile {
+    readonly filePath: string;
+    readonly name: string;
+    static loadFile(basePath: string, ...alternativeFileNames: string[]): Promise<ConfigFile | null>;
+    static isConfigFile(value: unknown): value is ConfigFile;
+    constructor(filePath: string, name: string);
+    readContent(): Promise<string>;
+}
+export {};

package/dist/helpers/CustomerConfig.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigFile = exports.CustomerConfig = exports.INSTALLATION_PROPERTIES = exports.SPEED_KIT_INSTALL_PATH = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const isFile_1 = require("./isFile");
+const promises_1 = require("fs/promises");
+const logging_helper_1 = require("./logging-helper");
+exports.SPEED_KIT_INSTALL_PATH = '/speed-kit-install.js';
+const CUSTOMER_CONFIG_BASENAME = 'config_customer.js';
+const SK_CONFIG = 'config_SpeedKit.js';
+const RUM_CONFIG = 'config_loadHandler.js';
+const DF_CONFIG = 'config_dynamicBlocks.js';
+const DF_STYLES_BASENAME = 'config_dynamicStyles.css';
+const DOCUMENT_HANDLER_CONFIG = 'config_documentHandler.js';
+const CUSTOM_LOADER = 'custom_loader.js';
+const CUSTOM_SERVICE_WORKER = 'custom_sw.js';
+const CUSTOM_DOCUMENT_HANDLER = 'custom_documentHandler.js';
+const CUSTOM_DYNAMIC_FETCHER = 'custom_dynamicFetcher.js';
+exports.INSTALLATION_PROPERTIES = {
+    config: SK_CONFIG,
+    custom: RUM_CONFIG,
+    sw: CUSTOM_SERVICE_WORKER,
+    loader: CUSTOM_LOADER,
+    dynamicFetcher: CUSTOM_DYNAMIC_FETCHER,
+    dynamicFetcherConfig: DF_CONFIG,
+    documentHandler: CUSTOM_DOCUMENT_HANDLER,
+    documentHandlerConfig: DOCUMENT_HANDLER_CONFIG,
+    customStyle: DF_STYLES_BASENAME,
+};
+function required(check, params, name) {
+    if (check(params[name])) {
+        return params[name];
+    }
+    throw new TypeError(`Please provide a ${check.name.substring(2)} "${name}" property.`);
+}
+function optional(check, params, name, defaultValue = null) {
+    if (check(params[name])) {
+        return params[name];
+    }
+    if (typeof params[name] === 'undefined' || params[name] === null) {
+        return defaultValue;
+    }
+    throw new TypeError(`Property "${name}" must be a ${check.name.substring(2)}.`);
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+class CustomerConfig {
+    name;
+    domain;
+    config;
+    app;
+    appDomain;
+    dynamicFetcher;
+    dynamicFetcherConfig;
+    customStyle;
+    custom;
+    sw;
+    loader;
+    documentHandler;
+    documentHandlerConfig;
+    popConfig;
+    installPath;
+    installParams;
+    forceInstall;
+    bypassDeactivation;
+    scope;
+    swPath;
+    origins;
+    chromeFlags;
+    globalWhitelist;
+    globalBlacklist;
+    static async loadConfig(dir) {
+        const mainConfig = await ConfigFile.loadFile(dir, CUSTOMER_CONFIG_BASENAME);
+        if (!mainConfig) {
+            throw new Error(`Could not find customer config file "${CUSTOMER_CONFIG_BASENAME}".`);
+        }
+        return require(mainConfig.filePath);
+    }
+    static async loadCustomer(dir, configName) {
+        const customerConfig = await this.loadConfig(dir);
+        let params;
+        if (configName in customerConfig) {
+            params = customerConfig[configName];
+        }
+        else {
+            (0, logging_helper_1.logWarning)('Use legacy customer config loading format.');
+            (0, logging_helper_1.logWarning)('Make sure to export the different app configs under their config names like:');
+            (0, logging_helper_1.logWarning)('module.exports = { production, staging }');
+            params = customerConfig;
+        }
+        const configs = {};
+        for (const [key, path] of Object.entries(exports.INSTALLATION_PROPERTIES)) {
+            configs[key] = await ConfigFile.loadFile(dir, path, path.replace('.js', '.es6'));
+        }
+        // Parse config
+        return new CustomerConfig({ name: configName, ...params }, {
+            ...configs,
+            popConfig: await ConfigFile.loadFile(dir, 'config_pops.js'),
+            globalWhitelist: await ConfigFile.loadFile(dir, '../../rules/global-whitelist.js'),
+            globalBlacklist: await ConfigFile.loadFile(dir, '../../rules/global-blacklist.js'),
+        });
+    }
+    constructor(params, configFiles) {
+        this.domain = required(isString, params, 'domain');
+        this.name = optional(isString, params, 'name');
+        this.swPath = optional(isString, params, 'swPath', '/wrapper-sw.js');
+        this.app = optional(isString, params, 'app');
+        this.appDomain = optional(isString, params, 'appDomain', '*.app.baqend.com');
+        this.chromeFlags = optional(Array.isArray, params, 'chromeFlags', []);
+        this.installPath = optional(isString, params, 'installPath', exports.SPEED_KIT_INSTALL_PATH);
+        const scope = optional(isString, params, 'scope', '/');
+        this.scope = scope + (scope.endsWith('/') ? '' : '/');
+        this.origins = optional(Array.isArray, params, 'origins', []);
+        this.installParams = optional(isString, params, 'installParams', 'async crossorigin="anonymous"');
+        this.forceInstall = optional(isBoolean, params, 'forceInstall', false);
+        this.bypassDeactivation = optional(isBoolean, params, 'bypassDeactivation', true);
+        // Assign Config Files
+        Object.assign(this, configFiles);
+    }
+}
+exports.CustomerConfig = CustomerConfig;
+class ConfigFile {
+    filePath;
+    name;
+    static async loadFile(basePath, ...alternativeFileNames) {
+        for (const fileName of alternativeFileNames) {
+            const filePath = path_1.default.resolve(basePath, fileName);
+            if (await (0, isFile_1.isFile)(filePath)) {
+                return new ConfigFile(filePath, fileName);
+            }
+        }
+        return null;
+    }
+    static isConfigFile(value) {
+        return value instanceof ConfigFile;
+    }
+    constructor(filePath, name) {
+        this.filePath = filePath;
+        this.name = name;
+    }
+    async readContent() {
+        return (0, promises_1.readFile)(this.filePath, 'utf-8');
+    }
+}
+exports.ConfigFile = ConfigFile;

package/dist/helpers/build-query-helper.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Returns the whitelisted filter as a sql query string.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+export declare function getWhitelistedFilter(parsedConfig: any): string;
+/**
+ * Returns the blacklisted filter as a SQL query string.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+export declare function getBlacklistedFilter(parsedConfig: any): string;
+/**
+ * Returns the parameter filter as a SQL query string.
+ *
+ * @param params - The stripped parameters that are named within the speed kit config.
+ * @param skConfigVersion - The Speed Kit config ruleset version.
+ */
+export declare function getParameterFilter(params: (string | RegExp)[], skConfigVersion?: number): string;
+/**
+ * Returns the parameter replace (regexp_replace) as a SQL query string.
+ *
+ * @param params - The stripped parameters that are named within the speed kit config.
+ * @param skConfigVersion - The Speed Kit config ruleset version.
+ */
+export declare function getParameterReplaceFilter(params: (string | RegExp)[], skConfigVersion?: number): string;
+/**
+ * Returns the stripped parameters that are named within the speed kit config.
+ *
+ * @param parsedConfig - The speed kit config parsed as an object.
+ */
+export declare function getStrippedParams(parsedConfig: any): (string | RegExp)[];