@speedkit/cli 2.4.1

package/dist/helpers/normalize.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = exports.transformNoValueParams = exports.convertNotEncodedParameters = exports.sortParams = void 0;
+const { URL } = require('url');
+/**
+ * Sorts all urls params manually.
+ *
+ * @param searchParams - Params to sort.
+ */
+function sortParams(searchParams) {
+    const entries = [...searchParams.entries()].sort((a, b) => {
+        if (a[0] === b[0]) {
+            return a[1] < b[1] ? -1 : 1;
+        }
+        return a[0] < b[0] ? -1 : 1;
+    });
+    // Clear search params before appending sorted params
+    entries.forEach(key => searchParams.delete(key[0]));
+    // Append sorted params without overwriting keys
+    entries.forEach(key => searchParams.append(key[0], key[1]));
+}
+exports.sortParams = sortParams;
+/**
+ * Encodes the parameter key as URL object would encode query params.
+ *
+ * @param parameterKey - The key to encode.
+ * @param parameterValue - The value to encode.
+ * @return The encoded parameter key and value without ?.
+ */
+function encodeUrlComponent(parameterKey, parameterValue) {
+    const url = new URL('https://www.baqend.com/');
+    url.searchParams.append(parameterKey, parameterValue);
+    return url.search.replace(/\?/, '');
+}
+/**
+ * Converts parameters back to origin form.
+ *
+ * When adding parameters to the original URL the encoding of the parameters can change.
+ * This is because adding parameters to an URL object triggers a decode before adding
+ * and an encode after adding. Therefore the encoding of parameters can differ from the origin
+ * (e.g. if a whitespace is encoded like '%20' in the original URL, adding a parameter by calling
+ * searchParams.append() encodes the whitespace to '+').
+ *
+ * The root cause for this is because the encoding when appending search params to an URL object
+ * is different than the encoding of encodeURIComponent().
+ *
+ * @param url - The original Url.
+ * @param manipulatedUrl - The computed URL.
+ */
+function convertNotEncodedParameters(url, manipulatedUrl) {
+    if (manipulatedUrl.search.length === 0) {
+        return;
+    }
+    const originalParamsMap = new Map();
+    const originalParams = url.search.substring(1).split('&');
+    let index = 0;
+    url.searchParams.forEach((value, param) => {
+        const paramWithValue = originalParams[index];
+        if (paramWithValue) {
+            originalParamsMap.set(encodeUrlComponent(param, value), paramWithValue);
+        }
+        index += 1;
+    });
+    const search = [...manipulatedUrl.searchParams].map((entry) => {
+        const [key, value] = entry;
+        const originalParamWithValue = originalParamsMap.get(encodeUrlComponent(key, value));
+        if (originalParamWithValue) {
+            return `${originalParamWithValue}`;
+        }
+        return `${key}=${value}`;
+    });
+    manipulatedUrl.search = `?${search.join('&')}`;
+}
+exports.convertNotEncodedParameters = convertNotEncodedParameters;
+/**
+ * Removes the "=" char of query parameters that do not have a value.
+ *
+ * Hint: This is needed because calling the append or delete method of {@link URL}
+ * adds a "=" to all parameter without value. This results in different resource URLs.
+ *
+ * @param url - The original URL.
+ * @param manipulatedUrl - The manipulated URL to remove the "=" from.
+ */
+function transformNoValueParams(url, manipulatedUrl) {
+    const paramsWithoutValue = url.search.split(/[?&]/).filter(e => e && !e.includes('='));
+    for (const param of paramsWithoutValue) {
+        manipulatedUrl.search = manipulatedUrl.search.replace(`${param}=`, param);
+    }
+}
+exports.transformNoValueParams = transformNoValueParams;
+/**
+ * Normalizes a given URL.
+ *
+ * @param urlString - The URL to be normalized.
+ * @param sortParameters - Activates alphabetical sorting of the URL parameters.
+ * @returns The normalized URL.
+ */
+function normalize(urlString, sortParameters) {
+    const url = new URL(urlString);
+    // Remove the hash part of the URL if exists
+    if (url.hash) {
+        url.hash = '';
+    }
+    if (!sortParameters) {
+        // Sort search params to normalize encoding and order of params
+        sortParams(url.searchParams);
+    }
+    convertNotEncodedParameters(new URL(urlString), url);
+    transformNoValueParams(new URL(urlString), url);
+    return url.toString();
+}
+exports.normalize = normalize;

