@speedkit/cli 4.26.0 → 4.27.1

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

@@ -8,14 +8,18 @@ import { BaqendAthenaService } from "./baqend-athena-service.js";
 import { EntityManagerFactory } from "../config-api/entity-manager-factory.js";
 export class AthenaServiceFactory {
     app;
+    workgroup;
     service;
     /**
      * @param app - the app to query. Enables the Baqend native query path (app
      * token only) as a fallback when no AWS login is present. Without it, only
      * the AWS path is available.
+     * @param workgroup - Athena workgroup for the AWS path. The Baqend path has
+     * no such notion, so it is ignored there.
      */
-    constructor(app) {
+    constructor(app, workgroup) {
         this.app = app;
+        this.workgroup = workgroup;
     }
     async getService() {
         if (!this.service) {
@@ -33,8 +37,10 @@ export class AthenaServiceFactory {
         const cli = new CliServiceFactory().getService();
         const client = await this.tryGetAthenaClient();
         if (client) {
-            cli.comment("Using AWS credentials for Athena queries.");
-            return new AwsAthenaService(client, cli);
+            cli.comment(this.workgroup
+                ? `Using AWS credentials for Athena queries, workgroup ${this.workgroup}.`
+                : "Using AWS credentials for Athena queries.");
+            return new AwsAthenaService(client, cli, this.workgroup);
         }
         if (this.app) {
             return new BaqendAthenaService(this.app, new EntityManagerFactory(), cli);

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

@@ -10,8 +10,20 @@ 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?;
+    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);
     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

@@ -11,21 +11,39 @@ import { safe } from "../../helpers/safe.js";
 export class AwsAthenaService {
     client;
     cli;
-    constructor(client, cli) {
+    workgroup;
+    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) {
         this.client = client;
         this.cli = cli;
+        this.workgroup = workgroup;
     }
     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)
@@ -97,6 +115,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.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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