@speedkit/cli 4.27.0 → 4.27.2

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

@@ -1,4 +1,23 @@
 export const DEFAULT_MAX_AGE_IN_MINUTES = 60;
+/**
+ * The Athena data catalog holding the Speed Kit tables.
+ *
+ * Which catalog that is depends on the credentials: the name below is the one
+ * our own logins see, while a role scoped to one account reaches the same
+ * tables under `AwsDataCatalog`. It is therefore a default, not a constant —
+ * see the `--catalog` flag.
+ */
+export const DEFAULT_ATHENA_CATALOG = "live";
+/**
+ * The catalog to use, given what a caller asked for.
+ *
+ * A blank name is the default rather than an error: it reaches here from an
+ * unset environment variable in a CI file as easily as from a typo, and a
+ * query that reads `from .rum.pi` is no way to report it.
+ */
+export function athenaCatalog(catalog) {
+    return catalog?.trim() || DEFAULT_ATHENA_CATALOG;
+}
 export const ATHENA_CONFIG = {
     region: "eu-central-1",
 };

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

@@ -10,7 +10,27 @@ import { CliServiceInterface } from "../cli/index.js";
 export declare class AwsAthenaService implements AthenaService {
     private client;
     private cli;
-    constructor(client: AthenaClient, cli: CliServiceInterface);
+    /**
+     * Athena falls back to the account's default workgroup when this is unset,
+     * which is only right where the credentials are allowed to use it.
+     */
+    private workgroup?;
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    private catalog?;
+    constructor(client: AthenaClient, cli: CliServiceInterface, 
+    /**
+     * Athena falls back to the account's default workgroup when this is unset,
+     * which is only right where the credentials are allowed to use it.
+     */
+    workgroup?: string, 
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    catalog?: string);
     getResult<T>(query: string, parameters?: string[], maxAgeInMinutes?: number): Promise<T[]>;
     /** The query, from sending it off to the rows it produced. */
     private runAndFetch;

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

@@ -1,5 +1,5 @@
 import { GetQueryExecutionCommand, GetQueryResultsCommand, QueryExecutionState, StartQueryExecutionCommand, } from "@aws-sdk/client-athena";
-import { DEFAULT_MAX_AGE_IN_MINUTES } from "./athena-service-model.js";
+import { athenaCatalog, DEFAULT_MAX_AGE_IN_MINUTES, } from "./athena-service-model.js";
 import { AthenaQueryError } from "./error/athena-query-error.js";
 import { safe } from "../../helpers/safe.js";
 /**
@@ -11,9 +11,23 @@ import { safe } from "../../helpers/safe.js";
 export class AwsAthenaService {
     client;
     cli;
-    constructor(client, cli) {
+    workgroup;
+    catalog;
+    constructor(client, cli, 
+    /**
+     * Athena falls back to the account's default workgroup when this is unset,
+     * which is only right where the credentials are allowed to use it.
+     */
+    workgroup, 
+    /**
+     * The data catalog the query runs against. It has to be the one the query
+     * text names too, or Athena rejects the reference rather than the context.
+     */
+    catalog) {
         this.client = client;
         this.cli = cli;
+        this.workgroup = workgroup;
+        this.catalog = catalog;
     }
     async getResult(query, parameters = [], maxAgeInMinutes = DEFAULT_MAX_AGE_IN_MINUTES) {
         this.cli.startAction("ATHENA:QUERY", "execute athena query");
@@ -99,7 +113,7 @@ export class AwsAthenaService {
         const command = new StartQueryExecutionCommand({
             ExecutionParameters: executionParameters.length > 0 ? executionParameters : null,
             QueryExecutionContext: {
-                Catalog: "live",
+                Catalog: athenaCatalog(this.catalog),
             },
             QueryString: sql,
             ResultReuseConfiguration: {
@@ -108,6 +122,10 @@ export class AwsAthenaService {
                     MaxAgeInMinutes: maxAgeInMinutes,
                 },
             },
+            // Omitted rather than sent empty: Athena reads an absent WorkGroup as
+            // "the default one", and an empty string as a workgroup that does not
+            // exist.
+            ...(this.workgroup ? { WorkGroup: this.workgroup } : {}),
         });
         const response = await this.client.send(command);
         await this.waitOnResponse(response.QueryExecutionId);

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

@@ -14,9 +14,10 @@ function recordingCli() {
     return { calls, cli };
 }
 /** An Athena that answers every execution with the given state. */
-function clientAnswering(state, reason) {
+function clientAnswering(state, reason, sent = []) {
     return {
         send: async (command) => {
+            sent.push(command);
             if (command instanceof StartQueryExecutionCommand) {
                 return { QueryExecutionId: "query-1" };
             }
@@ -62,6 +63,40 @@ describe("AwsAthenaService", () => {
         expect(result.message).to.contain("INVALID_ARGUMENTS: nope");
         expect(calls).to.deep.equal(["start:ATHENA:QUERY", "fail:ATHENA:QUERY"]);
     });
+    it("should run in the workgroup it was given", async () => {
+        const { cli } = recordingCli();
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), cli, "prewarming");
+        await service.getResult("select 1", [], 0);
+        const start = sent.find((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input.WorkGroup).to.equal("prewarming");
+    });
+    it("should leave the workgroup out when none was given", async () => {
+        // Athena reads an absent WorkGroup as the account default; an empty string
+        // is a workgroup that does not exist, so the key has to be gone entirely.
+        const { cli } = recordingCli();
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), cli);
+        await service.getResult("select 1", [], 0);
+        const start = sent.find((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input).to.not.have.property("WorkGroup");
+    });
+    it("should run against the catalog it was given", async () => {
+        // The context and the query text have to name the same catalog, or Athena
+        // rejects the reference in the query rather than the context.
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), recordingCli().cli, undefined, "AwsDataCatalog");
+        await service.getResult("select 1", [], 0);
+        const [start] = sent.filter((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input.QueryExecutionContext.Catalog).to.equal("AwsDataCatalog");
+    });
+    it("should fall back to the live catalog", async () => {
+        const sent = [];
+        const service = new AwsAthenaService(clientAnswering("SUCCEEDED", undefined, sent), recordingCli().cli);
+        await service.getResult("select 1", [], 0);
+        const [start] = sent.filter((command) => command instanceof StartQueryExecutionCommand);
+        expect(start.input.QueryExecutionContext.Catalog).to.equal("live");
+    });
     it("should not pass a failed query off as an empty result", async () => {
         const { cli } = recordingCli();
         const service = new AwsAthenaService(clientAnswering("CANCELLED"), cli);

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

@@ -8,8 +8,8 @@ import { CliServiceInterface } from "../cli/index.js";
  *
  * Two normalizations vs the AWS path:
  *  - `?` placeholders are inlined (the native path has no parameter binding).
- *  - the `live.` catalog prefix is stripped — the server derives catalog and
- *    database itself, and a 3-part `live.<db>.<table>` reference fails there
+ *  - the catalog prefix is stripped — the server derives catalog and database
+ *    itself, and a 3-part `<catalog>.<db>.<table>` reference fails there
  *    (verified against a live app), whereas 2-part `<db>.<table>` works.
  */
 export declare class BaqendAthenaService implements AthenaService {
@@ -17,8 +17,17 @@ export declare class BaqendAthenaService implements AthenaService {
     private entityManagerFactory;
     private cli;
     private static readonly TRIGGERED_BY;
-    private static readonly CATALOG_PREFIX;
-    constructor(app: string, entityManagerFactory: EntityManagerFactory, cli: CliServiceInterface);
+    /** A catalog qualifier in front of a `<db>.<table>` reference. */
+    private readonly catalogPrefix;
+    /** The catalog whose qualifier has to come back out of the query. */
+    private readonly catalog;
+    constructor(app: string, entityManagerFactory: EntityManagerFactory, cli: CliServiceInterface, 
+    /**
+     * The catalog the queries name. Whichever one the caller runs under, the
+     * prefix has to come back out here — so the name is read rather than
+     * assumed.
+     */
+    catalog?: string);
     getResult<T>(query: string, parameters?: AthenaParameter[], maxAgeInMinutes?: number, bucket?: AthenaBucket): Promise<T[]>;
     /**
      * Inline the `?` placeholders with the given parameters (same quoting as the

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

@@ -1,5 +1,9 @@
-import { DEFAULT_MAX_AGE_IN_MINUTES } from "./athena-service-model.js";
+import { athenaCatalog, DEFAULT_MAX_AGE_IN_MINUTES, } from "./athena-service-model.js";
 import { safe } from "../../helpers/safe.js";
+/** A literal for use inside a regular expression. */
+function escapeRegExp(value) {
+    return value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
+}
 /**
  * Runs Athena SQL through the Baqend API, authenticated by the app token only
  * (no AWS login). Hits the native query path via
@@ -7,8 +11,8 @@ import { safe } from "../../helpers/safe.js";
  *
  * Two normalizations vs the AWS path:
  *  - `?` placeholders are inlined (the native path has no parameter binding).
- *  - the `live.` catalog prefix is stripped — the server derives catalog and
- *    database itself, and a 3-part `live.<db>.<table>` reference fails there
+ *  - the catalog prefix is stripped — the server derives catalog and database
+ *    itself, and a 3-part `<catalog>.<db>.<table>` reference fails there
  *    (verified against a live app), whereas 2-part `<db>.<table>` works.
  */
 export class BaqendAthenaService {
@@ -16,12 +20,22 @@ export class BaqendAthenaService {
     entityManagerFactory;
     cli;
     static TRIGGERED_BY = "speed-kit-cli";
-    // a `live.` catalog qualifier in front of a `<db>.<table>` reference
-    static CATALOG_PREFIX = /^live\.[a-z_]\w*\.[a-z_]/i;
-    constructor(app, entityManagerFactory, cli) {
+    /** A catalog qualifier in front of a `<db>.<table>` reference. */
+    catalogPrefix;
+    /** The catalog whose qualifier has to come back out of the query. */
+    catalog;
+    constructor(app, entityManagerFactory, cli, 
+    /**
+     * The catalog the queries name. Whichever one the caller runs under, the
+     * prefix has to come back out here — so the name is read rather than
+     * assumed.
+     */
+    catalog) {
         this.app = app;
         this.entityManagerFactory = entityManagerFactory;
         this.cli = cli;
+        this.catalog = athenaCatalog(catalog);
+        this.catalogPrefix = new RegExp(`^${escapeRegExp(this.catalog)}\\.[a-z_]\\w*\\.[a-z_]`, "i");
     }
     async getResult(query, parameters = [], maxAgeInMinutes = DEFAULT_MAX_AGE_IN_MINUTES, bucket) {
         if (!bucket) {
@@ -78,11 +92,12 @@ export class BaqendAthenaService {
                 out += typeof value === "string" ? `'${value}'` : String(value);
                 continue;
             }
-            // strip a `live.` catalog qualifier at a word boundary
-            if ((char === "l" || char === "L") &&
+            // strip the catalog qualifier at a word boundary
+            if (char.toLowerCase() === this.catalog[0].toLowerCase() &&
                 (index === 0 || !/\w/.test(query[index - 1])) &&
-                BaqendAthenaService.CATALOG_PREFIX.test(query.slice(index))) {
-                index += 4; // skip "live." (the loop's index++ skips the dot)
+                this.catalogPrefix.test(query.slice(index))) {
+                // skip the name; the loop's index++ skips the dot behind it
+                index += this.catalog.length;
                 continue;
             }
             out += char;

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

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

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

@@ -0,0 +1,51 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { AthenaBucket } from "./athena-query-service.js";
+import { BaqendAthenaService } from "./baqend-athena-service.js";
+const cli = {
+    failAction: () => undefined,
+    startAction: () => undefined,
+    successAction: () => undefined,
+    writeError: () => undefined,
+};
+/** An entity manager that records the sql it was asked to run. */
+function factoryCapturing(sent) {
+    return {
+        getEntityManager: async () => ({
+            [AthenaBucket.RumPi]: {
+                executeQuery: async (sql) => {
+                    sent.push(sql);
+                    return [];
+                },
+            },
+        }),
+    };
+}
+/** The sql that reached the Baqend API for a query run under `catalog`. */
+async function sentFor(query, catalog) {
+    const sent = [];
+    const service = new BaqendAthenaService("shop-de", factoryCapturing(sent), cli, catalog);
+    await service.getResult(query, [], 60, AthenaBucket.RumPi);
+    return sent[0];
+}
+describe("BaqendAthenaService", () => {
+    it("should strip the default catalog qualifier", async () => {
+        // The native path derives catalog and database itself and rejects a
+        // three-part reference.
+        expect(await sentFor("select url from live.rum.pi")).to.equal("select url from rum.pi");
+    });
+    it("should strip whichever catalog the query names", async () => {
+        expect(await sentFor("select url from AwsDataCatalog.rum.pi", "AwsDataCatalog")).to.equal("select url from rum.pi");
+    });
+    it("should leave a catalog name inside a string literal alone", async () => {
+        expect(await sentFor("select 'https://live.foo.com' from live.rum.pi")).to.equal("select 'https://live.foo.com' from rum.pi");
+    });
+    it("should fall back to the default catalog when given a blank one", async () => {
+        // An unset variable in a CI file arrives as an empty string, and the
+        // stripping reads the first character of the name.
+        expect(await sentFor("select url from live.rum.pi", "  ")).to.equal("select url from rum.pi");
+    });
+    it("should leave a word that merely starts like the catalog alone", async () => {
+        expect(await sentFor("select liveliness from live.rum.pi")).to.equal("select liveliness from rum.pi");
+    });
+});

package/dist/services/cli/cli-service.d.ts

@@ -8,6 +8,9 @@ export declare class CliService implements CliServiceInterface {
     private buffer;
     private progressBar?;
     private spinners;
+    private readonly animates;
+    /** The text of each running action, for the log line that replaces it. */
+    private readonly actions;
     constructor(quiet?: boolean);
     code(code: string, buffered?: boolean): void;
     codeStyle(code: string): string;
@@ -30,6 +33,12 @@ export declare class CliService implements CliServiceInterface {
     endAction(name: string, message?: string): void;
     failAction(name: string, message?: string): void;
     successAction(name: string, message?: string): void;
+    /**
+     * One line for an action that ended, where a spinner cannot be drawn. The
+     * text comes from the action that started, so a caller that ends one without
+     * a message still says which one it ended.
+     */
+    private logAction;
     startProgress(total: number, start?: number, payload?: object, config?: Options): void;
     updateProgress(current: number, payload?: object): void;
     stopProgress(): void;

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

@@ -6,12 +6,27 @@ import Spinnies from "spinnies";
 import { safe } from "../../helpers/safe.js";
 import { execSync } from "node:child_process";
 import ApplicationError from "../error-handling/error/application-error.js";
+/**
+ * Whether a spinner can actually spin here.
+ *
+ * The same condition spinnies itself uses to decide, so the two never
+ * disagree: without it spinnies falls back to re-rendering *every* spinner it
+ * knows on every update, which in a CI log means the first action's line is
+ * printed again under each later one — a page of "build prewarm-query" for a
+ * job that only ever built one.
+ */
+function canAnimate() {
+    return Boolean(!process.env.CI && process.stderr && process.stderr.isTTY);
+}
 export class CliService {
     quiet;
     style;
     buffer = [];
     progressBar;
     spinners;
+    animates = canAnimate();
+    /** The text of each running action, for the log line that replaces it. */
+    actions = new Map();
     constructor(quiet = false) {
         this.quiet = quiet;
         this.spinners = new Spinnies();
@@ -90,26 +105,65 @@ export class CliService {
         if (this.quiet) {
             return;
         }
+        // Nothing is logged while the action runs: a log that cannot animate has
+        // no use for "this is happening", only for what happened.
+        if (!this.animates) {
+            this.actions.set(name, message);
+            return;
+        }
         this.spinners.add(name, { text: message });
     }
     endAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction("-", name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.update(name, { status: "stopped", text: message });
     }
     failAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction(this.style.red("✖"), name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.fail(name, { text: message });
     }
     successAction(name, message) {
-        if (this.quiet || !this.spinners.pick(name)) {
+        if (this.quiet) {
+            return;
+        }
+        if (!this.animates) {
+            this.logAction(this.style.green("✔"), name, message);
+            return;
+        }
+        if (!this.spinners.pick(name)) {
             return;
         }
         this.spinners.succeed(name, { text: message, succeedColor: "white" });
     }
+    /**
+     * One line for an action that ended, where a spinner cannot be drawn. The
+     * text comes from the action that started, so a caller that ends one without
+     * a message still says which one it ended.
+     */
+    logAction(symbol, name, message) {
+        const text = message ?? this.actions.get(name);
+        if (!this.actions.delete(name) && !message) {
+            return;
+        }
+        console.log(`${symbol} ${text}`);
+    }
     startProgress(total, start = 0, payload, config) {
         if (this.quiet) {
             return;

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

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

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

@@ -0,0 +1,67 @@
+import { expect } from "chai";
+import { afterEach, beforeEach, describe, it } from "mocha";
+import { CliService } from "./cli-service.js";
+/** The lines a block of work put on stdout. */
+function captured(work) {
+    const lines = [];
+    const log = console.log;
+    console.log = (line) => lines.push(line);
+    try {
+        work();
+    }
+    finally {
+        console.log = log;
+    }
+    return lines;
+}
+describe("CliService actions without a terminal", () => {
+    let ci;
+    beforeEach(() => {
+        ci = process.env.CI;
+        // What a CI runner sets, and what spinnies reads to decide it cannot spin.
+        process.env.CI = "true";
+    });
+    afterEach(() => {
+        if (ci === undefined) {
+            delete process.env.CI;
+            return;
+        }
+        process.env.CI = ci;
+    });
+    it("should say nothing while an action runs", () => {
+        const cli = new CliService();
+        expect(captured(() => cli.startAction("BUILD", "build prewarm-query"))).to.have.lengthOf(0);
+    });
+    it("should log an action that ended exactly once", () => {
+        // Spinnies re-renders every spinner it knows on each update when it cannot
+        // animate, so a running action reappears under each later one — a job with
+        // four actions logged "build prewarm-query" four times.
+        const cli = new CliService();
+        const lines = captured(() => {
+            cli.startAction("BUILD", "build prewarm-query");
+            cli.successAction("BUILD");
+            cli.startAction("QUERY", "execute athena query");
+            cli.failAction("QUERY");
+        });
+        expect(lines).to.have.lengthOf(2);
+        expect(lines[0]).to.contain("build prewarm-query");
+        expect(lines[1]).to.contain("execute athena query");
+        expect(lines.join("\n")).to.not.contain("build prewarm-query\n✖ execute athena query\n✔ build prewarm-query");
+    });
+    it("should keep the text of the action it ends", () => {
+        const cli = new CliService();
+        const lines = captured(() => {
+            cli.startAction("WARM", "warm the list");
+            cli.endAction("WARM");
+        });
+        expect(lines).to.deep.equal(["- warm the list"]);
+    });
+    it("should stay silent when it was told to be quiet", () => {
+        const cli = new CliService(true);
+        const lines = captured(() => {
+            cli.startAction("BUILD", "build prewarm-query");
+            cli.successAction("BUILD");
+        });
+        expect(lines).to.have.lengthOf(0);
+    });
+});

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

@@ -6,8 +6,18 @@ export interface AutoPreWarmContext extends QueryFilterOptions {
     readonly configName: string;
     /** Device classes to warm each url in the variations it was requested in. */
     readonly device?: readonly string[];
+    /** Drop urls the origin mostly answers with a 404. */
+    readonly excludeNotFound?: boolean;
+    /** Keep only the most requested urls. */
+    readonly limit?: number;
     /** Regular expressions the pre-warmed urls have to match. */
     readonly match?: readonly string[];
+    /** Keep only urls requested at least this often in the window. */
+    readonly minHits?: number;
+    /** Athena workgroup the query runs in. */
+    readonly workgroup?: string;
+    /** Athena data catalog the rum tables live in. */
+    readonly catalog?: string;
     /** Variations to pair every url with, when no traffic can reveal them. */
     readonly variation?: readonly string[];
     readonly variationPath?: string;

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

@@ -34,13 +34,18 @@ export class AutoPreWarmFactory {
             days: this.context.days,
             devices: normalizeDevices(this.context.device),
             excludeNoindex: this.context.excludeNoindex,
+            excludeNotFound: this.context.excludeNotFound,
             excludeSuspicious: this.context.excludeSuspicious,
             execute: true,
             hardNavigationsOnly: this.context.hardNavigationsOnly,
             isWindows: this.context.isWindows,
+            limit: this.context.limit,
             match: this.context.match,
+            minHits: this.context.minHits,
             quiet: this.context.quiet,
             variations: this.context.variation,
+            workgroup: this.context.workgroup,
+            catalog: this.context.catalog,
         }, this.userConfig).buildService(QueryType.prewarm);
         const app = queryService.app;
         const rows = await queryService.execute();

package/dist/services/query-builder/queries/page-source.d.ts

@@ -1,7 +1,16 @@
 import { RuleSubjectExpressions } from "../rules/index.js";
 import { QueryInput } from "./query-model.js";
-/** The relation every query reads from. */
-export declare const PAGE_IMPRESSIONS = "live.rum.pi";
+/** The database and table every query reads from, within its catalog. */
+export declare const PAGE_IMPRESSIONS = "rum.pi";
+/**
+ * The relation every query reads from, qualified by the catalog it lives in.
+ *
+ * The catalog is named in the query and not only in the context it runs in, so
+ * that a query pasted into the Athena console reads the same tables as the one
+ * the CLI ran — the console resolves an unqualified name against whichever
+ * catalog its dropdown happens to hold.
+ */
+export declare function pageImpressions(catalog?: string): string;
 /** The name of the common table expression the queries select from. */
 export declare const PAGE_SOURCE = "pages";
 export interface PageSource {

package/dist/services/query-builder/queries/page-source.js

@@ -2,8 +2,20 @@ import { column, formatPredicate } from "../sql/index.js";
 import { resolvedSubject, urlSubjects, } from "../rules/index.js";
 import { normalizeDevices } from "./device.js";
 import { buildRowFilter } from "./page-filter.js";
-/** The relation every query reads from. */
-export const PAGE_IMPRESSIONS = "live.rum.pi";
+import { athenaCatalog } from "../../athena/athena-service-model.js";
+/** The database and table every query reads from, within its catalog. */
+export const PAGE_IMPRESSIONS = "rum.pi";
+/**
+ * The relation every query reads from, qualified by the catalog it lives in.
+ *
+ * The catalog is named in the query and not only in the context it runs in, so
+ * that a query pasted into the Athena console reads the same tables as the one
+ * the CLI ran — the console resolves an unqualified name against whichever
+ * catalog its dropdown happens to hold.
+ */
+export function pageImpressions(catalog) {
+    return `${athenaCatalog(catalog)}.${PAGE_IMPRESSIONS}`;
+}
 /** The name of the common table expression the queries select from. */
 export const PAGE_SOURCE = "pages";
 const COLUMN_NAMES = {
@@ -37,7 +49,7 @@ export function buildPageSource(input, options = {}) {
     const cte = `${PAGE_SOURCE} as (
   select
     ${projections.join(",\n    ")}
-  from ${PAGE_IMPRESSIONS}
+  from ${pageImpressions(input.catalog)}
   where ${formatPredicate(buildRowFilter(input), { level: 2 })}
 )`;
     // An unused subject keeps its inline expression: nothing refers to it, and

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

@@ -61,6 +61,8 @@ export interface ParameterOptions {
 /** Everything a query is built from. */
 export interface QueryInput extends ParameterOptions, PrewarmOptions {
     readonly app: string;
+    /** The data catalog the rum tables live in. Defaults to `live`. */
+    readonly catalog?: string;
     /** Size of the window the query looks at, in days. */
     readonly days: number;
     /** Drop page impressions of pages marked `noindex`. */

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

@@ -188,6 +188,23 @@ describe("the --variation pairing", () => {
         expect(buildPrewarmQuery(inputFor(CONFIG, { variations: ["it's"] })).sql).to.contain("array['it''s']");
     });
 });
+describe("the --catalog the query reads from", () => {
+    it("should read the rum tables from the live catalog by default", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG)).sql).to.contain("from live.rum.pi");
+        expect(buildParameterQuery(inputFor(CONFIG)).sql).to.contain("from live.rum.pi");
+    });
+    it("should read from the live catalog when given a blank one", () => {
+        expect(buildPrewarmQuery(inputFor(CONFIG, { catalog: "" })).sql).to.contain("from live.rum.pi");
+    });
+    it("should name the catalog it was given instead", () => {
+        // Which catalog holds the tables depends on the credentials: our own
+        // logins see them under `live`, a role scoped to one account under
+        // `AwsDataCatalog`.
+        const options = { catalog: "AwsDataCatalog" };
+        expect(buildPrewarmQuery(inputFor(CONFIG, options)).sql).to.contain("from AwsDataCatalog.rum.pi");
+        expect(buildParameterQuery(inputFor(CONFIG, options)).sql).to.not.contain("live.rum.pi");
+    });
+});
 describe("the --count report", () => {
     it("should count the urls and the traffic they stand for", () => {
         const { sql } = buildPrewarmQuery(inputFor(CONFIG, { count: true }));

package/dist/services/query-builder/query-builder-factory.js

@@ -25,6 +25,7 @@ export class QueryBuilderFactory {
         const serviceContext = {
             app,
             bySet: this.context.bySet,
+            catalog: this.context.catalog,
             count: this.context.count,
             days: this.context.days,
             devices: this.context.devices,
@@ -47,7 +48,7 @@ export class QueryBuilderFactory {
         // The Athena service is only needed when the query is executed directly —
         // which `--count` is, a count query being of no use as text.
         const athenaService = this.context.execute || this.context.count
-            ? await new AthenaServiceFactory(app).getService()
+            ? await new AthenaServiceFactory(app, this.context.workgroup, this.context.catalog).getService()
             : undefined;
         return new QueryBuilderService(serviceContext, parseRuleSets(speedKitConfig), cli, athenaService);
     }