@speedkit/cli 2.4.1

package/dist/commands/generate-pop-config.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const cli_1 = require("baqend/cli");
+const promises_1 = require("node:fs/promises");
+const file_helper_1 = require("../helpers/file-helper");
+const cli_parameters_1 = require("../models/cli-parameters");
+const athena_service_1 = require("../services/athena-service");
+const cli_2 = require("../services/cli");
+const config_api_service_1 = tslib_1.__importDefault(require("../services/config-api-service"));
+const diff_service_1 = require("../services/diff-service");
+const POP_REMAPPING = {
+    HHN: 'FRA',
+};
+const SHIELDS = [
+    { condition: () => true, pop: 'FRA', shield: 'Default Shield' },
+    { condition: ({ region }) => region.startsWith('US'), pop: 'LGA', shield: 'United States Shield' },
+    { condition: ({ region }) => region.startsWith('SA'), pop: 'GRU', shield: 'South America Shield' },
+    { condition: ({ region }) => region.startsWith('APAC'), pop: 'SYD', shield: 'APAC Shield' },
+    { condition: ({ pop }) => ['KUL', 'QPG'].includes(pop), pop: 'QPG', shield: 'Singapore Shield' },
+    { condition: ({ pop }) => ['HKG', 'ICN', 'MNL'].includes(pop), pop: 'HKG', shield: 'Hongkong Shield' },
+    { condition: ({ region }) => region === 'Asia-South', pop: 'DEL', shield: 'Asia South Shield' },
+    { condition: ({ region }) => region === 'North-America', pop: 'YYZ', shield: 'North America Shield' },
+    { condition: ({ pop }) => ['DXB', 'FJR'].includes(pop), pop: 'FJR', shield: 'United Arab Emirates Shield' },
+    { condition: ({ region }) => region === 'South-Africa', pop: 'JNB', shield: 'South Africa Shield' },
+];
+const percentageFormatter = new Intl.NumberFormat('en-US', { minimumFractionDigits: 1, style: 'percent' });
+class GeneratePopConfig extends core_1.Command {
+    static args = {
+        [cli_parameters_1.CLIParameters.AppName]: core_1.Args.string({
+            description: 'The customers appName',
+            hidden: false,
+            name: cli_parameters_1.CLIParameters.AppName,
+            required: true, // make the arg required with `required: true`
+        }),
+    };
+    static description = 'Generate a pop config for the given app';
+    static examples = [
+        `$ sk generate-pop-config <${cli_parameters_1.CLIParameters.AppName}>`,
+        `$ sk generate-pop-config --use-rum <${cli_parameters_1.CLIParameters.AppName}>`,
+        '$ sk generate-pop-config --coverage 95 appName',
+        '$ sk generate-pop-config --no-deploy appName',
+        '$ sk generate-pop-config --deploy appName',
+        '$ sk generate-pop-config --coverage 95 --pop-limit 6 --traffic-share 2 --deploy appName',
+    ];
+    static flags = {
+        coverage: core_1.Flags.integer({ char: 'c', default: 95, description: 'The percentage of traffic which should be covered through prewarming.' }),
+        deploy: core_1.Flags.boolean({ allowNo: true, char: 'd', description: 'Default it diffs with the deployed config and ask for deployment. If the flag is passed deployment will be skipped or forced.' }),
+        'pop-limit': core_1.Flags.integer({ char: 'p', default: 5, description: 'The maximal pop count which should prewarmed.' }),
+        'traffic-share': core_1.Flags.integer({ char: 't', default: 5, description: 'The minimum traffic share in percent a pop must have to be actually prewarmed.' }),
+        'use-rum': core_1.Flags.boolean({ char: 'r', default: false, description: 'Compute the pop statistics based on RUM. Otherwise the real Speed Kit traffic is used.' }),
+    };
+    async createPopPrewarmingCode(popConfig) {
+        const revalidationTemplate = await (0, file_helper_1.readLocalFile)(__dirname, '../templates/speedKit.Revalidated.js');
+        const pops = await (0, file_helper_1.readLocalFile)(__dirname, '../templates/pops.js');
+        popConfig = pops + popConfig;
+        return revalidationTemplate.replace('{{config}}', popConfig);
+    }
+    async deployPrewarmingConfig(app, config, deploy) {
+        const moduleName = 'speedKit.Revalidated';
+        const db = await cli_1.account.login({ app });
+        const configService = new config_api_service_1.default(db, app);
+        const cliService = new cli_2.CliServiceFactory().getService();
+        const diffService = new diff_service_1.DiffService(cliService);
+        const popPrewarmingCode = await this.createPopPrewarmingCode(config);
+        const popPrewarmingCodePath = await diffService.writeContentToTemporalFile(`generated_${moduleName}`, popPrewarmingCode);
+        const remoteConfig = await configService.getRemoteModule(moduleName);
+        const doDeploy = deploy ?? await diffService.shouldDeployModule(moduleName, remoteConfig, popPrewarmingCodePath);
+        if (doDeploy) {
+            const content = await (0, promises_1.readFile)(popPrewarmingCodePath, { encoding: 'utf8' });
+            await configService.saveRemoteModule(content, moduleName);
+            this.log(`Changes for module ${moduleName} were updated successfully`);
+        }
+    }
+    async run() {
+        const { args: { app }, flags: { coverage, deploy, 'pop-limit': popLimit, 'traffic-share': minimalShare, 'use-rum': useRum } } = await this.parse(GeneratePopConfig);
+        const athenaService = new athena_service_1.AthenaService();
+        const result = await athenaService.getUsedPopsPerOrigin(app, useRum);
+        const originStats = this.generateOriginStats(result)
+            .filter(stats => stats.hits > 1000);
+        this.printStats(originStats, coverage / 100, minimalShare / 100, popLimit);
+        const popConfig = this.generatePopConfig(originStats, coverage / 100, minimalShare / 100, popLimit);
+        await this.deployPrewarmingConfig(app, popConfig, deploy);
+    }
+    byHitsDesc(a, b) {
+        return b.hits - a.hits;
+    }
+    computeCoverageAndShare(totalHits, segmentedStats) {
+        segmentedStats = segmentedStats.sort(this.byHitsDesc);
+        let segmentHits = 0;
+        return segmentedStats.map(segment => {
+            segmentHits += segment.hits;
+            return { ...segment, coverage: segmentHits / totalHits, share: segment.hits / totalHits };
+        });
+    }
+    generateOriginStats(result) {
+        const originStats = {};
+        for (let { hits, origin, pop, region } of result) {
+            pop = POP_REMAPPING[pop] ?? pop;
+            const shieldInfo = this.getShieldInfo(region, pop);
+            const stats = originStats[origin] = originStats[origin] ?? {
+                hits: 0,
+                origin,
+                pops: {},
+                regions: {},
+                shields: {},
+            };
+            stats.hits += hits;
+            const regionStats = stats.regions[region] = stats.regions[region] ?? { hits: 0, region };
+            regionStats.hits += hits;
+            const shieldStats = stats.shields[shieldInfo.shield] = stats.shields[shieldInfo.shield] ?? { ...shieldInfo, hits: 0 };
+            shieldStats.hits += hits;
+            const popStats = stats.pops[pop] = stats.pops[pop] ?? { hits: 0, pop, region, shield: shieldInfo.pop };
+            popStats.hits += hits;
+        }
+        return Object.values(originStats).map(stats => ({
+            hits: stats.hits,
+            origin: stats.origin,
+            pops: this.computeCoverageAndShare(stats.hits, Object.values(stats.pops)),
+            regions: this.computeCoverageAndShare(stats.hits, Object.values(stats.regions)),
+            shields: this.computeCoverageAndShare(stats.hits, Object.values(stats.shields)),
+        })).sort(this.byHitsDesc);
+    }
+    generatePopConfig(originStats, coverage, minimalShare, popLimit) {
+        const originConfigs = { DEFAULT: [] };
+        for (const originStat of originStats) {
+            originConfigs[originStat.origin] = this.generatePrewarmingConfig(originStat, coverage, minimalShare, popLimit).pops
+                .map(pop => 'POP.' + pop);
+        }
+        const serializedConfig = JSON.stringify(originConfigs, null, '  ')
+            .replaceAll(/"(POP.*?)"/g, '$1')
+            .replaceAll(/\[(.*?)]/gs, match => match.replaceAll(/\s+/gs, ' '));
+        return `/* global POP */
+/** @type PopConfig */
+const ORIGIN_POPS = ${serializedConfig}`;
+    }
+    generatePopListByPops(originStat, coverage, minimalShare) {
+        const pops = [];
+        let edgeCoverage = 0;
+        for (const popStats of originStat.pops) {
+            pops.push(popStats.pop);
+            edgeCoverage += popStats.share;
+            if (popStats.coverage >= coverage || popStats.share < minimalShare)
+                break;
+        }
+        return { edgeCoverage, pops, requiresShielding: false };
+    }
+    generatePopListByShields(originStat, coverage, minimalShare, popLimit) {
+        const pops = [];
+        let edgeCoverage = 0;
+        let shieldCoverage = 0;
+        for (const shieldStats of originStat.shields) {
+            // if we are pre warming the shield through an edge pop we increase the edge coverage of the edge and the shield pop
+            const shieldPop = originStat.pops.find(pop => pop.pop === shieldStats.pop);
+            edgeCoverage += shieldPop?.share ?? 0; // in the case the shield pop does not receive any direct traffic
+            shieldCoverage += shieldStats.share;
+            let { pop } = shieldStats;
+            // We try to use the top edge pop of the shield, if that pop still has enough traffic
+            const bestEdgePopOfShield = originStat.pops.find(popStats => popStats.shield == pop && popStats.pop != pop && popStats.share > minimalShare);
+            if (bestEdgePopOfShield) {
+                edgeCoverage += bestEdgePopOfShield.share;
+                pop = bestEdgePopOfShield.pop;
+            }
+            pops.push(pop);
+            if (shieldStats.coverage >= coverage)
+                break;
+        }
+        for (const pop of originStat.pops) {
+            if (pops.length < popLimit // when the shield pre warming list is short, we can add additional big traffic pops
+                && pop.share > minimalShare && !pops.includes(pop.pop) && pop.shield != pop.pop) {
+                pops.push(pop.pop);
+                edgeCoverage += pop.share;
+            }
+        }
+        return { edgeCoverage, pops, requiresShielding: true, shieldCoverage };
+    }
+    generatePrewarmingConfig(originStat, coverage, minimalShare, popLimit) {
+        // Use shields if we need to prewar more than 5 pops to achieve the coverage
+        const useShieldPrewarming = originStat.pops[popLimit - 1]?.coverage < coverage;
+        if (useShieldPrewarming) {
+            return this.generatePopListByShields(originStat, coverage, minimalShare, popLimit);
+        }
+        return this.generatePopListByPops(originStat, coverage, minimalShare);
+    }
+    getShieldInfo(region, pop) {
+        let s;
+        for (const shield of SHIELDS) {
+            if (shield.condition({ pop, region })) {
+                s = shield;
+            }
+        }
+        return { pop: s.pop, shield: s.shield };
+    }
+    printStats(originStats, coverage, minimalShare, popLimit) {
+        let shieldingRequired = false;
+        for (const originStat of originStats) {
+            this.log(`${originStat.origin} ${originStat.hits}`);
+            this.log('  Regions:');
+            for (const regionStats of originStat.regions) {
+                this.log(`    ${regionStats.region} ${regionStats.hits} ${percentageFormatter.format(regionStats.coverage)}`);
+                if (regionStats.coverage >= coverage || regionStats.share < minimalShare)
+                    break;
+            }
+            this.log('  Shields:');
+            for (const shieldStats of originStat.shields) {
+                this.log(`    ${shieldStats.shield} (${shieldStats.pop}) ${shieldStats.hits} ${percentageFormatter.format(shieldStats.coverage)}`);
+                if (shieldStats.coverage >= coverage || shieldStats.share < minimalShare)
+                    break;
+            }
+            this.log('  Pops:');
+            for (const popStats of originStat.pops) {
+                this.log(`    ${popStats.pop} ${popStats.hits} ${percentageFormatter.format(popStats.coverage)} - shield: ${popStats.shield}`);
+                if (popStats.coverage >= coverage || popStats.share < minimalShare)
+                    break;
+            }
+            const config = this.generatePrewarmingConfig(originStat, coverage, minimalShare, popLimit);
+            this.log('  --------------------');
+            if (config.requiresShielding)
+                this.log('  Final shield coverage: ' + percentageFormatter.format(config.shieldCoverage));
+            this.log('  Final edge coverage:   ' + percentageFormatter.format(config.edgeCoverage));
+            this.log('  Final pop list:        ' + config.pops.join(', '));
+            this.log('');
+            shieldingRequired ||= config.requiresShielding;
+        }
+        if (shieldingRequired) {
+            this.warn('The prewarming configuration needs enabled shielding to work properly!');
+        }
+    }
+}
+exports.default = GeneratePopConfig;