package/dist/helpers/race.d.ts

@@ -0,0 +1 @@
+export declare function race<T>(promise: Promise<T>): Promise<T>;

package/dist/helpers/race.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.race = void 0;
+const safe_1 = require("./safe");
+const DEFAULT_TIMEOUT = 5000;
+async function race(promise) {
+    const timeOut = new Promise((resolve, reject) => {
+        setTimeout(() => { reject('timeout'); }, DEFAULT_TIMEOUT);
+    });
+    const result = await (0, safe_1.safe)(Promise.race([promise, timeOut]));
+    if (result.success === true) {
+        return result.data;
+    }
+    throw new Error(result.error);
+}
+exports.race = race;

package/dist/helpers/safe.d.ts

@@ -0,0 +1,10 @@
+export type Safe<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+    errorObj?: Error;
+};
+export declare function safe<T>(promise: Promise<T>): Promise<Safe<T>>;
+export declare function safe<T>(func: () => T): Safe<T>;

package/dist/helpers/safe.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safe = void 0;
+function safe(promiseOrFunc) {
+    if (promiseOrFunc instanceof Promise) {
+        return safeAsync(promiseOrFunc);
+    }
+    return safeSync(promiseOrFunc);
+}
+exports.safe = safe;
+async function safeAsync(promise) {
+    try {
+        const data = await promise;
+        return { data, success: true };
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return { success: false, error: e.message, errorObj: e };
+        }
+        return { success: false, error: "Something went wrong" };
+    }
+}
+function safeSync(func) {
+    try {
+        const data = func();
+        return { data, success: true };
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return { success: false, error: e.message, errorObj: e };
+        }
+        return { success: false, error: "Something went wrong" };
+    }
+}

package/dist/helpers/scrape.d.ts

@@ -0,0 +1 @@
+export default function scrape(url: string): Promise<any>;

package/dist/helpers/scrape.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetch = require('node-fetch');
+async function scrape(url) {
+    const response = await fetch(url);
+    if (response.status !== 200) {
+        return null;
+    }
+    return response.text();
+}
+exports.default = scrape;

package/dist/helpers/speedKitRuleToRegExp.d.ts

@@ -0,0 +1 @@
+export declare function speedKitRuleToRegExp(url: string): RegExp;

