@speedkit/cli 4.26.0 → 4.27.0

package/dist/helpers/clipboard.js

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+import clipboardy from "clipboardy";
+/** How long a clipboard tool may take before the CLI stops waiting for it. */
+const TIMEOUT_IN_MS = 2000;
+/**
+ * Puts text on the system clipboard, and never holds up the CLI.
+ *
+ * `clipboardy.writeSync` cannot be used on Wayland. It runs `wl-copy` through
+ * `execaSync`, and `wl-copy` has to *stay alive* to own the selection — there
+ * is no clipboard daemon on Wayland, the source process serves the data. It
+ * forks into the background but inherits the pipes `execa` created, so the
+ * synchronous wait never returns: the command hangs after the work is done,
+ * with the output still unwritten, until the user interrupts it.
+ *
+ * On Wayland the tool is therefore started the way it wants to be — detached,
+ * with its output going nowhere, and unreferenced so Node can exit while it
+ * keeps serving the clipboard. Everywhere else `clipboardy` is used as before,
+ * behind a timeout, so no clipboard tool can ever be the reason a command
+ * appears to do nothing.
+ *
+ * @returns whether the text reached the clipboard.
+ */
+export async function copyToClipboard(text) {
+    if (isWayland()) {
+        const copied = await copyWithWaylandClipboard(text);
+        if (copied) {
+            return true;
+        }
+    }
+    try {
+        return await withTimeout(clipboardy.write(text).then(() => true));
+    }
+    catch {
+        return false;
+    }
+}
+function isWayland() {
+    return process.platform === "linux" && !!process.env.WAYLAND_DISPLAY;
+}
+/** Hands the text to `wl-copy` and leaves it running to serve the selection. */
+function copyWithWaylandClipboard(text) {
+    return new Promise((resolve) => {
+        const copy = spawn("wl-copy", ["--type", "text/plain"], {
+            detached: true,
+            // Anything but `ignore` here is what makes the call hang.
+            stdio: ["pipe", "ignore", "ignore"],
+        });
+        copy.on("error", () => resolve(false));
+        copy.on("spawn", () => {
+            copy.stdin.end(text, () => {
+                copy.unref();
+                resolve(true);
+            });
+        });
+    });
+}
+async function withTimeout(copied) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(false), TIMEOUT_IN_MS);
+        // A pending timer must not keep the process alive on its own.
+        timer.unref();
+    });
+    try {
+        return await Promise.race([copied, expired]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/helpers/evaluate-speed-kit-config.d.ts

@@ -1,21 +1,11 @@
 import { InstallResourceFile } from "../services/integration-api/index.js";
-export declare function evaluateLocalSpeedKitConfig(app: string, origin: string, speedKitConfigFile: InstallResourceFile): Promise<{
-    split: any;
-    splitTestId: any;
-    detectDevice: () => void;
-    customVariation: any[];
-}>;
+/**
+ * The `window.speedKit` a config assigned — whatever shape the config wrote,
+ * not the seed object the browser mock starts from.
+ */
+export type EvaluatedSpeedKitConfig = Record<string, any>;
+export declare function evaluateLocalSpeedKitConfig(app: string, origin: string, speedKitConfigFile: InstallResourceFile): Promise<EvaluatedSpeedKitConfig>;
 export declare function evaluateLocalAndRemoteSpeedKit(app: string, origin: string, speedKitConfigFile: InstallResourceFile, activeSpeedKitConfig: string): Promise<{
-    localSpeedKit: {
-        split: any;
-        splitTestId: any;
-        detectDevice: () => void;
-        customVariation: any[];
-    };
-    remoteSpeedKit: {
-        split: any;
-        splitTestId: any;
-        detectDevice: () => void;
-        customVariation: any[];
-    };
+    localSpeedKit: EvaluatedSpeedKitConfig;
+    remoteSpeedKit: EvaluatedSpeedKitConfig;
 }>;

package/dist/helpers/evaluate-speed-kit-config.js

@@ -78,14 +78,16 @@ function buildBrowserMock(origin, app) {
         top: {},
     };
     window.top = window;
+    // A config may read the DOM while it builds itself — `precache` is
+    // frequently a list of script and link hrefs. There is no document here, so
+    // these answer the way the DOM answers for a page without matches: an empty
+    // list, not `undefined`, which `Array.from` and `forEach` would choke on.
     const document = {
         cookie: "",
-        querySelector: () => {
-            /* empty */
-        },
-        querySelectorAll: () => {
-            /* empty */
-        },
+        referrer: "",
+        getElementById: () => null,
+        querySelector: () => null,
+        querySelectorAll: () => [],
         createElement: () => {
             /* empty */
         },

package/dist/helpers/evaluate-speed-kit-config.spec.d.ts

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

package/dist/helpers/evaluate-speed-kit-config.spec.js

@@ -0,0 +1,78 @@
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { evaluateLocalSpeedKitConfig } from "./evaluate-speed-kit-config.js";
+function configFile(source) {
+    return {
+        getContent: () => source,
+        path: "config_SpeedKit.js",
+    };
+}
+function evaluate(source) {
+    return evaluateLocalSpeedKitConfig("shop-de", "https://www.shop.de", configFile(source));
+}
+describe("evaluateLocalSpeedKitConfig", () => {
+    it("should read the app and the origin the config is evaluated for", async () => {
+        const speedKit = await evaluate(`
+      window.speedKit = { appName: APP, host: window.location.host };
+    `);
+        expect(speedKit.appName).to.equal("shop-de");
+        expect(speedKit.host).to.equal("www.shop.de");
+    });
+    it("should evaluate a config that reads the dom while it builds itself", async () => {
+        // A real shape: `precache` is collected from the document's own script and
+        // link tags. A `querySelectorAll` returning undefined would throw here,
+        // and the whole config — every rule in it — would be unreadable.
+        const speedKit = await evaluate(`
+      window.speedKit = {
+        appName: APP,
+        precache: Array.from(
+          document.querySelectorAll('script[src], link[rel="stylesheet"]'),
+        ).map(function (element) {
+          return element.getAttribute('src');
+        }),
+        enabledSites: [{ pathname: [/^\\/p\\//i] }],
+      };
+    `);
+        expect(speedKit.precache).to.deep.equal([]);
+        expect(speedKit.enabledSites).to.have.lengthOf(1);
+    });
+    it("should expose the location a config branches on (ED-409)", async () => {
+        // nbb reads `window.location.hostname` to pick its split, and read
+        // `document.referrer` to tell a new visitor from a returning one. When
+        // `window.location` was undefined this failed with
+        // "Cannot read properties of undefined (reading 'hostname')".
+        const speedKit = await evaluate(`
+      var hostname = window.location.hostname;
+      var isNewUser = !document.referrer;
+      window.speedKit = {
+        appName: APP,
+        hostname: hostname,
+        alsoHostname: location.hostname,
+        isNewUser: isNewUser,
+      };
+    `);
+        expect(speedKit.hostname).to.equal("www.shop.de");
+        expect(speedKit.alsoHostname).to.equal("www.shop.de");
+        expect(speedKit.isNewUser).to.equal(true);
+    });
+    it("should answer a missing element with null, the way the dom does", async () => {
+        const speedKit = await evaluate(`
+      window.speedKit = {
+        appName: APP,
+        hasMarker: document.querySelector('.marker') !== null,
+        byId: document.getElementById('marker'),
+      };
+    `);
+        expect(speedKit.hasMarker).to.equal(false);
+        expect(speedKit.byId).to.equal(null);
+    });
+    it("should report what the config itself throws", async () => {
+        try {
+            await evaluate(`window.speedKit = { appName: nothingHere.atAll };`);
+            expect.fail("should have thrown");
+        }
+        catch (error) {
+            expect(String(error)).to.contain("config_Speedkit.js");
+        }
+    });
+});

package/dist/models/cli-parameters.d.ts

@@ -4,16 +4,30 @@ export declare enum CLIParameters {
     ConfigName = "configName",
     ContentTypes = "contentTypes",
     Cookies = "cookies",
+    Count = "count",
     CreateTests = "CreateTests",
     CustomerPath = "customerPath",
     CustomersDirectory = "customersDirectory",
+    Days = "days",
     Delay = "delay",
+    Device = "device",
     Domain = "domain",
     DryRun = "dryRun",
+    Execute = "execute",
+    BySet = "bySet",
+    ExcludeNoindex = "excludeNoindex",
+    ExcludeNotFound = "excludeNotFound",
+    ExcludeSuspicious = "excludeSuspicious",
+    Explain = "explain",
     Group = "group",
+    HardNavigationsOnly = "hardNavigationsOnly",
     HideDiff = "hideDiff",
     Ips = "ips",
     KeepParameterSorting = "keepParameterSorting",
+    Limit = "limit",
+    Match = "match",
+    MinHits = "minHits",
+    MinImpressions = "minImpressions",
     Quiet = "quiet",
     Mobile = "mobile",
     PageUrl = "pageUrl",
@@ -35,9 +49,11 @@ export declare enum CLIParametersChar {
     CreateTests = "t",
     CustomerPath = "p",
     CustomersDirectory = "d",
+    Days = "d",
     Delay = "d",
     Domain = "d",
     DryRun = "d",
+    Execute = "e",
     Group = "g",
     HideDiff = "h",
     Ips = "i",
@@ -59,9 +75,11 @@ export declare enum CLIParametersExample {
     CustomerPath = "customers/decathlon.de",
     CustomersDirectory = "customers",
     Delay = "1200",
+    Devices = "desktop,mobile",
     Domain = "www.decathlon.de",
     Group = "B",
     Ips = "151.101.120.194",
+    Match = "^/p/",
     Mobile = "Y",
     PageUrl = "https://www.decathlon.de/",
     Path = "C:\\Users\\testUser\\file.csv",
@@ -78,6 +96,61 @@ export declare const CLI_CONFIG_NAME: {
 export declare const CLI_CONFIG_IS_TEST: {
     useTestConfig: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
+/** Shared wording, so every query command describes the window the same way. */
+export declare const CLI_QUERY_DAYS_DESCRIPTION = "Number of days the query looks back";
+/**
+ * How far back a query looks. Its own object because `generate-pop-config`
+ * takes it without the `-d` shorthand, which `--deploy` holds there.
+ */
+export declare const CLI_QUERY_DAYS: {
+    days: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+};
+/**
+ * What a query command does with the query it built. Both commands take them,
+ * so a query can be piped or run without a detour through the clipboard.
+ */
+export declare const CLI_QUERY_OUTPUT: {
+    execute: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+/**
+ * Which page impressions a query leaves out, and whether to account for every
+ * rule it does not carry over literally. Bots are always excluded.
+ */
+export declare const CLI_QUERY_FILTERS: {
+    excludeNoindex: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    excludeSuspicious: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    explain: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    hardNavigationsOnly: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+/**
+ * Which variation the pre-warm list carries per url, instead of leaving the
+ * pre-warmer to request every url in every variation.
+ *
+ * The two flags answer the same question from two different sources — the
+ * traffic, or the operator — so combining them would cross-produce the list
+ * again, which is what they are there to stop. A command that also reads a
+ * variations file from disk excludes that one on its own side.
+ */
+export declare const CLI_QUERY_VARIATIONS: {
+    device: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+    variation: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+};
+/** What the pre-warm query keeps of a long tail that is mostly seen once. */
+export declare const CLI_QUERY_PREWARM: {
+    count: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    excludeNotFound: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    match: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+    minHits: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    device: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+    variation: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+};
+/** How the parameter query presents what it found. */
+export declare const CLI_QUERY_PARAMETER: {
+    bySet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    minImpressions: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+};
 export declare const CLI_CUSTOMER_CONFIG: {
     customerPath: import("@oclif/core/interfaces").Arg<string, {
         exists?: boolean;

package/dist/models/cli-parameters.js

@@ -1,4 +1,9 @@
 import { Args, Flags } from "@oclif/core";
+// Imported from the modules rather than from the query-builder barrels: this
+// file is loaded by every command, and the rules barrel pulls in the automata
+// library.
+import { parseMatchPattern } from "../services/query-builder/rules/match-pattern.js";
+import { DEVICE_VARIATIONS } from "../services/query-builder/queries/device.js";
 export var CLIParameters;
 (function (CLIParameters) {
     CLIParameters["AppName"] = "app";
@@ -6,16 +11,30 @@ export var CLIParameters;
     CLIParameters["ConfigName"] = "configName";
     CLIParameters["ContentTypes"] = "contentTypes";
     CLIParameters["Cookies"] = "cookies";
+    CLIParameters["Count"] = "count";
     CLIParameters["CreateTests"] = "CreateTests";
     CLIParameters["CustomerPath"] = "customerPath";
     CLIParameters["CustomersDirectory"] = "customersDirectory";
+    CLIParameters["Days"] = "days";
     CLIParameters["Delay"] = "delay";
+    CLIParameters["Device"] = "device";
     CLIParameters["Domain"] = "domain";
     CLIParameters["DryRun"] = "dryRun";
+    CLIParameters["Execute"] = "execute";
+    CLIParameters["BySet"] = "bySet";
+    CLIParameters["ExcludeNoindex"] = "excludeNoindex";
+    CLIParameters["ExcludeNotFound"] = "excludeNotFound";
+    CLIParameters["ExcludeSuspicious"] = "excludeSuspicious";
+    CLIParameters["Explain"] = "explain";
     CLIParameters["Group"] = "group";
+    CLIParameters["HardNavigationsOnly"] = "hardNavigationsOnly";
     CLIParameters["HideDiff"] = "hideDiff";
     CLIParameters["Ips"] = "ips";
     CLIParameters["KeepParameterSorting"] = "keepParameterSorting";
+    CLIParameters["Limit"] = "limit";
+    CLIParameters["Match"] = "match";
+    CLIParameters["MinHits"] = "minHits";
+    CLIParameters["MinImpressions"] = "minImpressions";
     CLIParameters["Quiet"] = "quiet";
     CLIParameters["Mobile"] = "mobile";
     CLIParameters["PageUrl"] = "pageUrl";
@@ -39,9 +58,11 @@ export var CLIParametersChar;
     CLIParametersChar["CreateTests"] = "t";
     CLIParametersChar["CustomerPath"] = "p";
     CLIParametersChar["CustomersDirectory"] = "d";
+    CLIParametersChar["Days"] = "d";
     CLIParametersChar["Delay"] = "d";
     CLIParametersChar["Domain"] = "d";
     CLIParametersChar["DryRun"] = "d";
+    CLIParametersChar["Execute"] = "e";
     CLIParametersChar["Group"] = "g";
     CLIParametersChar["HideDiff"] = "h";
     CLIParametersChar["Ips"] = "i";
@@ -65,9 +86,11 @@ export var CLIParametersExample;
     CLIParametersExample["CustomerPath"] = "customers/decathlon.de";
     CLIParametersExample["CustomersDirectory"] = "customers";
     CLIParametersExample["Delay"] = "1200";
+    CLIParametersExample["Devices"] = "desktop,mobile";
     CLIParametersExample["Domain"] = "www.decathlon.de";
     CLIParametersExample["Group"] = "B";
     CLIParametersExample["Ips"] = "151.101.120.194";
+    CLIParametersExample["Match"] = "^/p/";
     CLIParametersExample["Mobile"] = "Y";
     CLIParametersExample["PageUrl"] = "https://www.decathlon.de/";
     CLIParametersExample["Path"] = "C:\\Users\\testUser\\file.csv";
@@ -95,6 +118,134 @@ export const CLI_CONFIG_IS_TEST = {
         description: "Override app with configured testApp",
     }),
 };
+/** Shared wording, so every query command describes the window the same way. */
+export const CLI_QUERY_DAYS_DESCRIPTION = "Number of days the query looks back";
+/**
+ * How far back a query looks. Its own object because `generate-pop-config`
+ * takes it without the `-d` shorthand, which `--deploy` holds there.
+ */
+export const CLI_QUERY_DAYS = {
+    [CLIParameters.Days]: Flags.integer({
+        char: CLIParametersChar.Days,
+        description: CLI_QUERY_DAYS_DESCRIPTION,
+        min: 1,
+        required: false,
+    }),
+};
+/**
+ * What a query command does with the query it built. Both commands take them,
+ * so a query can be piped or run without a detour through the clipboard.
+ */
+export const CLI_QUERY_OUTPUT = {
+    [CLIParameters.Execute]: Flags.boolean({
+        char: CLIParametersChar.Execute,
+        default: false,
+        description: "Execute the query directly and write the result to a <app>-<date>-<query>.csv file",
+    }),
+    [CLIParameters.Quiet]: Flags.boolean({
+        char: CLIParametersChar.Quiet,
+        default: false,
+        description: "Output only the raw query without clipboard copy or styling",
+    }),
+};
+/**
+ * Which page impressions a query leaves out, and whether to account for every
+ * rule it does not carry over literally. Bots are always excluded.
+ */
+export const CLI_QUERY_FILTERS = {
+    [CLIParameters.ExcludeNoindex]: Flags.boolean({
+        default: false,
+        description: "Exclude page impressions of pages marked noindex",
+    }),
+    [CLIParameters.ExcludeSuspicious]: Flags.boolean({
+        default: false,
+        description: "Exclude page impressions Speed Kit classified as suspicious",
+    }),
+    [CLIParameters.Explain]: Flags.boolean({
+        default: false,
+        description: "Account for every rule the query leaves out, reduces or approximates",
+    }),
+    [CLIParameters.HardNavigationsOnly]: Flags.boolean({
+        default: false,
+        description: "Exclude soft (SPA) navigations",
+    }),
+};
+/**
+ * Which variation the pre-warm list carries per url, instead of leaving the
+ * pre-warmer to request every url in every variation.
+ *
+ * The two flags answer the same question from two different sources — the
+ * traffic, or the operator — so combining them would cross-produce the list
+ * again, which is what they are there to stop. A command that also reads a
+ * variations file from disk excludes that one on its own side.
+ */
+export const CLI_QUERY_VARIATIONS = {
+    [CLIParameters.Device]: Flags.string({
+        delimiter: ",",
+        description: "Split the list by device class, so every url is warmed in the variations it was actually requested in. A class not named is left out",
+        exclusive: [CLIParameters.Variation],
+        multiple: true,
+        options: [...DEVICE_VARIATIONS],
+        required: false,
+    }),
+    [CLIParameters.Variation]: Flags.string({
+        char: CLIParametersChar.Variation,
+        delimiter: ",",
+        description: "Pair every url of the list with each of these variations. For the custom variations no traffic can reveal, e.g. 'desktop-pdp-a,mobile-pdp-a'",
+        exclusive: [CLIParameters.Device],
+        multiple: true,
+        required: false,
+    }),
+};
+/** What the pre-warm query keeps of a long tail that is mostly seen once. */
+export const CLI_QUERY_PREWARM = {
+    ...CLI_QUERY_VARIATIONS,
+    [CLIParameters.Count]: Flags.boolean({
+        default: false,
+        description: "Run the query and report how large the list is instead of what is in it: urls, the impressions they stand for, and a row per variation where the list carries variations. Every other flag still applies, so this counts the list the same command would produce",
+        exclusive: [CLIParameters.Execute],
+    }),
+    [CLIParameters.ExcludeNotFound]: Flags.boolean({
+        default: false,
+        description: "Leave out urls the origin answers with a 404 more often than not",
+    }),
+    [CLIParameters.Limit]: Flags.integer({
+        description: "Keep only the most requested urls",
+        min: 1,
+        required: false,
+    }),
+    [CLIParameters.Match]: Flags.string({
+        description: "Keep only urls whose path matches this regular expression, e.g. '^/p/'. The path is matched with its query string, the way a version 1 pathname rule matches it, so '[?&]size=' works too. Repeat the flag to keep the urls matching any of several patterns, and start a pattern with (?i) to match case-insensitively",
+        multiple: true,
+        parse: async (input) => {
+            try {
+                parseMatchPattern(input);
+            }
+            catch (error) {
+                throw new Error(`--match ${input} is not a regular expression: ${error.message}`, { cause: error });
+            }
+            return input;
+        },
+        required: false,
+    }),
+    [CLIParameters.MinHits]: Flags.integer({
+        description: "Keep only urls requested at least this often in the window",
+        min: 1,
+        required: false,
+    }),
+};
+/** How the parameter query presents what it found. */
+export const CLI_QUERY_PARAMETER = {
+    [CLIParameters.BySet]: Flags.boolean({
+        default: false,
+        description: "Rank whole sets of parameters instead of single parameters, to see which ones travel together",
+    }),
+    [CLIParameters.MinImpressions]: Flags.integer({
+        description: "Leave out parameters seen on fewer page impressions than this",
+        min: 1,
+        required: false,
+    }),
+};
 export const CLI_CUSTOMER_CONFIG = {
     [CLIParameters.CustomerPath]: Args.directory({
         name: CLIParameters.CustomerPath,

package/dist/models/cli-parameters.spec.d.ts

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

package/dist/models/cli-parameters.spec.js

@@ -0,0 +1,47 @@
+import { parse } from "@oclif/core/parser";
+import { expect } from "chai";
+import { describe, it } from "mocha";
+import { CLI_QUERY_VARIATIONS } from "./cli-parameters.js";
+async function parseFlags(argv) {
+    const { flags } = await parse(argv, { flags: CLI_QUERY_VARIATIONS });
+    return flags;
+}
+/** The message the parser refused the arguments with. */
+async function refusal(argv) {
+    try {
+        await parseFlags(argv);
+    }
+    catch (error) {
+        return error.message;
+    }
+    throw new Error(`Expected ${argv.join(" ")} to be refused`);
+}
+/** What the parser has to catch before Athena is asked anything. */
+describe("the --device and --variation flags", () => {
+    it("should read a comma separated list of devices", async () => {
+        expect(await parseFlags(["--device", "desktop,mobile"])).to.deep.equal({
+            device: ["desktop", "mobile"],
+        });
+    });
+    it("should read a comma separated list of variations", async () => {
+        expect(await parseFlags(["-v", "men,women"])).to.deep.equal({
+            variation: ["men", "women"],
+        });
+    });
+    it("should refuse a device class that does not exist", async () => {
+        // A typo has to fail here rather than produce a query that scans a whole
+        // window and returns nothing.
+        expect(await refusal(["--device", "phone"])).to.contain("Expected --device=phone to be one of: desktop, mobile, tablet");
+    });
+    it("should refuse a device class hidden among valid ones", async () => {
+        expect(await refusal(["--device", "desktop,tv"])).to.contain("to be one of");
+    });
+    it("should refuse the two flags together", async () => {
+        // They answer the same question from two sources; together they would
+        // cross-produce the list again.
+        expect(await refusal(["--device", "desktop", "--variation", "men"])).to.contain("cannot also be provided");
+    });
+    it("should take neither by default", async () => {
+        expect(await parseFlags([])).to.deep.equal({});
+    });
+});

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

@@ -12,6 +12,8 @@ export declare class AwsAthenaService implements AthenaService {
     private cli;
     constructor(client: AthenaClient, cli: CliServiceInterface);
     getResult<T>(query: string, parameters?: string[], maxAgeInMinutes?: number): Promise<T[]>;
+    /** The query, from sending it off to the rows it produced. */
+    private runAndFetch;
     private castValueToType;
     /**
      * Fetch the query result of the given query id, if the result is still available

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 {};