@speedkit/cli 4.26.0 → 4.27.0

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

@@ -0,0 +1,86 @@
+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";
+/**
+ * The bugs that prompted the rework, each with the config that reported it.
+ *
+ * A golden query shows the whole output; these name the defect, so a
+ * regression fails with the ticket it belongs to rather than as an
+ * unexplained diff.
+ */
+function inputFor(config, hosts) {
+    return {
+        app: "shop",
+        days: 30,
+        hosts,
+        now: new Date("2026-09-04T09:30:00Z"),
+        ruleSets: parseRuleSets(config),
+    };
+}
+describe("ED-277: a query from whitelisted pathnames", () => {
+    // The whitelist carried the page scope, and only its host was ever read, so
+    // the pathnames never reached the query.
+    const config = {
+        whitelist: [
+            {
+                contentType: ["navigate"],
+                host: ["www.hugendubel.de"],
+                pathname: [/\/de$/, /\/category/, /\.html/],
+            },
+        ],
+    };
+    const { sql } = buildPrewarmQuery(inputFor(config, ["www.hugendubel.de"]));
+    it("should filter on the whitelisted host", () => {
+        expect(sql).to.contain("lower(host) like 'www.hugendubel.de%'");
+    });
+    it("should filter on every whitelisted pathname", () => {
+        expect(sql).to.contain(String.raw `regexp_like(pathWithSearch, '/de$')`);
+        expect(sql).to.contain(String.raw `regexp_like(pathWithSearch, '/category')`);
+        expect(sql).to.contain(String.raw `regexp_like(pathWithSearch, '\.html')`);
+    });
+    it("should or the pathnames and and them with the host", () => {
+        const clause = sql.slice(sql.indexOf("  where lower(host)"));
+        expect(clause).to.match(/where lower\(host\) like[^\n]*\n {4}and \(/);
+        expect(clause).to.contain("\n      or regexp_like(pathWithSearch");
+    });
+    it("should match the pathname the way the rule set version does", () => {
+        // No ruleSetConfig means version 1, where the runtime tests a pathname
+        // against `pathname + search` — not against the path alone.
+        expect(sql).to.not.contain("regexp_like(path,");
+    });
+});
+describe("ED-408: a pathname-scoped stripQueryParams rule", () => {
+    // `params: /.*/` was applied to every key of every page, so no key ever
+    // survived the filter and the analysis came back empty.
+    const config = {
+        ruleSetConfig: { version: 2 },
+        stripQueryParams: [
+            { params: /.*/, rules: [{ pathname: "/hoteldetail/" }] },
+            { params: ["_ga"] },
+        ],
+        whitelist: [{ host: ["www.alltours.de"] }],
+    };
+    const { sql } = buildParameterQuery(inputFor(config, ["www.alltours.de"]));
+    it("should reject a key only on the scoped pathname", () => {
+        expect(sql).to.contain([
+            "(key) -> not (",
+            "          lower(path) = '/hoteldetail/'",
+            "          and regexp_like(key, '.*')",
+            "        )",
+        ].join("\n"));
+    });
+    it("should keep rejecting the unscoped parameters everywhere", () => {
+        expect(sql).to.contain("and not (lower(key) = '_ga')");
+    });
+    it("should scope the cache key the same way", () => {
+        // The cache key is built from the parameters that survive the very same
+        // filter, so the scope cannot apply to one and not the other.
+        expect(sql).to.contain("filter(pairs, (pair) -> contains(keptKeys, split(pair, '=')[1]))");
+        expect(sql).to.contain("path || '?' || array_join(pairs, '&') as cacheKey");
+    });
+    it("should never strip every parameter unconditionally", () => {
+        expect(sql).to.not.contain("(key) -> not regexp_like(key, '.*')");
+    });
+});

package/dist/services/query-builder/query-builder-factory.d.ts

@@ -1,11 +1,11 @@
 import { QueryBuilderService } from "./query-builder-service.js";
-import { QueryBuilderFactoryContext, QueryTpe } from "./query-builder-model.js";
+import { QueryBuilderFactoryContext, QueryType } from "./query-builder-model.js";
 import { UserCliConfig } from "../../helpers/cli-config.js";
 export declare class QueryBuilderFactory {
     private context;
     private userConfig;
     constructor(context: QueryBuilderFactoryContext, userConfig: UserCliConfig);
-    buildService(queryType: QueryTpe): Promise<QueryBuilderService>;
+    buildService(queryType: QueryType): Promise<QueryBuilderService>;
     private getIntegrationFiles;
     private getSpeedKitConfig;
 }

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

@@ -1,4 +1,5 @@
 import { QueryBuilderService } from "./query-builder-service.js";
+import { parseRuleSets } from "./rules/index.js";
 import { IntegrationApiContext, IntegrationApiFactory, } from "../integration-api/index.js";
 import { INTEGRATION_FILES } from "../../models/files.js";
 import { CliServiceFactory } from "../cli/index.js";
@@ -18,21 +19,37 @@ export class QueryBuilderFactory {
         const files = await this.getIntegrationFiles();
         const customerConfig = files.getCustomerConfig().config;
         const app = customerConfig.app;
-        const origin = customerConfig.origins[0];
+        const origins = customerConfig.origins ?? [];
         const speedKitConfigFile = files.getByName(INTEGRATION_FILES.CONFIG.SPEED_KIT);
-        const speedKitConfig = await this.getSpeedKitConfig(app, origin, speedKitConfigFile);
+        const speedKitConfig = await this.getSpeedKitConfig(app, origins[0], speedKitConfigFile);
         const serviceContext = {
             app,
-            queryType,
+            bySet: this.context.bySet,
+            count: this.context.count,
+            days: this.context.days,
+            devices: this.context.devices,
+            excludeNotFound: this.context.excludeNotFound,
+            excludeNoindex: this.context.excludeNoindex,
+            excludeSuspicious: this.context.excludeSuspicious,
+            execute: this.context.execute,
+            explain: this.context.explain,
+            hardNavigationsOnly: this.context.hardNavigationsOnly,
+            hosts: toHosts(origins),
             isWindows: this.context.isWindows,
+            limit: this.context.limit,
+            match: this.context.match,
+            minHits: this.context.minHits,
+            minImpressions: this.context.minImpressions,
+            queryType,
             quiet: this.context.quiet,
-            execute: this.context.execute,
+            variations: this.context.variations,
         };
-        // The Athena service is only needed when the query is executed directly.
-        const athenaService = this.context.execute
+        // 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()
             : undefined;
-        return new QueryBuilderService(serviceContext, speedKitConfig, cli, athenaService);
+        return new QueryBuilderService(serviceContext, parseRuleSets(speedKitConfig), cli, athenaService);
     }
     async getIntegrationFiles() {
         const integrationApiContext = new IntegrationApiContext(this.context.customerPath, this.context.configName, ["config_SpeedKit"]);
@@ -49,3 +66,14 @@ export class QueryBuilderFactory {
         return result.data;
     }
 }
+/** The host of every origin, ignoring the ones that are not a URL. */
+function toHosts(origins) {
+    const hosts = [];
+    for (const origin of origins) {
+        const result = safe(() => new URL(origin).host);
+        if (result.success === true) {
+            hosts.push(result.data);
+        }
+    }
+    return hosts;
+}

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

@@ -1,24 +1,36 @@
-export interface QueryBuilderContext {
-    isWindows?: boolean;
-    quiet?: boolean;
-    execute?: boolean;
-    queryType: QueryTpe;
-    app: string;
+import { ParameterOptions, PrewarmOptions } from "./queries/query-model.js";
+export declare enum QueryType {
+    parameter = "parameter",
+    prewarm = "prewarm"
 }
-export interface QueryBuilderFactoryContext {
-    readonly customerPath: string;
-    readonly configName: string;
+/** Options that narrow the rows a query looks at. */
+export interface QueryFilterOptions {
+    /** Size of the window the query looks at, in days. */
+    readonly days?: number;
+    /** Drop page impressions of pages marked `noindex`. */
+    readonly excludeNoindex?: boolean;
+    /** Drop page impressions Speed Kit classified as suspicious. */
+    readonly excludeSuspicious?: boolean;
+    /** Keep hard navigations only, dropping soft (SPA) navigations. */
+    readonly hardNavigationsOnly?: boolean;
+}
+export interface QueryBuilderContext extends ParameterOptions, PrewarmOptions, QueryFilterOptions {
+    readonly app: string;
+    readonly execute?: boolean;
+    /** Report every rule the query leaves out, reduces or approximates. */
+    readonly explain?: boolean;
+    /** Hosts of the app's origins. */
+    readonly hosts?: readonly string[];
     readonly isWindows?: boolean;
+    readonly queryType: QueryType;
     readonly quiet?: boolean;
-    readonly execute?: boolean;
-}
-export declare enum QueryTpe {
-    prewarm = "prewarm",
-    parameter = "parameter"
 }
-export interface SpeedKitConfig {
-    ruleSetConfig?: {
-        version?: string;
-    };
-    [key: string]: any;
+export interface QueryBuilderFactoryContext extends ParameterOptions, PrewarmOptions, QueryFilterOptions {
+    readonly configName: string;
+    readonly customerPath: string;
+    readonly execute?: boolean;
+    /** Report every rule the query leaves out, reduces or approximates. */
+    readonly explain?: boolean;
+    readonly isWindows?: boolean;
+    readonly quiet?: boolean;
 }

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

@@ -1,5 +1,5 @@
-export var QueryTpe;
-(function (QueryTpe) {
-    QueryTpe["prewarm"] = "prewarm";
-    QueryTpe["parameter"] = "parameter";
-})(QueryTpe || (QueryTpe = {}));
+export var QueryType;
+(function (QueryType) {
+    QueryType["parameter"] = "parameter";
+    QueryType["prewarm"] = "prewarm";
+})(QueryType || (QueryType = {}));

package/dist/services/query-builder/query-builder-service.d.ts

@@ -1,12 +1,13 @@
-import { QueryBuilderContext, SpeedKitConfig } from "./query-builder-model.js";
+import { QueryBuilderContext } from "./query-builder-model.js";
+import { ParsedRuleSets } from "./rules/index.js";
 import { CliServiceInterface } from "../cli/index.js";
 import { AthenaService } from "../athena/index.js";
 export declare class QueryBuilderService {
     private context;
-    private speedKitConfig;
+    private ruleSets;
     private cli;
     private athenaService?;
-    constructor(context: QueryBuilderContext, speedKitConfig: SpeedKitConfig, cli: CliServiceInterface, athenaService?: AthenaService);
+    constructor(context: QueryBuilderContext, ruleSets: ParsedRuleSets, cli: CliServiceInterface, athenaService?: AthenaService);
     /** The app the query targets, as read from the customer config. */
     get app(): string;
     run(): Promise<void>;
@@ -16,13 +17,33 @@ export declare class QueryBuilderService {
      * directly instead of exporting it (e.g. `auto-prewarm`).
      */
     execute<T>(): Promise<T[]>;
+    /** The query as SQL. */
+    query(): string;
+    private build;
+    /**
+     * Points out where the query is not exactly what the config says — a rule
+     * left out, a rule the query can only approximate, a pattern Athena reads
+     * differently than the browser — plus what the config itself gets wrong.
+     *
+     * Reductions are silent unless asked for: a rule another rule already
+     * decides is not a divergence, it is arithmetic.
+     */
+    private report;
+    /** The same accounting as {@link report}, as plain lines. */
+    private reportLines;
     private runQuery;
+    /**
+     * Execute the count query and put its handful of rows on the terminal — a
+     * count is read, not filed, so nothing is written to disk.
+     *
+     * Under `--quiet` the rows go to stdout as tab separated values, so a count
+     * can be read by something other than a person.
+     */
+    private executeAndReportCounts;
     /**
      * Execute the built query against Athena (Baqend native path, AWS fallback)
      * and write the rows to a `<app>-<YYYY-MM-DD>-<queryType>.csv` file in the
      * current working directory.
      */
     private executeAndExport;
-    query(): string;
-    private buildQuery;
 }

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

@@ -1,22 +1,37 @@
-import { getSpeedKitConfigVersion } from "../../helpers/get-parsed-config.js";
-import { getBlacklistedFilter, getParameterFilter, getParameterReplaceFilter, getStrippedParameters, getWhitelistedFilter, } from "../../helpers/build-query-helper.js";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import clipboardy from "clipboardy";
 import json2Csv from "json2csv";
-import { QueryTpe, } from "./query-builder-model.js";
-import { Prewarm } from "./query/prewarm.js";
-import { Parameter } from "./query/parameter.js";
+import { QueryType } from "./query-builder-model.js";
+import { buildParameterQuery, buildPrewarmQuery, DEFAULT_QUERY_DAYS, } from "./queries/index.js";
 import { AthenaBucket } from "../athena/index.js";
+import { copyToClipboard } from "../../helpers/clipboard.js";
 import { safe } from "../../helpers/safe.js";
+/**
+ * The notes as unique lines. Each phase of the reduction reports on its own,
+ * so the same note — the budget running out, above all — can arrive more than
+ * once.
+ */
+function distinct(notes) {
+    return [
+        ...new Set(notes.map(({ reason, source }) => `Reduced ${source}: ${reason}`)),
+    ];
+}
+/**
+ * A count as it is read: grouped in thousands. Athena hands numbers over as
+ * strings, so anything that is not one is passed through untouched.
+ */
+function readable(value) {
+    const text = String(value ?? "");
+    return /^\d+$/.test(text) ? Number(text).toLocaleString("en-US") : text;
+}
 export class QueryBuilderService {
     context;
-    speedKitConfig;
+    ruleSets;
     cli;
     athenaService;
-    constructor(context, speedKitConfig, cli, athenaService) {
+    constructor(context, ruleSets, cli, athenaService) {
         this.context = context;
-        this.speedKitConfig = speedKitConfig;
+        this.ruleSets = ruleSets;
         this.cli = cli;
         this.athenaService = athenaService;
     }
@@ -25,37 +40,49 @@ export class QueryBuilderService {
         return this.context.app;
     }
     async run() {
-        this.cli.startAction(`QUERY:BUILD:${this.context.queryType}`, `build ${this.context.queryType}-query`);
-        const parameters = getStrippedParameters(this.speedKitConfig);
-        const parameterReplaceFilter = getParameterReplaceFilter(parameters, getSpeedKitConfigVersion(this.speedKitConfig));
-        const whitelistedFilter = getWhitelistedFilter(this.speedKitConfig);
-        const blacklistedFilter = getBlacklistedFilter(this.speedKitConfig);
-        const skConfigVersion = getSpeedKitConfigVersion(this.speedKitConfig);
-        const parameterFilter = getParameterFilter(parameters, skConfigVersion);
-        const result = safe(() => this.buildQuery(this.context.app, parameterFilter, whitelistedFilter, blacklistedFilter, parameterReplaceFilter));
-        this.cli.successAction(`QUERY:BUILD:${this.context.queryType}`);
+        const action = `QUERY:BUILD:${this.context.queryType}`;
+        this.cli.startAction(action, `build ${this.context.queryType}-query`);
+        const result = safe(() => this.build());
         if (result.success !== true) {
-            this.cli.failAction(`QUERY:BUILD:${this.context.queryType}`, result.error);
+            this.cli.failAction(action, result.error);
             this.cli.writeError(result.error);
             console.error(result.errorObj);
             return;
         }
-        this.cli.successAction(`QUERY:BUILD:${this.context.queryType}`);
+        this.cli.successAction(action);
+        const query = result.data;
+        if (this.context.count) {
+            if (this.context.explain) {
+                this.report(query);
+            }
+            await this.executeAndReportCounts(query.sql);
+            return;
+        }
         if (this.context.execute) {
-            await this.executeAndExport(result.data);
+            await this.executeAndExport(query.sql);
             return;
         }
         if (this.context.quiet) {
-            process.stdout.write(result.data);
+            // The query goes to stdout so it can be piped; an accounting the caller
+            // asked for goes next to it, on stderr.
+            if (this.context.explain) {
+                process.stderr.write(`${this.reportLines(query).join("\n")}\n`);
+            }
+            process.stdout.write(query.sql);
             return;
         }
-        if (!this.context.isWindows) {
-            clipboardy.writeSync(result.data);
+        this.report(query);
+        // The query is the result, the clipboard is a convenience: write it out
+        // first so nothing about the clipboard can delay or hide it.
+        this.cli.write(this.cli.style.dim.italic(query.sql));
+        if (this.context.isWindows) {
+            return;
         }
-        this.cli.write(this.cli.style.dim.italic(result.data));
-        if (!this.context.isWindows) {
+        if (await copyToClipboard(query.sql)) {
             this.cli.writeSuccess("Result has been copied to the clipboard 📋");
+            return;
         }
+        this.cli.write(this.cli.style.dim("The clipboard could not be reached 📋"));
     }
     /**
      * Build and execute the query against Athena (Baqend native path, AWS
@@ -65,12 +92,115 @@ export class QueryBuilderService {
     async execute() {
         return this.runQuery(this.query());
     }
+    /** The query as SQL. */
+    query() {
+        return this.build().sql;
+    }
+    build() {
+        const input = {
+            app: this.context.app,
+            bySet: this.context.bySet,
+            count: this.context.count,
+            days: this.context.days ?? DEFAULT_QUERY_DAYS[this.context.queryType],
+            devices: this.context.devices,
+            excludeNotFound: this.context.excludeNotFound,
+            excludeNoindex: this.context.excludeNoindex,
+            excludeSuspicious: this.context.excludeSuspicious,
+            hardNavigationsOnly: this.context.hardNavigationsOnly,
+            hosts: this.context.hosts,
+            limit: this.context.limit,
+            match: this.context.match,
+            minHits: this.context.minHits,
+            minImpressions: this.context.minImpressions,
+            ruleSets: this.ruleSets,
+            variations: this.context.variations,
+        };
+        return this.context.queryType === QueryType.prewarm
+            ? buildPrewarmQuery(input)
+            : buildParameterQuery(input);
+    }
+    /**
+     * Points out where the query is not exactly what the config says — a rule
+     * left out, a rule the query can only approximate, a pattern Athena reads
+     * differently than the browser — plus what the config itself gets wrong.
+     *
+     * Reductions are silent unless asked for: a rule another rule already
+     * decides is not a divergence, it is arithmetic.
+     */
+    report(query) {
+        for (const { reason, source } of query.findings) {
+            this.cli.writeWarning(`${source} ${reason}`);
+        }
+        for (const { reason, source } of query.dropped) {
+            this.cli.writeWarning(`Left out ${source}: ${reason}`);
+        }
+        for (const { reason, source } of query.approximated) {
+            this.cli.writeWarning(`Approximated ${source}: ${reason}`);
+        }
+        for (const warning of query.warnings) {
+            this.cli.writeWarning(warning);
+        }
+        const reduced = distinct(query.reduced);
+        if (this.context.explain) {
+            for (const line of reduced) {
+                this.cli.write(this.cli.style.dim(line));
+            }
+            return;
+        }
+        if (reduced.length > 0) {
+            this.cli.write(this.cli.style.dim(`${reduced.length} rule(s) reduced away — run with --explain to see them`));
+        }
+    }
+    /** The same accounting as {@link report}, as plain lines. */
+    reportLines(query) {
+        return [
+            ...query.findings.map(({ reason, source }) => `${source} ${reason}`),
+            ...query.dropped.map(({ reason, source }) => `Left out ${source}: ${reason}`),
+            ...query.approximated.map(({ reason, source }) => `Approximated ${source}: ${reason}`),
+            ...query.warnings,
+            ...distinct(query.reduced),
+        ];
+    }
     async runQuery(query) {
         if (!this.athenaService) {
             throw new Error("No Athena service available to execute the query");
         }
         return this.athenaService.getResult(query, [], undefined, AthenaBucket.RumPi);
     }
+    /**
+     * Execute the count query and put its handful of rows on the terminal — a
+     * count is read, not filed, so nothing is written to disk.
+     *
+     * Under `--quiet` the rows go to stdout as tab separated values, so a count
+     * can be read by something other than a person.
+     */
+    async executeAndReportCounts(query) {
+        this.cli.startAction("QUERY:COUNT", "count the pre-warm list");
+        const result = await safe(this.runQuery(query));
+        if (result.success !== true) {
+            this.cli.failAction("QUERY:COUNT");
+            this.cli.writeError(result.error);
+            return;
+        }
+        this.cli.successAction("QUERY:COUNT");
+        const rows = result.data;
+        if (rows.length === 0) {
+            this.cli.writeWarning("No page impressions in the window — the list would be empty");
+            return;
+        }
+        if (this.context.quiet) {
+            const columns = Object.keys(rows[0]);
+            process.stdout.write([
+                columns.join("\t"),
+                ...rows.map((row) => columns.map((name) => row[name]).join("\t")),
+            ].join("\n") + "\n");
+            return;
+        }
+        this.cli.table(rows, Object.fromEntries(Object.keys(rows[0]).map((name) => [
+            name,
+            { get: (row) => readable(row[name]) },
+        ])));
+    }
     /**
      * Execute the built query against Athena (Baqend native path, AWS fallback)
      * and write the rows to a `<app>-<YYYY-MM-DD>-<queryType>.csv` file in the
@@ -80,7 +210,7 @@ export class QueryBuilderService {
         this.cli.startAction("QUERY:EXECUTE", "execute query and export csv");
         const result = await safe(this.runQuery(query));
         if (result.success !== true) {
-            this.cli.failAction("QUERY:EXECUTE", result.error);
+            this.cli.failAction("QUERY:EXECUTE");
             this.cli.writeError(result.error);
             return;
         }
@@ -93,21 +223,4 @@ export class QueryBuilderService {
         this.cli.successAction("QUERY:EXECUTE");
         this.cli.writeSuccess(`Wrote ${rows.length} rows to ${filePath} 📄`);
     }
-    query() {
-        const parameters = getStrippedParameters(this.speedKitConfig);
-        const parameterReplaceFilter = getParameterReplaceFilter(parameters, getSpeedKitConfigVersion(this.speedKitConfig));
-        const whitelistedFilter = getWhitelistedFilter(this.speedKitConfig);
-        const blacklistedFilter = getBlacklistedFilter(this.speedKitConfig);
-        const skConfigVersion = getSpeedKitConfigVersion(this.speedKitConfig);
-        const parameterFilter = getParameterFilter(parameters, skConfigVersion);
-        return this.buildQuery(this.context.app, parameterFilter, whitelistedFilter, blacklistedFilter, parameterReplaceFilter);
-    }
-    buildQuery(app, parameterFilter, whitelistedFilter, blacklistedFilter, parameterReplaceFilter) {
-        if (this.context.queryType === QueryTpe.prewarm) {
-            return new Prewarm(app, whitelistedFilter, blacklistedFilter, parameterReplaceFilter).query;
-        }
-        if (this.context.queryType === QueryTpe.parameter) {
-            return new Parameter(app, parameterFilter, whitelistedFilter, blacklistedFilter, parameterReplaceFilter).query;
-        }
-    }
 }

package/dist/services/query-builder/query-command.d.ts

@@ -0,0 +1,26 @@
+import { Config } from "@oclif/core";
+import { ParameterOptions, PrewarmOptions } from "./queries/query-model.js";
+import { QueryFilterOptions, QueryType } from "./query-builder-model.js";
+/**
+ * The flags a query command parses; each takes the ones it offers.
+ *
+ * `--device` and `--variation` are named as the flags are, singular, and are
+ * the two the caller gives rather than the list the builder works on.
+ */
+export interface QueryCommandFlags extends ParameterOptions, Omit<PrewarmOptions, "devices" | "variations">, QueryFilterOptions {
+    readonly configName: string;
+    readonly device?: readonly string[];
+    readonly execute?: boolean;
+    readonly explain?: boolean;
+    readonly quiet?: boolean;
+    readonly variation?: readonly string[];
+}
+/**
+ * Builds one of the config-derived queries and hands it over.
+ *
+ * Both `sk query` commands differ only in which query they ask for, so the
+ * wiring lives here rather than twice in the command layer — the two of them
+ * drifting apart is what left a diverged copy of the parameter query behind
+ * once already.
+ */
+export declare function runQuery(queryType: QueryType, customerPath: string, flags: QueryCommandFlags, config: Config): Promise<void>;

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

@@ -0,0 +1,35 @@
+import { CliConfig } from "../../helpers/cli-config.js";
+import { QueryBuilderFactory } from "./query-builder-factory.js";
+import { normalizeDevices } from "./queries/device.js";
+/**
+ * Builds one of the config-derived queries and hands it over.
+ *
+ * Both `sk query` commands differ only in which query they ask for, so the
+ * wiring lives here rather than twice in the command layer — the two of them
+ * drifting apart is what left a diverged copy of the parameter query behind
+ * once already.
+ */
+export async function runQuery(queryType, customerPath, flags, config) {
+    const service = await new QueryBuilderFactory({
+        bySet: flags.bySet,
+        configName: flags.configName,
+        count: flags.count,
+        customerPath,
+        days: flags.days,
+        devices: normalizeDevices(flags.device),
+        excludeNotFound: flags.excludeNotFound,
+        excludeNoindex: flags.excludeNoindex,
+        excludeSuspicious: flags.excludeSuspicious,
+        execute: flags.execute,
+        explain: flags.explain,
+        hardNavigationsOnly: flags.hardNavigationsOnly,
+        isWindows: config.windows,
+        limit: flags.limit,
+        match: flags.match,
+        minHits: flags.minHits,
+        minImpressions: flags.minImpressions,
+        quiet: flags.quiet,
+        variations: flags.variation,
+    }, new CliConfig(config).load()).buildService(queryType);
+    await service.run();
+}

package/dist/services/query-builder/rules/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./match-pattern.js";
+export * from "./pattern-language.js";
+export * from "./rule-model.js";
+export * from "./rule-parser.js";
+export * from "./rule-reducer.js";
+export * from "./rule-relevance.js";
+export * from "./rule-to-sql.js";
+export * from "./strip-parameters.js";

package/dist/services/query-builder/rules/index.js

@@ -0,0 +1,8 @@
+export * from "./match-pattern.js";
+export * from "./pattern-language.js";
+export * from "./rule-model.js";
+export * from "./rule-parser.js";
+export * from "./rule-reducer.js";
+export * from "./rule-relevance.js";
+export * from "./rule-to-sql.js";
+export * from "./strip-parameters.js";