package/dist/helpers/speedKitRuleToRegExp.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.speedKitRuleToRegExp = void 0;
+function escapeRegExp(str) {
+    return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+function speedKitRuleToRegExp(url) {
+    return new RegExp(`^${escapeRegExp(url).replace(/\\\*/g, '.*')}$`);
+}
+exports.speedKitRuleToRegExp = speedKitRuleToRegExp;

package/dist/helpers/watchFiles.d.ts

@@ -0,0 +1 @@
+export declare function watchFiles(filenames: (string | undefined)[], listener: () => Promise<void>): void;

package/dist/helpers/watchFiles.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchFiles = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+function watchFiles(filenames, listener) {
+    for (const filename of filenames) {
+        if (!filename) {
+            // asset comes not from the local filesystem
+            continue;
+        }
+        fs_1.default.watchFile(filename, async () => {
+            console.info((0, chalk_1.default) `Updated {bold ${filename}}`);
+            await listener();
+        });
+        console.info((0, chalk_1.default) `Listening for changes on {bold ${filename}}`);
+    }
+}
+exports.watchFiles = watchFiles;

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

@@ -0,0 +1,73 @@
+export declare enum CLIParameters {
+    AppName = "app",
+    Artifacts = "artifacts",
+    ConfigName = "configName",
+    ContentTypes = "contentTypes",
+    Cookies = "cookies",
+    CreateTests = "CreateTests",
+    CustomerPath = "customerPath",
+    CustomersDir = "customersDir",
+    Delay = "delay",
+    DryRun = "dryRun",
+    Group = "group",
+    HideDiff = "hideDiff",
+    Ips = "ips",
+    KeepParameterSorting = "keepParameterSorting",
+    Mobile = "mobile",
+    PageUrl = "pageUrl",
+    Path = "path",
+    SlackToken = "slackToken",
+    TestId = "testId",
+    Urls = "urls",
+    Variation = "variation",
+    VariationPath = "variationPath"
+}
+export declare enum CLIParametersChar {
+    AppName = "a",
+    Artifacts = "a",
+    ConfigName = "c",
+    ContentTypes = "c",
+    Cookies = "c",
+    CreateTests = "t",
+    CustomerPath = "p",
+    CustomersDir = "d",
+    Delay = "d",
+    DryRun = "d",
+    Group = "g",
+    HideDiff = "h",
+    Ips = "i",
+    KeepParameterSorting = "k",
+    Mobile = "m",
+    SlackToken = "t",
+    Path = "p",
+    Variation = "v",
+    VariationPath = "p"
+}
+export declare enum CLIParametersExample {
+    AppName = "decathlon",
+    Artifacts = "dynamic,SpeedKit",
+    ConfigName = "production",
+    ContentTypes = "image,style",
+    Cookies = "consentCookies",
+    CustomerPath = "customer/decathlon.de",
+    CustomersDir = "customers",
+    Delay = "1200",
+    Group = "B",
+    Ips = "151.101.120.194",
+    Mobile = "Y",
+    PageUrl = "https://www.decathlon.de/",
+    Path = "C:\\Users\\testUser\\file.csv",
+    SlackToken = "someSlackToken",
+    TestId = "listing-50vs50",
+    Urls = "url1,url2,url3",
+    Variation = "MOBILE",
+    VariationPath = "C:\\Users\\testUser\\variations.csv"
+}
+export declare const CLI_CONFIG_NAME: {
+    configName: import("@oclif/core/lib/interfaces/parser").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+};
+export declare const CLI_CUSTOMER_CONFIG: {
+    customerPath: import("@oclif/core/lib/interfaces/parser").Arg<string, {
+        exists?: boolean;
+    }>;
+};

package/dist/models/cli-parameters.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_CUSTOMER_CONFIG = exports.CLI_CONFIG_NAME = exports.CLIParametersExample = exports.CLIParametersChar = exports.CLIParameters = void 0;
+const core_1 = require("@oclif/core");
+var CLIParameters;
+(function (CLIParameters) {
+    CLIParameters["AppName"] = "app";
+    CLIParameters["Artifacts"] = "artifacts";
+    CLIParameters["ConfigName"] = "configName";
+    CLIParameters["ContentTypes"] = "contentTypes";
+    CLIParameters["Cookies"] = "cookies";
+    CLIParameters["CreateTests"] = "CreateTests";
+    CLIParameters["CustomerPath"] = "customerPath";
+    CLIParameters["CustomersDir"] = "customersDir";
+    CLIParameters["Delay"] = "delay";
+    CLIParameters["DryRun"] = "dryRun";
+    CLIParameters["Group"] = "group";
+    CLIParameters["HideDiff"] = "hideDiff";
+    CLIParameters["Ips"] = "ips";
+    CLIParameters["KeepParameterSorting"] = "keepParameterSorting";
+    CLIParameters["Mobile"] = "mobile";
+    CLIParameters["PageUrl"] = "pageUrl";
+    CLIParameters["Path"] = "path";
+    CLIParameters["SlackToken"] = "slackToken";
+    CLIParameters["TestId"] = "testId";
+    CLIParameters["Urls"] = "urls";
+    CLIParameters["Variation"] = "variation";
+    CLIParameters["VariationPath"] = "variationPath";
+})(CLIParameters || (exports.CLIParameters = CLIParameters = {}));
+var CLIParametersChar;
+(function (CLIParametersChar) {
+    CLIParametersChar["AppName"] = "a";
+    CLIParametersChar["Artifacts"] = "a";
+    CLIParametersChar["ConfigName"] = "c";
+    CLIParametersChar["ContentTypes"] = "c";
+    CLIParametersChar["Cookies"] = "c";
+    CLIParametersChar["CreateTests"] = "t";
+    CLIParametersChar["CustomerPath"] = "p";
+    CLIParametersChar["CustomersDir"] = "d";
+    CLIParametersChar["Delay"] = "d";
+    CLIParametersChar["DryRun"] = "d";
+    CLIParametersChar["Group"] = "g";
+    CLIParametersChar["HideDiff"] = "h";
+    CLIParametersChar["Ips"] = "i";
+    CLIParametersChar["KeepParameterSorting"] = "k";
+    CLIParametersChar["Mobile"] = "m";
+    CLIParametersChar["SlackToken"] = "t";
+    CLIParametersChar["Path"] = "p";
+    CLIParametersChar["Variation"] = "v";
+    CLIParametersChar["VariationPath"] = "p";
+})(CLIParametersChar || (exports.CLIParametersChar = CLIParametersChar = {}));
+var CLIParametersExample;
+(function (CLIParametersExample) {
+    CLIParametersExample["AppName"] = "decathlon";
+    CLIParametersExample["Artifacts"] = "dynamic,SpeedKit";
+    CLIParametersExample["ConfigName"] = "production";
+    CLIParametersExample["ContentTypes"] = "image,style";
+    CLIParametersExample["Cookies"] = "consentCookies";
+    CLIParametersExample["CustomerPath"] = "customer/decathlon.de";
+    CLIParametersExample["CustomersDir"] = "customers";
+    CLIParametersExample["Delay"] = "1200";
+    CLIParametersExample["Group"] = "B";
+    CLIParametersExample["Ips"] = "151.101.120.194";
+    CLIParametersExample["Mobile"] = "Y";
+    CLIParametersExample["PageUrl"] = "https://www.decathlon.de/";
+    CLIParametersExample["Path"] = "C:\\Users\\testUser\\file.csv";
+    CLIParametersExample["SlackToken"] = "someSlackToken";
+    CLIParametersExample["TestId"] = "listing-50vs50";
+    CLIParametersExample["Urls"] = "url1,url2,url3";
+    CLIParametersExample["Variation"] = "MOBILE";
+    CLIParametersExample["VariationPath"] = "C:\\Users\\testUser\\variations.csv";
+})(CLIParametersExample || (exports.CLIParametersExample = CLIParametersExample = {}));
+exports.CLI_CONFIG_NAME = {
+    [CLIParameters.ConfigName]: core_1.Flags.string({ char: CLIParametersChar.ConfigName, default: 'production', description: 'The costumer config name' }),
+};
+exports.CLI_CUSTOMER_CONFIG = {
+    [CLIParameters.CustomerPath]: core_1.Args.directory({
+        name: CLIParameters.CustomerPath,
+        required: true,
+        description: 'The customer config path', // help description
+    }),
+};

package/dist/models/files.d.ts

@@ -0,0 +1,20 @@
+export declare const INTEGRATION_FILES: {
+    CONFIG: {
+        CUSTOMER: string;
+        SPEED_KIT: string;
+        DOCUMENT_HANDLER: string;
+        DYNAMIC_BLOCKS: string;
+        LOAD_HANDLER: string;
+        DYNAMIC_STYLES: string;
+    };
+    CUSTOM: {
+        LOADER: string;
+        SW: string;
+        DOCUMENT_HANDLER: string;
+        DYNAMIC_FETCHER: string;
+    };
+    BUILD: {
+        INSTALL: string;
+        DOCUMENT_HANDLER: string;
+    };
+};

package/dist/models/files.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTEGRATION_FILES = void 0;
+exports.INTEGRATION_FILES = {
+    CONFIG: {
+        CUSTOMER: 'config_customer',
+        SPEED_KIT: 'config_SpeedKit',
+        DOCUMENT_HANDLER: 'config_documentHandler',
+        DYNAMIC_BLOCKS: 'config_dynamicBlocks',
+        LOAD_HANDLER: 'config_loadHandler',
+        DYNAMIC_STYLES: 'config_dynamicStyles'
+    },
+    CUSTOM: {
+        LOADER: 'custom_loader',
+        SW: 'custom_sw',
+        DOCUMENT_HANDLER: 'custom_documentHandler',
+        DYNAMIC_FETCHER: 'custom_dynamicFetcher',
+    },
+    BUILD: {
+        INSTALL: 'bundle_install',
+        DOCUMENT_HANDLER: 'bundle_documentHandler',
+    }
+};

package/dist/models/install.d.ts

@@ -0,0 +1,24 @@
+export interface InstallConfigs<T> {
+    config: T;
+    custom: T;
+    sw: T;
+    loader: T;
+    dynamicFetcher: T;
+    dynamicFetcherConfig: T;
+    documentHandler: T;
+    documentHandlerConfig: T;
+    customStyle: T;
+}
+export default interface Install extends Partial<InstallConfigs<string>> {
+    id?: string;
+    version?: number;
+    acl?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    status?: string;
+    swVersion?: string;
+    domain: string;
+    configVersion?: number;
+    description?: string;
+    origins?: string[];
+}

package/dist/models/install.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,30 @@
+export type UsedPopsPerOrigin = {
+    hits: number;
+    origin: string;
+    pop: string;
+    region: string;
+};
+export declare class AthenaService {
+    private client;
+    getUsedPopsPerOrigin(app: string, useRum: any): Promise<UsedPopsPerOrigin[]>;
+    private castValueToType;
+    /**
+     * Fetch the query result of the given query id, if the result is still available
+     * @param queryId - The query of which the results should be fetched
+     * @return The query result as an array of objects. The object keys are the selected column names and the object
+     * values the column values
+     */
+    private fetchResult;
+    /**
+     * Runs the given SQL query against Athena and returns the query id when the query has successfully been executed.
+     * @param sql - The query to execute
+     * @param parameters - the parameters ? which should be passed to the query. In the order they are occurring in the query
+     * @param useCacheTTLMinutes - enable query caching to the given amount of minutes, if the same query is
+     * issued within the cached time causes that the results from the previous execution will be returned without any
+     * additional costs
+     * @return The query id which can be used to fetch the query results
+     */
+    private runQuery;
+    private sleep;
+    private waitOnResponse;
+}

package/dist/services/athena-service.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthenaService = void 0;
+const client_athena_1 = require("@aws-sdk/client-athena");
+class AthenaService {
+    client = new client_athena_1.AthenaClient({ region: 'eu-central-1' });
+    async getUsedPopsPerOrigin(app, useRum) {
+        const query = `
+      with data as (
+        select
+          *,
+          coalesce('https://' || url_extract_host(assetUrl) || regexp_extract(url_extract_path(assetUrl), '(?i)/([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);
+        const queryId = await this.runQuery(query, [start, end, app], 12 * 60);
+        return await this.fetchResult(queryId);
+    }
+    castValueToType(value, type) {
+        if (value === null)
+            return null;
+        switch (type) {
+            case 'bigint': {
+                return Number(value);
+            }
+            default: {
+                return value;
+            }
+        }
+    }
+    /**
+     * Fetch the query result of the given query id, if the result is still available
+     * @param queryId - The query of which the results should be fetched
+     * @return The query result as an array of objects. The object keys are the selected column names and the object
+     * values the column values
+     */
+    async fetchResult(queryId) {
+        const rows = [];
+        let NextToken;
+        let first = true;
+        do {
+            // Max Results can be set but if its not set,
+            // it will choose the maximum page size.
+            const command = new client_athena_1.GetQueryResultsCommand({ NextToken, QueryExecutionId: queryId });
+            const result = await this.client.send(command);
+            const columns = result.ResultSet.ResultSetMetadata.ColumnInfo.map(info => info.Name);
+            const types = result.ResultSet.ResultSetMetadata.ColumnInfo.map(info => info.Type);
+            for (const rowRaw of result.ResultSet.Rows) {
+                if (first) {
+                    first = false;
+                    continue; // the first row contains the column names
+                }
+                const row = {};
+                for (let i = 0; i < rowRaw.Data.length; i++) {
+                    row[columns[i]] = this.castValueToType(rowRaw.Data[i].VarCharValue, types[i]);
+                }
+                rows.push(row);
+            }
+            NextToken = result.NextToken;
+        } while (NextToken);
+        return rows;
+    }
+    /**
+     * Runs the given SQL query against Athena and returns the query id when the query has successfully been executed.
+     * @param sql - The query to execute
+     * @param parameters - the parameters ? which should be passed to the query. In the order they are occurring in the query
+     * @param useCacheTTLMinutes - enable query caching to the given amount of minutes, if the same query is
+     * issued within the cached time causes that the results from the previous execution will be returned without any
+     * additional costs
+     * @return The query id which can be used to fetch the query results
+     */
+    async runQuery(sql, parameters, useCacheTTLMinutes = 60) {
+        const ExecutionParameters = parameters.map(value => typeof value === 'string' ? `'${value}'` : String(value));
+        const command = new client_athena_1.StartQueryExecutionCommand({
+            ExecutionParameters,
+            QueryExecutionContext: {
+                Catalog: 'live',
+            },
+            QueryString: sql,
+            ResultReuseConfiguration: {
+                ResultReuseByAgeConfiguration: {
+                    Enabled: true,
+                    MaxAgeInMinutes: useCacheTTLMinutes,
+                },
+            },
+        });
+        const response = await this.client.send(command);
+        await this.waitOnResponse(response.QueryExecutionId);
+        return response.QueryExecutionId;
+    }
+    async sleep(sleep) {
+        return new Promise(resolve => {
+            setTimeout(resolve, sleep);
+        });
+    }
+    async waitOnResponse(QueryExecutionId) {
+        for (;;) {
+            const command = new client_athena_1.GetQueryExecutionCommand({ QueryExecutionId });
+            const result = await this.client.send(command);
+            const status = result.QueryExecution.Status;
+            switch (status.State) {
+                case client_athena_1.QueryExecutionState.FAILED: {
+                    throw new Error('The Amazon Athena query failed to run with error message: ' + status.StateChangeReason);
+                }
+                case client_athena_1.QueryExecutionState.CANCELLED: {
+                    throw new Error('The Amazon Athena query was cancelled.');
+                }
+                case client_athena_1.QueryExecutionState.SUCCEEDED: {
+                    return;
+                }
+                default: {
+                    await this.sleep(1000);
+                    break;
+                }
+            }
+        }
+    }
+}
+exports.AthenaService = AthenaService;

package/dist/services/bundler/bundle-service-factory.d.ts

@@ -0,0 +1,4 @@
+import { BundleService } from './bundle-service';
+export declare class BundleServiceFactory {
+    buildService(): BundleService;
+}

package/dist/services/bundler/bundle-service-factory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleServiceFactory = void 0;
+const bundle_service_1 = require("./bundle-service");
+class BundleServiceFactory {
+    buildService() {
+        return new bundle_service_1.BundleService();
+    }
+}
+exports.BundleServiceFactory = BundleServiceFactory;