@speedkit/cli 4.26.0 → 4.27.0

package/dist/services/query-builder/queries/spec/golden-configs.js

@@ -0,0 +1,116 @@
+export const GOLDEN_CONFIGS = [
+    {
+        config: {
+            blacklist: [
+                {
+                    pathname: [
+                        // Guards for pages `enabledSites` never allowed — the bulk of a
+                        // real blacklist, and all reducible.
+                        /^\/checkout/i,
+                        /^\/cart/i,
+                        /^\/account/i,
+                        // These can hit an enabled page and have to survive.
+                        /\.pdf/i,
+                        /paypal/i,
+                    ],
+                },
+                { contentType: ["image", "script"], pathname: [/\/media\//i] },
+                { host: ["tracking.example.com"] },
+            ],
+            disabledScopes: ["/checkout", "/cart"],
+            disabledSites: [{ pathname: [/^\/search/i] }],
+            enabledSites: [
+                {
+                    host: ["www.shop.de"],
+                    pathname: [/^\/$/, /^\/p\//i, /^\/c\//i],
+                },
+            ],
+            ruleSetConfig: { version: 2 },
+            stripQueryParams: [{ params: ["gclid", /^utm[_-]/i] }],
+            whitelist: [{ contentType: ["navigate"], host: ["www.shop.de"] }],
+        },
+        describes: "the recommended shape: version 2, enabledSites, and a blacklist most of which cannot fire",
+        hosts: ["www.shop.de"],
+        name: "enabled-sites-v2",
+    },
+    {
+        config: {
+            blacklist: [{ pathname: ["/login", "/warenkorb"] }],
+            disabledSites: [{ pathname: [/\/kasse/i] }],
+            // No ruleSetConfig: version 1, where a string is a prefix and a
+            // pathname pattern is matched against the query string as well.
+            stripQueryParams: ["utm", /session$/i],
+            whitelist: [{ host: ["www.shop.de", "m.shop.de"] }],
+        },
+        describes: "a version 1 config without enabledSites, where every page is enabled unless disabled",
+        hosts: ["www.shop.de", "m.shop.de"],
+        name: "disabled-sites-v1",
+    },
+    {
+        config: {
+            enabledSites: [
+                { host: ["www.shop.de"], pathname: [/^\/de\//i] },
+                { host: ["www.shop.fr"], pathname: [/^\/fr\//i] },
+            ],
+            ruleSetConfig: { version: 2 },
+            whitelist: [{ host: ["www.shop.de", "www.shop.fr"] }],
+        },
+        describes: "one market per rule, which only works if host and pathname stay together",
+        hosts: ["www.shop.de", "www.shop.fr"],
+        name: "multi-market",
+    },
+    {
+        config: {
+            enabledSites: [{ pathname: [/^\/p\//i, /^\/c\//i] }],
+            ruleSetConfig: { version: 2 },
+            stripQueryParams: [
+                { params: ["gclid"] },
+                // Only stripped on product pages.
+                { enabledSites: [{ pathname: [/^\/p\//i] }], params: ["size"] },
+                // Only stripped on images, which a page impression never is.
+                { params: ["width"], rules: [{ contentType: ["image"] }] },
+            ],
+            whitelist: [{ host: ["www.shop.de"] }],
+        },
+        describes: "parameters stripped only on certain pages or resources",
+        hosts: ["www.shop.de"],
+        name: "scoped-strip-params",
+    },
+    {
+        config: {
+            blacklist: [
+                // A real shape: the hosts are only blacklisted for browsers without
+                // WebP, and the evaluated config carries the empty branch. Read as
+                // "any host" this rule would exclude every page.
+                { host: [] },
+                { pathname: [/^\/checkout/i] },
+            ],
+            enabledSites: [{ pathname: [/^\/$/, /^\/p\//i] }],
+            ruleSetConfig: { version: 2 },
+            whitelist: [{ host: ["www.shop.de"] }],
+        },
+        describes: "a condition that is an empty list, which matches nothing",
+        hosts: ["www.shop.de"],
+        name: "empty-condition",
+    },
+    {
+        config: {
+            blacklist: [
+                { contentType: ["fetch"] },
+                { url: ["www.googletagmanager.com/gtm.js"] },
+                // A word boundary has no automaton, so no reduction may touch it.
+                { pathname: [/\bprint\b/i] },
+            ],
+            disabledSites: [
+                { cookie: /loggedIn=true/ },
+                { mobile: true, pathname: [/^\/app\//i] },
+            ],
+            enabledSites: [{ pathname: [/^\//i] }],
+            ruleSetConfig: { version: 2 },
+            whitelist: [],
+        },
+        describes: "rules the query cannot express literally: a cookie, a device, a pattern with no automaton",
+        hosts: ["www.shop.de"],
+        name: "unexpressible",
+    },
+];

package/dist/services/query-builder/queries/spec/golden.spec.d.ts

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

package/dist/services/query-builder/queries/spec/golden.spec.js

@@ -0,0 +1,161 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { parseRuleSets } from "../../rules/index.js";
+import { buildParameterQuery } from "../parameter-query.js";
+import { buildPopsQuery } from "../pops-query.js";
+import { buildPrewarmQuery } from "../prewarm-query.js";
+import { GOLDEN_CONFIGS } from "./golden-configs.js";
+/**
+ * The queries these configs produce, in full, checked in beside them.
+ *
+ * A unit test states one property; a golden query states all of them at once,
+ * which is what a reviewer needs for a change that rewrites SQL. Run with
+ * `UPDATE_GOLDEN=1 npm test` to write the files, then read the diff — an
+ * unexplained line there is a bug, and the diff is the review.
+ */
+const DIRECTORY = join(dirname(fileURLToPath(import.meta.url)), "golden");
+/** A fixed day, so a window never makes a golden query go stale. */
+const NOW = new Date("2026-09-04T09:30:00Z");
+const APP = "shop-de";
+function goldenText(query) {
+    const notes = [
+        ...query.findings.map(({ reason, source }) => `finding: ${source} ${reason}`),
+        ...query.dropped.map(({ reason, source }) => `dropped: ${source} — ${reason}`),
+        ...query.approximated.map(({ reason, source }) => `approximated: ${source} — ${reason}`),
+        ...query.reduced.map(({ reason, source }) => `reduced: ${source} — ${reason}`),
+        ...query.warnings.map((warning) => `warning: ${warning}`),
+    ];
+    return [
+        query.sql.trim(),
+        "",
+        "-- accounting",
+        ...(notes.length > 0
+            ? notes.map((note) => `-- ${note}`)
+            : ["-- nothing left out, reduced or approximated"]),
+        "",
+    ].join("\n");
+}
+/** Compares against the checked-in file, or writes it when asked to. */
+function expectGolden(name, text) {
+    const file = join(DIRECTORY, `${name}.sql`);
+    if (process.env.UPDATE_GOLDEN) {
+        mkdirSync(DIRECTORY, { recursive: true });
+        writeFileSync(file, text, "utf8");
+        return;
+    }
+    let expected;
+    try {
+        expected = readFileSync(file, "utf8");
+    }
+    catch {
+        throw new Error(`No golden query at ${file}. Run UPDATE_GOLDEN=1 npm test to write it.`);
+    }
+    expect(text).to.equal(expected);
+}
+/** The prewarm query for one of the golden configs, with options on top. */
+function prewarmQueryFor(name, options) {
+    const { config, hosts } = GOLDEN_CONFIGS.find((candidate) => candidate.name === name);
+    return buildPrewarmQuery({
+        app: APP,
+        days: 10,
+        hosts,
+        now: NOW,
+        ruleSets: parseRuleSets(config),
+        ...options,
+    });
+}
+describe("golden queries", () => {
+    for (const { config, describes, hosts, name } of GOLDEN_CONFIGS) {
+        describe(`${name} — ${describes}`, () => {
+            const input = {
+                app: APP,
+                days: 10,
+                hosts,
+                now: NOW,
+                ruleSets: parseRuleSets(config),
+            };
+            it("should build the same prewarm query", () => {
+                expectGolden(`${name}.prewarm`, goldenText(buildPrewarmQuery(input)));
+            });
+            it("should build the same parameter query", () => {
+                expectGolden(`${name}.parameter`, goldenText(buildParameterQuery({ ...input, days: 30 })));
+            });
+        });
+    }
+    describe("match — a prewarm query narrowed by --match", () => {
+        it("should build the same prewarm query", () => {
+            expectGolden("enabled-sites-v2.match.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                match: ["^/p/", "(?i)^/c/[^?]*sale", "[?&]size="],
+            })));
+        });
+    });
+    describe("device — a prewarm list split by device class", () => {
+        it("should carry the variation and still judge urls", () => {
+            // Every url-level cut at once: the limit, the threshold and the 404 rule
+            // all belong to the inner `urls` relation, never to the pairs.
+            expectGolden("enabled-sites-v2.device.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                devices: ["desktop", "mobile"],
+                excludeNotFound: true,
+                limit: 5000,
+                minHits: 2,
+            })));
+        });
+        it("should split a list whose urls are reduced to a cache key", () => {
+            expectGolden("scoped-strip-params.device.prewarm", goldenText(prewarmQueryFor("scoped-strip-params", {
+                devices: ["desktop", "mobile", "tablet"],
+            })));
+        });
+    });
+    describe("variation — a prewarm list paired with custom variations", () => {
+        it("should cross every url with every variation", () => {
+            expectGolden("enabled-sites-v2.variation.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                variations: ["desktop-pdp-a", "mobile-pdp-a", "break"],
+            })));
+        });
+        it("should pair urls that were reduced to a cache key", () => {
+            expectGolden("scoped-strip-params.variation.prewarm", goldenText(prewarmQueryFor("scoped-strip-params", {
+                limit: 5000,
+                variations: ["men", "women"],
+            })));
+        });
+    });
+    describe("count — how large the list is, instead of what is in it", () => {
+        it("should count the list every other flag leaves", () => {
+            expectGolden("enabled-sites-v2.count.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                count: true,
+                excludeNotFound: true,
+                limit: 5000,
+                minHits: 2,
+            })));
+        });
+        it("should count a split list per device class, plus a total", () => {
+            expectGolden("enabled-sites-v2.device.count.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                count: true,
+                devices: ["desktop", "mobile"],
+            })));
+        });
+        it("should count custom variations as a product, not as rows", () => {
+            expectGolden("enabled-sites-v2.variation.count.prewarm", goldenText(prewarmQueryFor("enabled-sites-v2", {
+                count: true,
+                variations: ["desktop-pdp-a", "mobile-pdp-a", "break"],
+            })));
+        });
+    });
+    describe("pops — the same query for every app", () => {
+        it("should build the same pops query", () => {
+            const { parameters, sql } = buildPopsQuery({ app: APP, now: NOW });
+            expectGolden("pops", [sql.trim(), "", `-- parameters: ${parameters.join(", ")}`, ""].join("\n"));
+        });
+        it("should build the same pops query from rum", () => {
+            const { parameters, sql } = buildPopsQuery({
+                app: APP,
+                now: NOW,
+                useRum: true,
+            });
+            expectGolden("pops.rum", [sql.trim(), "", `-- parameters: ${parameters.join(", ")}`, ""].join("\n"));
+        });
+    });
+});

package/dist/services/query-builder/queries/spec/pops-query.spec.d.ts

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

package/dist/services/query-builder/queries/spec/pops-query.spec.js

@@ -0,0 +1,58 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { buildPopsQuery } from "../pops-query.js";
+import { sinceDate, today } from "../query-model.js";
+describe("buildPopsQuery", () => {
+    it("should read the request log, not the page impressions", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("from fastly.logs");
+        expect(sql).to.not.contain("rum.pi");
+    });
+    it("should pass the window and the app as parameters, in order", () => {
+        const { parameters, sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("where date between ? and ?");
+        expect(sql).to.contain("and app = ?");
+        expect(parameters).to.deep.equal([sinceDate(7), today(), "shop-de"]);
+    });
+    it("should look back a week by default", () => {
+        const [start, end] = buildPopsQuery({ app: "shop-de" }).parameters;
+        const days = (Date.parse(String(end)) - Date.parse(String(start))) / 86_400_000;
+        expect(days).to.equal(7);
+    });
+    it("should take the window from the caller", () => {
+        const { parameters } = buildPopsQuery({ app: "shop-de", days: 30 });
+        expect(parameters[0]).to.equal(sinceDate(30));
+    });
+    it("should count Speed Kit's own asset requests by default", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("and isassetrequest");
+        expect(sql).to.contain("and isnavigaterequest");
+        expect(sql).to.not.contain("ispibeacon");
+    });
+    it("should count beacons instead when there is no accelerated traffic", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de", useRum: true });
+        expect(sql).to.contain("and ispibeacon");
+        expect(sql).to.not.contain("isassetrequest");
+    });
+    it("should exclude bots and unknown origins", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("and client.bot is null");
+        expect(sql).to.contain("and origin not in ('Unknown', '')");
+    });
+    it("should keep the locale prefix of an origin", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("regexp_extract(url_extract_path(asseturl)");
+        expect(sql).to.contain(String.raw `(?i)((/\w+)?/[a-z]{2}([-/_][a-z]{2})*/)`);
+    });
+    it("should aggregate per region, pop and origin", () => {
+        const { sql } = buildPopsQuery({ app: "shop-de" });
+        expect(sql).to.contain("coalesce(originWithPrefix, origin) as origin");
+        expect(sql).to.contain("count() as hits");
+        expect(sql).to.contain("group by grouping sets (");
+        expect(sql).to.contain("having originWithPrefix is null or originWithPrefix <> 'Unknown'");
+    });
+    it("should project only what the aggregation reads", () => {
+        // `select *` would carry every column of the log through the CTE.
+        expect(buildPopsQuery({ app: "shop-de" }).sql).to.not.contain("select *");
+    });
+});

package/dist/services/query-builder/queries/spec/queries.spec.d.ts

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

package/dist/services/query-builder/queries/spec/queries.spec.js

@@ -0,0 +1,312 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { parseRuleSets } from "../../rules/index.js";
+import { buildParameterQuery } from "../parameter-query.js";
+import { buildPrewarmQuery } from "../prewarm-query.js";
+import { sinceDate } from "../query-model.js";
+function inputFor(config, options = {}) {
+    return {
+        app: "shop-de",
+        days: 10,
+        hosts: ["www.shop.de"],
+        ruleSets: parseRuleSets(config),
+        ...options,
+    };
+}
+const CONFIG = {
+    blacklist: [{ contentType: ["image"], pathname: [/\/media\//i] }],
+    enabledSites: [{ host: "www.shop.de", pathname: [/^\/p\//i] }],
+    ruleSetConfig: { version: 2 },
+    stripQueryParams: [{ params: ["gclid"] }],
+    whitelist: [{ host: ["www.shop.de"] }],
+};
+/** A config whose enabled scope is wide enough for a guard to survive. */
+const WIDE_CONFIG = {
+    disabledScopes: ["/checkout", "/cart"],
+    enabledSites: [{ pathname: [/^\//i] }],
+    ruleSetConfig: { version: 2 },
+};
+describe("sinceDate", () => {
+    it("should count back from the given day", () => {
+        expect(sinceDate(10, new Date("2026-09-04T08:00:00Z"))).to.equal("2026-08-25");
+    });
+    it("should keep a window of at least one day", () => {
+        expect(sinceDate(0, new Date("2026-09-04T08:00:00Z"))).to.equal("2026-09-03");
+    });
+});
+describe("the row filter of both queries", () => {
+    const queries = {
+        parameter: buildParameterQuery,
+        prewarm: buildPrewarmQuery,
+    };
+    for (const [name, build] of Object.entries(queries)) {
+        describe(name, () => {
+            it("should read the app and the window", () => {
+                const { sql } = build(inputFor(CONFIG));
+                expect(sql).to.contain("app = 'shop-de'");
+                expect(sql).to.contain(`date >= '${sinceDate(10)}'`);
+            });
+            it("should always exclude bots", () => {
+                expect(build(inputFor(CONFIG)).sql).to.contain("device <> 'Robot'");
+            });
+            it("should not filter navigations unless asked to", () => {
+                expect(build(inputFor(CONFIG)).sql).to.not.contain("navigationtype");
+            });
+            it("should keep hard navigations only when asked to", () => {
+                const { sql } = build(inputFor(CONFIG, { hardNavigationsOnly: true }));
+                expect(sql).to.contain("navigationtype in ('NAVIGATE', 'RELOAD', 'BACK_FORWARD')");
+            });
+            it("should exclude suspicious page impressions when asked to", () => {
+                const { sql } = build(inputFor(CONFIG, { excludeSuspicious: true }));
+                // Null has to count as not suspicious, or the rows vanish with it.
+                expect(sql).to.contain("not coalesce(suspicious, false)");
+                expect(sql).to.not.contain("noindex");
+            });
+            it("should exclude noindex pages when asked to", () => {
+                const { sql } = build(inputFor(CONFIG, { excludeNoindex: true }));
+                expect(sql).to.contain("not coalesce(noindex, false)");
+            });
+            it("should read the relation only through the page source", () => {
+                const { sql } = build(inputFor(CONFIG));
+                expect(sql.match(/live\.rum\.pi/g)).to.have.lengthOf(1);
+                expect(sql).to.contain("from pages");
+            });
+            it("should leave out a rule that cannot apply to a document", () => {
+                const { dropped, sql } = build(inputFor(CONFIG));
+                expect(sql).to.not.contain("/media/");
+                expect(dropped.map(({ source }) => source)).to.contain("blacklist[0]");
+            });
+            it("should exclude the pages a disabled scope claims", () => {
+                // The service worker never runs there, so Speed Kit never sees them.
+                const { sql } = build(inputFor(WIDE_CONFIG));
+                expect(sql).to.contain("regexp_like(path, '^/checkout')");
+                expect(sql).to.contain("regexp_like(path, '^/cart')");
+            });
+            it("should reduce away a scope no enabled page can reach", () => {
+                const { reduced, sql } = build(inputFor({
+                    ...WIDE_CONFIG,
+                    enabledSites: [{ pathname: [/^\/p\//i] }],
+                }));
+                expect(sql).to.not.contain("checkout");
+                expect(reduced.map(({ source }) => source)).to.contain("disabledScopes[0]");
+            });
+            it("should project only the subjects the rules use", () => {
+                const { sql } = build(inputFor(CONFIG));
+                expect(sql).to.contain("as host");
+                expect(sql).to.contain("as path");
+                expect(sql).to.not.contain("as pathWithSearch");
+                expect(sql).to.not.contain("as matchUrl");
+            });
+        });
+    }
+});
+describe("buildPrewarmQuery", () => {
+    it("should group the stripped urls by request count", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG));
+        expect(sql).to.contain("select url, count(*) as hits");
+        expect(sql).to.contain("group by url");
+        expect(sql).to.contain("order by hits desc");
+    });
+    it("should keep the whole list unless asked to cut it", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG));
+        expect(sql).to.not.contain("having");
+        expect(sql).to.not.contain("limit");
+    });
+    it("should drop urls below the hit threshold", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { minHits: 5 }));
+        expect(sql).to.contain("having count(*) >= 5");
+    });
+    it("should keep only the most requested urls when limited", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { limit: 5000 })).sql).to.contain("limit 5000");
+    });
+    it("should drop urls the origin mostly answers with a 404", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { excludeNotFound: true }));
+        expect(sql).to.contain("responsecause");
+        expect(sql).to.contain("2 * count_if(responsecause = 'OriginStatusNotFound') < count(*)");
+    });
+    it("should not read the response cause unless it filters on it", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG)).sql).to.not.contain("responsecause");
+    });
+    it("should not carry createdat through the prewarm query", () => {
+        // Only the parameter query picks example urls by creation time.
+        expect(buildPrewarmQuery(inputFor(CONFIG)).sql).to.not.contain("createdat");
+    });
+    it("should strip the configured parameters from the url", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG));
+        expect(sql).to.contain("(?i)[?&](gclid)(=[^&]*)?(?=&|$)");
+    });
+});
+describe("the --device split", () => {
+    const DEVICES = inputFor(CONFIG, { devices: ["desktop", "mobile"] });
+    it("should read the device classes asked for, and no other", () => {
+        const { sql } = buildPrewarmQuery(DEVICES);
+        expect(sql).to.contain("device in ('Desktop', 'Mobile')");
+        // Naming them subsumes the bot exclusion.
+        expect(sql).to.not.contain("device <> 'Robot'");
+        expect(sql).to.not.contain("'Tablet'");
+    });
+    it("should carry the device as the variation of the row", () => {
+        expect(buildPrewarmQuery(DEVICES).sql).to.contain("lower(device) as variation");
+    });
+    it("should count the pairs and rank them by their own hits", () => {
+        const { sql } = buildPrewarmQuery(DEVICES);
+        expect(sql).to.contain("select impressions.url, impressions.variation, count(*) as hits");
+        expect(sql).to.contain("join urls on urls.url = impressions.url");
+        expect(sql).to.contain("group by 1, 2");
+        expect(sql).to.contain("order by 3 desc");
+    });
+    it("should still limit urls rather than rows", () => {
+        // The limit belongs to the relation that has one row per url, so
+        // `--limit 5000` is 5000 pages, not 5000 pre-warm requests.
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { devices: ["desktop"], limit: 5000, minHits: 5 }));
+        expect(sql).to.contain("urls as (\n  select url, count(*) as hits\n  from impressions\n  group by url\n  having count(*) >= 5\n  order by hits desc\n  limit 5000\n)");
+    });
+    it("should ignore the order the devices were given in", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { devices: ["mobile", "desktop"] }))
+            .sql).to.equal(buildPrewarmQuery(DEVICES).sql);
+    });
+    it("should not read the device unless it splits by it", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG));
+        expect(sql).to.not.contain("as variation");
+        expect(sql).to.not.contain("impressions");
+    });
+});
+describe("the --variation pairing", () => {
+    const VARIATIONS = inputFor(CONFIG, { variations: ["men", "women"] });
+    it("should pair every url with every variation", () => {
+        const { sql } = buildPrewarmQuery(VARIATIONS);
+        expect(sql).to.contain("cross join unnest(array['men', 'women']) as t (variation)");
+        expect(sql).to.contain("select urls.url, variation, urls.hits");
+        expect(sql).to.contain("order by urls.hits desc, variation");
+    });
+    it("should not pretend the traffic knows the variation", () => {
+        const { sql } = buildPrewarmQuery(VARIATIONS);
+        expect(sql).to.contain("device <> 'Robot'");
+        expect(sql).to.not.contain("lower(device)");
+    });
+    it("should quote a variation that carries a quote", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { variations: ["it's"] })).sql).to.contain("array['it''s']");
+    });
+});
+describe("the --count report", () => {
+    it("should count the urls and the traffic they stand for", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true }));
+        expect(sql).to.contain("select count(*) as urls, sum(hits) as impressions\nfrom urls");
+        expect(sql).to.not.contain("select url, count(*) as hits\nfrom");
+    });
+    it("should count the list every other option leaves", () => {
+        // Nothing about counting relaxes a cut: the number is the size of the
+        // list the same flags would produce, limit included.
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true, limit: 5000, minHits: 5 }));
+        expect(sql).to.contain("urls as (\n  select url, count(*) as hits\n  from impressions\n  group by url\n  having count(*) >= 5\n  order by hits desc\n  limit 5000\n)");
+    });
+    it("should count a split list per variation, plus a total", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true, devices: ["desktop", "mobile"] }));
+        // Over the pairs, so the total is what the pre-warmer would request —
+        // every url once per device class it was seen in.
+        expect(sql).to.contain("pairs as (");
+        expect(sql).to.contain("select coalesce(pairs.variation, 'total') as variation, count(*) as urls, sum(hits) as impressions");
+        expect(sql).to.contain("group by rollup(pairs.variation)");
+        // Qualified: an unqualified argument would resolve to the output alias of
+        // the same name, which Athena rejects in a grouping() expression.
+        expect(sql).to.contain("order by grouping(pairs.variation) desc, 2 desc");
+    });
+    it("should count custom variations as a product", () => {
+        // Every url carries every one of them, so a row per variation would be
+        // the same number written out three times.
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true, variations: ["men", "women", "kids"] }));
+        expect(sql).to.contain("select count(*) as urls, 3 * count(*) as requests, sum(hits) as impressions");
+        expect(sql).to.not.contain("cross join unnest");
+    });
+    it("should leave the list itself alone", () => {
+        const options = { devices: ["desktop"], limit: 10, minHits: 2 };
+        const list = buildPrewarmQuery(inputFor(CONFIG, options)).sql;
+        const count = buildPrewarmQuery(inputFor(CONFIG, { ...options, count: true })).sql;
+        // Same relations, different projection: everything up to the final select
+        // is what the list is built from.
+        expect(count).to.contain(list.slice(0, list.indexOf("\n\nselect")));
+    });
+});
+describe("the --match narrowing", () => {
+    it("should filter on the path and its query string", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { match: ["^/p/"] }));
+        // A version 1 pathname condition, whatever version the config runs under.
+        expect(sql).to.contain("as pathWithSearch");
+        expect(sql).to.contain("regexp_like(pathWithSearch, '^/p/')");
+    });
+    it("should reach a query parameter", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { match: ["[?&]size="] })).sql).to.contain("regexp_like(pathWithSearch, '[?&]size=')");
+    });
+    it("should keep the pages matching any of several patterns", () => {
+        const { sql } = buildPrewarmQuery(inputFor(CONFIG, { match: ["^/p/", "^/c/"] }));
+        expect(sql).to.contain("(\n      regexp_like(pathWithSearch, '^/p/')\n      or regexp_like(pathWithSearch, '^/c/')\n    )");
+    });
+    it("should carry inline flags over to Athena", () => {
+        // `new RegExp('(?i)…')` throws, so the flag is lifted out and put back.
+        expect(buildPrewarmQuery(inputFor(CONFIG, { match: ["(?i)^/P/"] })).sql).to.contain("regexp_like(pathWithSearch, '(?i)^/P/')");
+    });
+    it("should not project the subject when nothing matches on it", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG)).sql).to.not.contain("pathWithSearch");
+    });
+    it("should refuse a pattern the config excludes again", () => {
+        // The scope is disabled, so nothing under it is ever served by Speed Kit.
+        expect(() => buildPrewarmQuery(inputFor(WIDE_CONFIG, { match: ["^/checkout/thanks"] }))).to.throw(/--match is completely excluded again by disabledScopes/);
+    });
+    it("should restate a version 2 guard over the query string", () => {
+        // The guard is matched against the path, the pattern against path and
+        // query string; without the restatement the two are never compared.
+        const config = {
+            disabledSites: [{ pathname: [/^\/checkout$/] }],
+            enabledSites: [{ pathname: [/^\//] }],
+            ruleSetConfig: { version: 2 },
+        };
+        expect(() => buildPrewarmQuery(inputFor(config, { match: ["^/checkout\\?step="] }))).to.throw(/--match is completely excluded again by disabledSites/);
+    });
+    it("should not refuse a pattern the config only partly excludes", () => {
+        expect(() => buildPrewarmQuery(inputFor(WIDE_CONFIG, { match: ["^/"] }))).to.not.throw();
+    });
+    it("should not refuse a pattern an unanchored guard seems to cover", () => {
+        // /checkout/ says nothing about where in the path it sits, so it cannot
+        // be restated over the query string and takes part in no comparison.
+        const config = {
+            disabledSites: [{ pathname: [/checkout/] }],
+            enabledSites: [{ pathname: [/^\//] }],
+            ruleSetConfig: { version: 2 },
+        };
+        expect(() => buildPrewarmQuery(inputFor(config, { match: ["^/checkout/"] }))).to.not.throw();
+    });
+});
+describe("buildParameterQuery", () => {
+    it("should keep a parameter the config does not strip", () => {
+        const { sql } = buildParameterQuery(inputFor(CONFIG));
+        expect(sql).to.contain("(key) -> not (lower(key) = 'gclid')");
+    });
+    it("should count only urls that carry a query string", () => {
+        expect(buildParameterQuery(inputFor(CONFIG)).sql).to.contain("cardinality(split(url, '?')) > 1");
+    });
+    it("should build the cache key from the parameters it keeps", () => {
+        const { sql } = buildParameterQuery(inputFor(CONFIG));
+        expect(sql).to.contain("path || '?' || array_join(pairs, '&') as cacheKey");
+        expect(sql).to.contain("count(distinct cacheKey) as cachedUrls");
+    });
+    it("should sort and deduplicate the parameters of a url", () => {
+        // Speed Kit sorts the query string, so `?b=1&a=1` and `?a=1&b=1` are one
+        // cache key — and one group, not two.
+        expect(buildParameterQuery(inputFor(CONFIG)).sql).to.contain("array_sort(\n        array_distinct(");
+    });
+    it("should rank one row per parameter", () => {
+        const { sql } = buildParameterQuery(inputFor(CONFIG));
+        expect(sql).to.contain("group by parameter");
+        expect(sql).to.contain("count(distinct value) as distinctValues");
+        expect(sql).to.contain("count(distinct cacheKey) - count(distinct cacheKeyWithout) as potentialGain");
+    });
+    it("should rank whole sets when asked to", () => {
+        const { sql } = buildParameterQuery(inputFor(CONFIG, { bySet: true }));
+        expect(sql).to.contain("group by pairs");
+        expect(sql).to.contain("as paramKeys");
+        expect(sql).to.not.contain("group by parameter");
+    });
+    it("should leave out parameters below the impression threshold", () => {
+        expect(buildParameterQuery(inputFor(CONFIG, { minImpressions: 30 })).sql).to.contain("having count(*) >= 30");
+    });
+});

package/dist/services/query-builder/queries/spec/reported-bugs.spec.d.ts

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