@speedkit/cli 4.25.2 → 4.27.0

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

@@ -17,15 +17,26 @@ export class AwsAthenaService {
     }
     async getResult(query, parameters = [], maxAgeInMinutes = DEFAULT_MAX_AGE_IN_MINUTES) {
         this.cli.startAction("ATHENA:QUERY", "execute athena query");
-        const queryId = await this.runQuery(query, parameters, maxAgeInMinutes);
-        const result = await safe(this.fetchResult(queryId));
+        // Everything the action covers is inside the guard, running the query
+        // included: Athena reports a rejected query by failing the execution, and
+        // a throw that escapes here leaves the spinner running — which is a timer,
+        // so the process stays alive with nothing left to do and has to be killed
+        // by hand.
+        const result = await safe(this.runAndFetch(query, parameters, maxAgeInMinutes));
         if (result.success === true) {
             this.cli.successAction("ATHENA:QUERY");
             return result.data;
         }
+        // Rethrown rather than answered with an empty result: no rows and no rows
+        // found look the same to a caller, and a pre-warm list that silently came
+        // back empty is worse than one that failed.
         this.cli.failAction("ATHENA:QUERY");
-        this.cli.writeError(result.error);
-        return [];
+        throw result.errorObj ?? new Error(result.error);
+    }
+    /** The query, from sending it off to the rows it produced. */
+    async runAndFetch(query, parameters, maxAgeInMinutes) {
+        const queryId = await this.runQuery(query, parameters, maxAgeInMinutes);
+        return this.fetchResult(queryId);
     }
     castValueToType(value, type) {
         if (value === null)

package/dist/services/athena/athena-service.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/athena/athena-service.spec.js

@@ -0,0 +1,74 @@
+import { GetQueryResultsCommand, StartQueryExecutionCommand, } from "@aws-sdk/client-athena";
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { AwsAthenaService } from "./athena-service.js";
+/** The cli calls the service makes, in the order it made them. */
+function recordingCli() {
+    const calls = [];
+    const cli = {
+        failAction: (name) => calls.push(`fail:${name}`),
+        startAction: (name) => calls.push(`start:${name}`),
+        successAction: (name) => calls.push(`success:${name}`),
+        writeError: (message) => calls.push(`error:${message}`),
+    };
+    return { calls, cli };
+}
+/** An Athena that answers every execution with the given state. */
+function clientAnswering(state, reason) {
+    return {
+        send: async (command) => {
+            if (command instanceof StartQueryExecutionCommand) {
+                return { QueryExecutionId: "query-1" };
+            }
+            if (command instanceof GetQueryResultsCommand) {
+                return {
+                    ResultSet: {
+                        ResultSetMetadata: {
+                            ColumnInfo: [{ Name: "urls", Type: "bigint" }],
+                        },
+                        Rows: [
+                            { Data: [{ VarCharValue: "urls" }] },
+                            { Data: [{ VarCharValue: "42" }] },
+                        ],
+                    },
+                };
+            }
+            return {
+                QueryExecution: { Status: { State: state, StateChangeReason: reason } },
+            };
+        },
+    };
+}
+describe("AwsAthenaService", () => {
+    it("should return the rows of a query that succeeded", async () => {
+        const { calls, cli } = recordingCli();
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED"), cli);
+        expect(await service.getResult("select 1", [], 0)).to.deep.equal([
+            { urls: 42 },
+        ]);
+        expect(calls).to.deep.equal(["start:ATHENA:QUERY", "success:ATHENA:QUERY"]);
+    });
+    it("should end the action when the query itself failed", async () => {
+        // A failed execution throws from inside the action. Left unhandled it
+        // leaves the spinner running, and the spinner is a timer: the process then
+        // never exits and has to be killed by hand.
+        const { calls, cli } = recordingCli();
+        const service = new AwsAthenaService(clientAnswering("FAILED", "INVALID_ARGUMENTS: nope"), cli);
+        const result = await service
+            .getResult("select 1", [], 0)
+            .then(() => undefined)
+            .catch((error) => error);
+        expect(result).to.be.an("error");
+        expect(result.message).to.contain("INVALID_ARGUMENTS: nope");
+        expect(calls).to.deep.equal(["start:ATHENA:QUERY", "fail:ATHENA:QUERY"]);
+    });
+    it("should not pass a failed query off as an empty result", async () => {
+        const { cli } = recordingCli();
+        const service = new AwsAthenaService(clientAnswering("CANCELLED"), cli);
+        const result = await service
+            .getResult("select 1", [], 0)
+            .then(() => "resolved")
+            .catch(() => "rejected");
+        expect(result).to.equal("rejected");
+    });
+});

package/dist/services/deploy/handler/install-resource-handler.js

@@ -1,6 +1,6 @@
 import { FILE_TYPE, } from "../../integration-api/index.js";
+import { copyToClipboard } from "../../../helpers/clipboard.js";
 import { safe } from "../../../helpers/safe.js";
-import clipboardy from "clipboardy";
 export default class InstallResourceHandler {
     customer;
     configApi;
@@ -67,11 +67,10 @@ export default class InstallResourceHandler {
                 }
                 this.cli.successAction("DEPLOY:ACTIVATE:INSTALL_RESOURCE_TEST");
                 const debugParameter = `?debugSpeedKit=${install.id.split("/").pop()}`;
-                try {
-                    clipboardy.writeSync(debugParameter);
+                if (await copyToClipboard(debugParameter)) {
                     this.cli.writeSuccess("Query parameter to activate the testing installation has been copied to the clipboard 📋");
                 }
-                catch {
+                else {
                     this.cli.writeSuccess(`Use the following parameter to active the testing installation in your browser: ${debugParameter}`);
                 }
             }

package/dist/services/onboarding/onboarding-service-factory.js

@@ -41,7 +41,7 @@ import { ExtensionDownloader } from "./browser/extension/extension-downloader.js
 import { ExecutableValidator } from "./browser/executable/executable-validator.js";
 import { applyOriginProxy, withOriginProxyFlag, } from "../../helpers/origin-proxy.js";
 import { QueryBuilderFactory } from "../query-builder/query-builder-factory.js";
-import { QueryTpe } from "../query-builder/query-builder-model.js";
+import { QueryType } from "../query-builder/query-builder-model.js";
 export class OnboardingServiceFactory {
     context;
     cliConfig;
@@ -155,7 +155,7 @@ export class OnboardingServiceFactory {
             configName: this.context.configName,
             customerPath: this.context.customerPath,
             isWindows: this.cliConfig.runtimeConfig.windows,
-        }, this.cliConfig).buildService(QueryTpe.parameter);
+        }, this.cliConfig).buildService(QueryType.parameter);
         const DiffService = new DiffServiceFactory(new DiffContext(this.cliConfig.diffExec, this.cliConfig.diffExecTemplate)).getService();
         const requestDiffService = new RequestDiffService(DiffService, documentHandler);
         const handlers = [

package/dist/services/pop-config/pop-config-service.d.ts

@@ -3,5 +3,12 @@ import { AthenaService } from "../athena/index.js";
 export declare class PopConfigService {
     private athenaService;
     constructor(athenaService: AthenaService);
-    getUsedPopsPerOrigin(app: string, useRum: boolean): Promise<UsedPopsPerOrigin[]>;
+    /**
+     * The PoPs serving the app's traffic, per origin and region.
+     *
+     * @param useRum - count page-impression beacons instead of Speed Kit's own
+     * asset requests, which is what an app without production traffic needs.
+     * @param days - size of the window to look at, in days.
+     */
+    getUsedPopsPerOrigin(app: string, useRum: boolean, days?: number): Promise<UsedPopsPerOrigin[]>;
 }

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

@@ -1,36 +1,24 @@
 import { AthenaBucket } from "../athena/index.js";
+import { buildPopsQuery } from "../query-builder/queries/index.js";
+/**
+ * How long a result may be reused. The PoP distribution of an app barely
+ * moves within a day, and the query scans a week of request logs.
+ */
+const MAX_AGE_IN_MINUTES = 12 * 60;
 export class PopConfigService {
     athenaService;
     constructor(athenaService) {
         this.athenaService = athenaService;
     }
-    async getUsedPopsPerOrigin(app, useRum) {
-        const query = `
-      with data as (select *,
-                           coalesce('https://' || url_extract_host(assetUrl) ||
-                                    regexp_extract(url_extract_path(assetUrl), '(?i)((/\\w+)?/[a-z]{2}([-/_][a-z]{2})*/)', 0),
-                                    'Unknown') as originWithPrefix
-                    from fastly.logs
-                    where date between ? and ?
-                      and app = ?
-                      and ${useRum ? "ispibeacon" : "isassetrequest and isnavigaterequest"}
-                      and client.bot is null
-                      and origin not in ('Unknown', ''))
-
-      select region,
-             pop,
-             coalesce(originWithPrefix, origin) as origin,
-             count()                            as hits
-      from data
-      group by grouping sets (
-        (region, pop, origin),
-        (region, pop, origin, originWithPrefix)
-        )
-      having originWithPrefix is null or originWithPrefix <> 'Unknown'`;
-        const endDate = new Date();
-        const startDate = new Date(endDate.getFullYear(), endDate.getMonth(), endDate.getDate() - 7);
-        const start = startDate.toISOString().slice(0, 10);
-        const end = endDate.toISOString().slice(0, 10);
-        return await this.athenaService.getResult(query, [start, end, app], 12 * 60, AthenaBucket.FastlyLogs);
+    /**
+     * The PoPs serving the app's traffic, per origin and region.
+     *
+     * @param useRum - count page-impression beacons instead of Speed Kit's own
+     * asset requests, which is what an app without production traffic needs.
+     * @param days - size of the window to look at, in days.
+     */
+    async getUsedPopsPerOrigin(app, useRum, days) {
+        const { parameters, sql } = buildPopsQuery({ app, days, useRum });
+        return await this.athenaService.getResult(sql, parameters, MAX_AGE_IN_MINUTES, AthenaBucket.FastlyLogs);
     }
 }

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

@@ -26,7 +26,7 @@ export declare class AssetApiClient {
      * handle parameter "bqvariation"
      * reflect behaviour of SpeedKit.
      * - do not send default variation
-     * - send mobile/tablet/tv as lowercase
+     * - send mobile/tablet as lowercase
      * - send customVariations as they are
      *
      * As orestes will always make variations uppercase and does not care for caseSensitivity,

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

@@ -1,6 +1,7 @@
 import { URL } from "node:url";
 import http2 from "node:http2";
-import { MAX_REQUESTS_PER_SECOND, DEFAULT_REQUESTS_PER_SECOND, RATE_LIMIT_MULTIPLICATOR, DEFAULT_VARIATIONS, TIMING_HEADER_KEY, } from "../index.js";
+import { MAX_REQUESTS_PER_SECOND, DEFAULT_REQUESTS_PER_SECOND, RATE_LIMIT_MULTIPLICATOR, TIMING_HEADER_KEY, } from "../index.js";
+import { DEVICE_VARIATIONS, } from "../../query-builder/queries/device.js";
 import { normalize } from "../../../helpers/normalize.js";
 import { InvalidOriginError } from "../error/invalid-origin-error.js";
 export class AssetApiClient {
@@ -114,7 +115,7 @@ export class AssetApiClient {
      * handle parameter "bqvariation"
      * reflect behaviour of SpeedKit.
      * - do not send default variation
-     * - send mobile/tablet/tv as lowercase
+     * - send mobile/tablet as lowercase
      * - send customVariations as they are
      *
      * As orestes will always make variations uppercase and does not care for caseSensitivity,
@@ -130,8 +131,8 @@ export class AssetApiClient {
         if (variation === "default" || variation === "desktop") {
             return;
         }
-        // on tv|tablet|mobile set variation as lowerCase
-        if (DEFAULT_VARIATIONS.includes(variation.toLowerCase())) {
+        // on tablet|mobile set variation as lowerCase
+        if (DEVICE_VARIATIONS.includes(variation.toLowerCase())) {
             assetUrl.searchParams.set("bqvariation", variation.toLowerCase());
             return;
         }

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

@@ -1,9 +1,15 @@
 import { UserCliConfig } from "../../helpers/cli-config.js";
+import { QueryFilterOptions } from "../query-builder/query-builder-model.js";
 import { PreWarmService } from "./pre-warm-service.js";
-export interface AutoPreWarmContext {
+export interface AutoPreWarmContext extends QueryFilterOptions {
     readonly customerPath: string;
     readonly configName: string;
-    readonly variation?: string;
+    /** Device classes to warm each url in the variations it was requested in. */
+    readonly device?: readonly string[];
+    /** Regular expressions the pre-warmed urls have to match. */
+    readonly match?: readonly string[];
+    /** Variations to pair every url with, when no traffic can reveal them. */
+    readonly variation?: readonly string[];
     readonly variationPath?: string;
     readonly sortParameters?: boolean;
     readonly quiet?: boolean;
@@ -16,6 +22,10 @@ export interface AutoPreWarmContext {
  * config, builds the prewarm query via {@link QueryBuilderFactory}, runs it
  * against Athena (Baqend native path, AWS fallback), and feeds the resulting
  * URLs straight into the prewarm job.
+ *
+ * `--device` and `--variation` are handed to the query, which returns the
+ * variation alongside every url; without them the query returns urls and the
+ * list is crossed with `--variationPath` or the default variation, as before.
  */
 export declare class AutoPreWarmFactory {
     private context;

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

@@ -1,17 +1,23 @@
 import { CliContext, CliServiceFactory } from "../cli/index.js";
 import { QueryBuilderFactory } from "../query-builder/query-builder-factory.js";
-import { QueryTpe } from "../query-builder/query-builder-model.js";
+import { QueryType, } from "../query-builder/query-builder-model.js";
+import { normalizeDevices } from "../query-builder/queries/device.js";
 import { ConfigApiContext, ConfigApiServiceFactory, } from "../config-api/index.js";
 import { AssetApiClient } from "./assets/asset-api-client.js";
 import { CsvReader } from "./csv-reader.js";
 import { PreWarmService } from "./pre-warm-service.js";
 import { resolveVariations } from "./pre-warm-factory.js";
+import { toPrewarmTargets } from "./prewarm-targets.js";
 /**
  * Wires a {@link PreWarmService} that gets its URLs from a freshly built and
  * executed prewarm query instead of a CSV file. Reads the app from the customer
  * config, builds the prewarm query via {@link QueryBuilderFactory}, runs it
  * against Athena (Baqend native path, AWS fallback), and feeds the resulting
  * URLs straight into the prewarm job.
+ *
+ * `--device` and `--variation` are handed to the query, which returns the
+ * variation alongside every url; without them the query returns urls and the
+ * list is crossed with `--variationPath` or the default variation, as before.
  */
 export class AutoPreWarmFactory {
     context;
@@ -25,18 +31,26 @@ export class AutoPreWarmFactory {
         const queryService = await new QueryBuilderFactory({
             configName: this.context.configName,
             customerPath: this.context.customerPath,
+            days: this.context.days,
+            devices: normalizeDevices(this.context.device),
+            excludeNoindex: this.context.excludeNoindex,
+            excludeSuspicious: this.context.excludeSuspicious,
+            execute: true,
+            hardNavigationsOnly: this.context.hardNavigationsOnly,
             isWindows: this.context.isWindows,
+            match: this.context.match,
             quiet: this.context.quiet,
-            execute: true,
-        }, this.userConfig).buildService(QueryTpe.prewarm);
+            variations: this.context.variation,
+        }, this.userConfig).buildService(QueryType.prewarm);
         const app = queryService.app;
         const rows = await queryService.execute();
-        const urls = rows.map((row) => row.url).filter(Boolean);
         const configApi = new ConfigApiServiceFactory(new ConfigApiContext(app)).getService();
         const entityManager = await configApi.client.getEntityManager();
         const assetApiClient = new AssetApiClient(entityManager.token, app, this.context.sortParameters);
         const csvReader = new CsvReader();
-        const variations = resolveVariations(csvReader, this.context.variation, this.context.variationPath);
-        return new PreWarmService(assetApiClient, cli, urls, variations, this.context.verbose);
+        return new PreWarmService(assetApiClient, cli, toPrewarmTargets(rows.filter((row) => row.url), 
+        // `--variation` was answered by the query already; a variations file
+        // is still applied here.
+        resolveVariations(csvReader, undefined, this.context.variationPath)), this.context.verbose);
     }
 }

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

@@ -1,5 +1,24 @@
+import { PrewarmRow } from "./pre-warm-model.js";
 export declare class CsvReader {
-    readPath(filePath: string): string[];
-    private cleanUpEntries;
+    /**
+     * The pre-warm list of a csv: one url per line, together with the variation
+     * to warm it in where the file names one.
+     *
+     * A second column only carries a variation when the header says so. The file
+     * `sk query prewarm --execute` writes for an unsplit list has the hit count
+     * there, and a list without a header at all is what it always was — bare
+     * urls, all of them to be warmed in whatever variations the caller asks for.
+     */
+    readList(filePath: string): PrewarmRow[];
+    /**
+     * The first column of a csv, for a file that is a plain list of values —
+     * the variations to warm every url in.
+     */
+    readValues(filePath: string): string[];
+    /**
+     * The fields of a csv line. A quoted field is taken as it stands, so a comma
+     * inside a url stays part of it, and its doubled quotes are one quote.
+     */
+    private fields;
     private getEntries;
 }

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

@@ -3,22 +3,84 @@ import path from "node:path";
 import { ReadCsvError } from "./error/read-csv-error.js";
 const ENCODING = "utf8";
 const LINE_BREAK = /\r?\n/;
+/** The header the query command writes above a split pre-warm list. */
+const VARIATION_COLUMN = "variation";
 export class CsvReader {
-    readPath(filePath) {
+    /**
+     * The pre-warm list of a csv: one url per line, together with the variation
+     * to warm it in where the file names one.
+     *
+     * A second column only carries a variation when the header says so. The file
+     * `sk query prewarm --execute` writes for an unsplit list has the hit count
+     * there, and a list without a header at all is what it always was — bare
+     * urls, all of them to be warmed in whatever variations the caller asks for.
+     */
+    readList(filePath) {
         try {
-            const entries = this.getEntries(filePath);
-            return this.cleanUpEntries(entries);
+            const lines = this.getEntries(filePath).map((line) => this.fields(line));
+            const [header] = lines;
+            const hasHeader = header?.[0]?.toLowerCase() === "url";
+            const carriesVariation = hasHeader && header[1]?.toLowerCase() === VARIATION_COLUMN;
+            return (hasHeader ? lines.slice(1) : lines)
+                .filter(([url]) => url)
+                .map(([url, second]) => carriesVariation && second ? { url, variation: second } : { url });
         }
         catch (error) {
             throw new ReadCsvError(error.message);
         }
     }
-    cleanUpEntries(entries) {
-        return entries
-            .map((entry) => {
-            return /^"[^"]+"/.test(entry) ? entry.slice(1, -1) : entry;
-        })
-            .filter(Boolean);
+    /**
+     * The first column of a csv, for a file that is a plain list of values —
+     * the variations to warm every url in.
+     */
+    readValues(filePath) {
+        try {
+            return this.getEntries(filePath)
+                .map((line) => this.fields(line)[0])
+                .filter(Boolean);
+        }
+        catch (error) {
+            throw new ReadCsvError(error.message);
+        }
+    }
+    /**
+     * The fields of a csv line. A quoted field is taken as it stands, so a comma
+     * inside a url stays part of it, and its doubled quotes are one quote.
+     */
+    fields(line) {
+        const entry = line.trim();
+        const fields = [];
+        let field = "";
+        let quoted = false;
+        for (let index = 0; index < entry.length; index++) {
+            const character = entry[index];
+            if (quoted) {
+                if (character !== '"') {
+                    field += character;
+                    continue;
+                }
+                // A doubled quote is one quote; a single one ends the field.
+                if (entry[index + 1] === '"') {
+                    field += '"';
+                    index++;
+                    continue;
+                }
+                quoted = false;
+                continue;
+            }
+            if (character === '"' && field === "") {
+                quoted = true;
+                continue;
+            }
+            if (character === ",") {
+                fields.push(field.trim());
+                field = "";
+                continue;
+            }
+            field += character;
+        }
+        fields.push(field.trim());
+        return fields;
     }
     getEntries(filePath) {
         const fileContent = fs.readFileSync(path.resolve(filePath), ENCODING);

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,75 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { CsvReader } from "./csv-reader.js";
+function write(content) {
+    const file = join(mkdtempSync(join(tmpdir(), "sk-csv-")), "urls.csv");
+    writeFileSync(file, content, "utf8");
+    return file;
+}
+/** The urls of a list, for the cases that say nothing about variations. */
+function read(content) {
+    return readList(content).map(({ url }) => url);
+}
+function readList(content) {
+    return new CsvReader().readList(write(content));
+}
+describe("CsvReader", () => {
+    it("should read a bare list of urls", () => {
+        expect(read("https://a.de/\nhttps://b.de/\n")).to.deep.equal([
+            "https://a.de/",
+            "https://b.de/",
+        ]);
+    });
+    it("should read quoted urls", () => {
+        expect(read('"https://a.de/"\n"https://b.de/"')).to.deep.equal([
+            "https://a.de/",
+            "https://b.de/",
+        ]);
+    });
+    it("should take only the first column", () => {
+        // What `sk query prewarm --execute` writes: url and hit count.
+        expect(read('"url","hits"\n"https://a.de/",12\n"https://b.de/",3')).to.deep.eq(["https://a.de/", "https://b.de/"]);
+    });
+    it("should skip a header row", () => {
+        expect(read("url\nhttps://a.de/")).to.deep.equal(["https://a.de/"]);
+    });
+    it("should keep a comma inside a quoted url", () => {
+        expect(read('"https://a.de/?list=1,2",7')).to.deep.equal([
+            "https://a.de/?list=1,2",
+        ]);
+    });
+    it("should read a doubled quote as one quote", () => {
+        expect(read('"https://a.de/?q=""x"""')).to.deep.equal([
+            'https://a.de/?q="x"',
+        ]);
+    });
+    it("should drop empty lines", () => {
+        expect(read("https://a.de/\n\n\nhttps://b.de/\n")).to.have.lengthOf(2);
+    });
+    it("should read the variation of a split list", () => {
+        // What `sk query prewarm --device desktop,mobile --execute` writes.
+        expect(readList('"url","variation","hits"\n"https://a.de/","mobile",12\n"https://a.de/","desktop",3')).to.deep.equal([
+            { url: "https://a.de/", variation: "mobile" },
+            { url: "https://a.de/", variation: "desktop" },
+        ]);
+    });
+    it("should not read a hit count as a variation", () => {
+        expect(readList('"url","hits"\n"https://a.de/",12')).to.deep.equal([
+            { url: "https://a.de/" },
+        ]);
+    });
+    it("should not read a second column of a headerless list", () => {
+        expect(readList('"https://a.de/","mobile"')).to.deep.equal([
+            { url: "https://a.de/" },
+        ]);
+    });
+    it("should keep a comma inside a quoted url of a split list", () => {
+        expect(readList('url,variation\n"https://a.de/?list=1,2",mobile')).to.deep.equal([{ url: "https://a.de/?list=1,2", variation: "mobile" }]);
+    });
+    it("should read a plain list of values", () => {
+        expect(new CsvReader().readValues(write("desktop\nmobile\n"))).to.deep.equal(["desktop", "mobile"]);
+    });
+});

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

@@ -2,3 +2,4 @@ export * from "./pre-warm-service.js";
 export * from "./pre-warm-factory.js";
 export * from "./auto-pre-warm-factory.js";
 export * from "./pre-warm-model.js";
+export * from "./prewarm-targets.js";

package/dist/services/prewarm/index.js

@@ -2,3 +2,4 @@ export * from "./pre-warm-service.js";
 export * from "./pre-warm-factory.js";
 export * from "./auto-pre-warm-factory.js";
 export * from "./pre-warm-model.js";
+export * from "./prewarm-targets.js";

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

@@ -4,8 +4,6 @@ export declare class PreWarmFactory {
     private context;
     constructor(context: PreWarmContext);
     getService(): Promise<PreWarmService>;
-    private getUrls;
-    private getVariations;
 }
 /**
  * Resolve the list of variations to prewarm: a `variationPath` CSV takes

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

@@ -1,5 +1,5 @@
 import { CliContext, CliServiceFactory } from "../cli/index.js";
-import { DEFAULT_VARIATION, PreWarmService, VARIATION_SEPARATOR, } from "./index.js";
+import { DEFAULT_VARIATION, PreWarmService, toPrewarmTargets, VARIATION_SEPARATOR, } from "./index.js";
 import { AssetApiClient } from "./assets/asset-api-client.js";
 import { CsvReader } from "./csv-reader.js";
 import { ConfigApiContext, ConfigApiServiceFactory, } from "../config-api/index.js";
@@ -14,15 +14,12 @@ export class PreWarmFactory {
         const entityManager = await configApi.client.getEntityManager();
         const csvReader = new CsvReader();
         const assetApiClient = new AssetApiClient(entityManager.token, this.context.app, this.context.keepParameterSorting);
-        const urls = this.getUrls(csvReader);
-        const variations = this.getVariations(csvReader);
-        return new PreWarmService(assetApiClient, cli, urls, variations, this.context.verbose);
-    }
-    getUrls(csvReader) {
-        return csvReader.readPath(this.context.path);
-    }
-    getVariations(csvReader) {
-        return resolveVariations(csvReader, this.context.variation, this.context.variationPath);
+        const rows = csvReader.readList(this.context.path);
+        const named = this.context.variation ?? this.context.variationPath;
+        if (named && rows.some((row) => row.variation)) {
+            cli.writeWarning(`The list names a variation for every url, so ${named} is not used`);
+        }
+        return new PreWarmService(assetApiClient, cli, toPrewarmTargets(rows, resolveVariations(csvReader, this.context.variation, this.context.variationPath)), this.context.verbose);
     }
 }
 /**
@@ -37,7 +34,7 @@ export function resolveVariations(csvReader, variation, variationPath) {
         variations = variation.split(VARIATION_SEPARATOR);
     }
     if (variationPath) {
-        variations = csvReader.readPath(variationPath);
+        variations = csvReader.readValues(variationPath);
     }
     return variations;
 }

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

@@ -8,6 +8,20 @@ export declare class PreWarmContext {
     readonly verbose: boolean;
     constructor(app: string, path: string, variation?: string, variationPath?: string, keepParameterSorting?: boolean, quiet?: boolean, verbose?: boolean);
 }
+/**
+ * One url to warm, in one variation. A pre-warm list is a list of these: the
+ * variation is a fact about the url, not a dimension crossed over the whole
+ * list, so a url seen only on phones is warmed only as `mobile`.
+ */
+export interface PrewarmTarget {
+    readonly url: string;
+    readonly variation: string;
+}
+/** A row of a pre-warm list, which may or may not name a variation yet. */
+export interface PrewarmRow {
+    readonly url: string;
+    readonly variation?: string;
+}
 export interface AssetItemInterface {
     done(): void;
     error?: Error;
@@ -36,4 +50,3 @@ export declare const TIMING_HEADER_KEY = "server-timing";
 export declare const PROGRESS_BAR_FORMAT = "[{bar}] {percentage}% | ETA: {eta_formatted}s | {value}/{total} | error:{errors} | rate: {rate} | retry: {retry} | batchDur: {batchDuration}";
 export declare const VARIATION_SEPARATOR = ",";
 export declare const DEFAULT_VARIATION: string[];
-export declare const DEFAULT_VARIATIONS: string[];

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

@@ -36,4 +36,3 @@ export const TIMING_HEADER_KEY = "server-timing";
 export const PROGRESS_BAR_FORMAT = "[{bar}] {percentage}% | ETA: {eta_formatted}s | {value}/{total} | error:{errors} | rate: {rate} | retry: {retry} | batchDur: {batchDuration}";
 export const VARIATION_SEPARATOR = ",";
 export const DEFAULT_VARIATION = ["default"];
-export const DEFAULT_VARIATIONS = ["mobile", "tablet", "tv"];