package/dist/commands/login.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class Login extends Command {
+    static description: string;
+    static args: {
+        app: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    private createLoginTokenFileIfNotExists;
+}

package/dist/commands/login.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const cli_1 = require("baqend/cli");
+const cli_parameters_1 = require("../models/cli-parameters");
+const node_fs_1 = require("node:fs");
+const path_1 = tslib_1.__importDefault(require("path"));
+class Login extends core_1.Command {
+    static description = 'Login to your app';
+    static args = {
+        [cli_parameters_1.CLIParameters.AppName]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.AppName,
+            required: false,
+            default: 'bbq',
+            description: 'The customers appName', // help description
+        }),
+    };
+    static examples = [
+        `$ sk login <${cli_parameters_1.CLIParameters.AppName}>`,
+        '$ sk login appName',
+    ];
+    async run() {
+        const { app } = (await this.parse(Login)).args;
+        this.createLoginTokenFileIfNotExists();
+        await cli_1.account.persistLogin({ app });
+    }
+    createLoginTokenFileIfNotExists() {
+        if (!(0, node_fs_1.existsSync)(path_1.default.resolve(this.config.home, ".baqend"))) {
+            (0, node_fs_1.writeFileSync)(path_1.default.resolve(this.config.home, ".baqend"), "{}");
+            (0, node_fs_1.writeFileSync)("~/.baqend", "{}");
+        }
+    }
+}
+exports.default = Login;

package/dist/commands/onboarding.d.ts

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

package/dist/commands/onboarding.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const cli_parameters_1 = require("../models/cli-parameters");
+const onboarding_1 = require("../services/onboarding");
+const cli_config_1 = require("../helpers/cli-config");
+class Onboarding extends core_1.Command {
+    static description = 'Start a local dev environment for building and testing the Speed Kit configuration';
+    static flags = {
+        ...cli_parameters_1.CLI_CONFIG_NAME,
+        'local': core_1.Flags.boolean({ char: 'l', default: false, description: 'Run with local documentHandler' }),
+        'verboseLevel': core_1.Flags.boolean({ char: 'v', default: false, description: 'Show all messages' }),
+    };
+    static args = cli_parameters_1.CLI_CUSTOMER_CONFIG;
+    static examples = [
+        `$ sk onboarding <${cli_parameters_1.CLIParameters.CustomerPath}> -${cli_parameters_1.CLIParametersChar.ConfigName} <${cli_parameters_1.CLIParameters.ConfigName}>`,
+        `$ sk onboarding ${cli_parameters_1.CLIParametersExample.CustomerPath} -${cli_parameters_1.CLIParametersChar.ConfigName} ${cli_parameters_1.CLIParametersExample.ConfigName}`,
+    ];
+    async run() {
+        const { args: { customerPath }, flags: { configName, local, verboseLevel } } = await this.parse(Onboarding);
+        const service = await new onboarding_1.OnboardingServiceFactory(new onboarding_1.OnboardingContext(customerPath, configName, local, verboseLevel), new cli_config_1.CliConfig(this.config).load()).getService();
+        await service.run();
+    }
+}
+exports.default = Onboarding;

package/dist/commands/param-diff.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+import { CliService } from "../services/cli";
+export default class ParamDiff extends Command {
+    cli: CliService;
+    static description: string;
+    static args: {
+        pageUrl: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        hideDiff: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    constructor(argv: string[], config: any);
+    logError(message: any): void;
+    run(): Promise<void>;
+}

package/dist/commands/param-diff.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const scrape_1 = tslib_1.__importDefault(require("../helpers/scrape"));
+const cli_parameters_1 = require("../models/cli-parameters");
+const cli_1 = require("../services/cli");
+const url = tslib_1.__importStar(require("url"));
+const diff_1 = require("../services/diff");
+const cli_config_1 = require("../helpers/cli-config");
+class ParamDiff extends core_1.Command {
+    cli;
+    static description = 'Shows difference in documents with query parameters on/off';
+    static args = {
+        [cli_parameters_1.CLIParameters.PageUrl]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.PageUrl,
+            required: true,
+            description: 'Link of the page',
+            example: cli_parameters_1.CLIParametersExample.PageUrl
+        })
+    };
+    static flags = {
+        [cli_parameters_1.CLIParameters.HideDiff]: core_1.Flags.boolean({
+            char: cli_parameters_1.CLIParametersChar.HideDiff,
+            description: 'Hide the code diff in IDE code diff window'
+        }),
+    };
+    static examples = [
+        `$ sk prewarm <${cli_parameters_1.CLIParameters.PageUrl}> -${cli_parameters_1.CLIParametersChar.HideDiff}`,
+        `$ sk prewarm ${cli_parameters_1.CLIParametersExample.PageUrl} -${cli_parameters_1.CLIParametersChar.HideDiff}`,
+    ];
+    constructor(argv, config) {
+        super(argv, config);
+        this.cli = new cli_1.CliServiceFactory().getService();
+    }
+    logError(message) {
+        this.cli.spacer();
+        this.cli.writeError(message);
+        this.cli.exit(1);
+    }
+    async run() {
+        const { args, flags } = await this.parse(ParamDiff);
+        const { pageUrl: originalUrl } = args;
+        const originalData = await (0, scrape_1.default)(originalUrl);
+        if (!originalData) {
+            this.logError('Failed to fetch original document');
+        }
+        const parsedUrl = url.parse(originalUrl, true);
+        const withoutAnyParamsUrl = url.format({
+            protocol: parsedUrl.protocol,
+            host: parsedUrl.host,
+            pathname: parsedUrl.pathname,
+        });
+        const withoutAnyParamsData = await (0, scrape_1.default)(withoutAnyParamsUrl);
+        if (!withoutAnyParamsData) {
+            this.logError('Failed to fetch document without any params');
+        }
+        const userConfig = new cli_config_1.CliConfig(this.config).load();
+        const context = new diff_1.DiffContext(userConfig.diffExec, userConfig.diffExecTemplate);
+        const diffService = new diff_1.DiffServiceFactory(context).getService();
+        const originalFilePath = await diffService.writeContentToTemporalFile('original.html', originalData);
+        const withoutAnyParamsFilePath = await diffService.writeContentToTemporalFile('without-any-params.html', withoutAnyParamsData);
+        this.cli.spacer();
+        this.cli.write(`Checking any parameter...`);
+        this.cli.write(`- with: ${originalUrl}`);
+        this.cli.write(`- without: ${withoutAnyParamsUrl}`);
+        const isEqual = await diffService.executeDiff(originalFilePath, withoutAnyParamsFilePath, flags.hideDiff);
+        if (isEqual) {
+            this.cli.writeSuccess(`✅ No diff found`);
+            return;
+        }
+        this.cli.writeWarning('⚠️ Found diff');
+        // If there is more than one query params given &
+        // there's a difference in the general check, do a detailed check:
+        if (Object.keys(parsedUrl.query).length === 1)
+            return;
+        for (let param in parsedUrl.query) {
+            const withoutCurrentParamQuery = { ...parsedUrl.query };
+            delete withoutCurrentParamQuery[param]; // Remove the current parameter
+            const withoutCurrentParamUrl = url.format({
+                protocol: parsedUrl.protocol,
+                host: parsedUrl.host,
+                pathname: parsedUrl.pathname,
+                query: withoutCurrentParamQuery
+            });
+            const withoutCurrentParamData = await (0, scrape_1.default)(withoutCurrentParamUrl);
+            if (!withoutCurrentParamData) {
+                this.logError(`Failed to fetch document without "${param}" parameter`);
+            }
+            const withoutCurrentParamFilePath = await diffService.writeContentToTemporalFile(`without-${param}-param.html`, withoutCurrentParamData);
+            this.cli.spacer();
+            this.cli.write(`Checking "${param}" parameter...`);
+            this.cli.write(`- with: ${originalUrl}`);
+            this.cli.write(`- without: ${withoutCurrentParamUrl}`);
+            const hasSpecificDiff = !await diffService.executeDiff(originalFilePath, withoutCurrentParamFilePath, flags.hideDiff);
+            if (hasSpecificDiff) {
+                const hasDiffWithoutAnyParams = !await diffService.executeDiff(withoutAnyParamsFilePath, withoutCurrentParamFilePath, true);
+                if (hasDiffWithoutAnyParams) {
+                    this.cli.writeWarning('⚠️ Found diff');
+                }
+                else {
+                    this.cli.writeWarning('⚠️ Found diff (identical with having all params removed)');
+                }
+            }
+            else {
+                this.cli.writeSuccess(`✅ No diff found`);
+            }
+        }
+    }
+}
+exports.default = ParamDiff;

package/dist/commands/pop-prewarm.d.ts

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+import { EntityManager } from 'baqend';
+export default class PopPrewarm extends Command {
+    static description: string;
+    static args: {
+        app: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        ips: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        contentTypes: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    getCount(db: EntityManager, contentTypes: string[]): Promise<any>;
+    queryDb(db: EntityManager, contentTypes: string[], lastId?: string): Promise<any>;
+    fetchAssets(db: EntityManager, ips: string[], contentTypes: string[], app: string, progress: any, lastId?: string): Promise<any>;
+}

package/dist/commands/pop-prewarm.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const cli_1 = require("baqend/cli");
+const core_2 = require("@oclif/core");
+const prewarm_service_1 = tslib_1.__importDefault(require("../services/prewarm-service"));
+const cli_parameters_1 = require("../models/cli-parameters");
+const logging_helper_1 = require("../helpers/logging-helper");
+class PopPrewarm extends core_1.Command {
+    static description = 'Pre-warm Fastly PoPs';
+    static args = {
+        [cli_parameters_1.CLIParameters.AppName]: core_1.Args.string({
+            name: cli_parameters_1.CLIParameters.AppName,
+            required: true,
+            description: 'The customers appName',
+            hidden: false, // hide this arg from help
+        }),
+    };
+    static flags = {
+        [cli_parameters_1.CLIParameters.Ips]: core_1.Flags.string({ default: '151.101.120.194', char: cli_parameters_1.CLIParametersChar.Ips }),
+        [cli_parameters_1.CLIParameters.ContentTypes]: core_1.Flags.string({ default: 'image', char: cli_parameters_1.CLIParametersChar.ContentTypes }),
+    };
+    static examples = [
+        `$ sk pop-prewarm <${cli_parameters_1.CLIParameters.AppName}> -${cli_parameters_1.CLIParametersChar.ContentTypes} <${cli_parameters_1.CLIParameters.ContentTypes}> -${cli_parameters_1.CLIParametersChar.Ips} <${cli_parameters_1.CLIParameters.Ips}>`,
+        `$ sk pop-prewarm decathlon -${cli_parameters_1.CLIParametersChar.ContentTypes} ${cli_parameters_1.CLIParametersExample.ContentTypes} -${cli_parameters_1.CLIParametersChar.Ips} ${cli_parameters_1.CLIParametersExample.Ips}`,
+    ];
+    async run() {
+        const { args: { app }, flags: { ips, contentTypes } } = await this.parse(PopPrewarm);
+        const db = await cli_1.account.login({ app });
+        const contentTypeArr = contentTypes.split(',');
+        const ipsArr = ips.split(',');
+        const count = await this.getCount(db, contentTypeArr);
+        const progress = core_2.ux.progress();
+        progress.start(count * ips.length, 0);
+        await this.fetchAssets(db, ipsArr, contentTypeArr, app, progress);
+        progress.stop();
+    }
+    async getCount(db, contentTypes) {
+        return db['speedKit.Asset'].find().in('contentType', contentTypes).count();
+    }
+    async queryDb(db, contentTypes, lastId = '') {
+        let qb = db['speedKit.Asset'].find().in('contentType', contentTypes);
+        if (lastId) {
+            qb = qb.gt('id', lastId);
+        }
+        return qb.limit(100).sort({ id: 1 }).resultList();
+    }
+    async fetchAssets(db, ips, contentTypes, app, progress, lastId = '') {
+        const resultList = await this.queryDb(db, contentTypes, lastId);
+        if (resultList.length === 0) {
+            return Promise.resolve();
+        }
+        const assetChunks = prewarm_service_1.default.chunk(resultList, 50);
+        let fetches = [];
+        for (const assets of assetChunks) {
+            for (const ip of ips) {
+                for (const asset of assets) {
+                    let { url } = asset;
+                    const { origin, variation, extendedURL } = asset;
+                    url += (extendedURL || '');
+                    fetches.push(prewarm_service_1.default.fetchURLByIp(ip, url, origin, variation, app, db.token));
+                }
+                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 = [];
+            }
+        }
+        db.clear();
+        this.log(resultList[resultList.length - 1].url);
+        return this.fetchAssets(db, ips, contentTypes, app, progress, resultList[resultList.length - 1].id);
+    }
+}
+exports.default = PopPrewarm;

package/dist/commands/prewarm.d.ts

@@ -0,0 +1,40 @@
+import { Command } from '@oclif/core';
+export default class Prewarm extends Command {
+    static description: string;
+    static args: {
+        app: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        variation: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        variationPath: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        delay: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        keepParameterSorting: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static examples: string[];
+    run(): Promise<void>;
+    /**
+     * 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.
+     */
+    prewarmVariations(variations: string[], urls: {
+        url: string;
+        origin: string;
+    }[], app: string, token: string, delay: number, sortParameters: boolean): Promise<void>;
+    loadAssets(path: string, origin?: string): ({
+        url: string;
+        origin: string;
+    } | null)[];
+    /**
+     * Extracts variations line by line from a given file.
+     * @param path - path to the csv containing variations
+     */
+    loadVariations(path: string): (string[]);
+    sleep(ms: any): Promise<unknown>;
+}