@speedkit/cli 2.14.2 → 2.15.0

package/dist/models/files.js

@@ -3,21 +3,21 @@ 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'
+        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',
+        LOADER: "custom_loader",
+        SW: "custom_sw",
+        DOCUMENT_HANDLER: "custom_documentHandler",
+        DYNAMIC_FETCHER: "custom_dynamicFetcher",
     },
     BUILD: {
-        INSTALL: 'bundle_install',
-        DOCUMENT_HANDLER: 'bundle_documentHandler',
-    }
+        INSTALL: "bundle_install",
+        DOCUMENT_HANDLER: "bundle_documentHandler",
+    },
 };

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

@@ -0,0 +1,13 @@
+import { AthenaService } from "./athena-service";
+export declare class AthenaServiceFactory {
+    service?: AthenaService;
+    getService(): Promise<AthenaService>;
+    private createService;
+    /**
+     * create awsAthenaClient
+     *
+     * @param cli
+     * @private
+     */
+    private getAthenaClient;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthenaServiceFactory = void 0;
+const client_athena_1 = require("@aws-sdk/client-athena");
+const safe_1 = require("../../helpers/safe");
+const cli_1 = require("../cli");
+const _1 = require("./");
+const athena_service_1 = require("./athena-service");
+class AthenaServiceFactory {
+    service;
+    async getService() {
+        if (!(this.service instanceof athena_service_1.AthenaService)) {
+            this.service = await this.createService();
+        }
+        return this.service;
+    }
+    async createService() {
+        const cli = new cli_1.CliServiceFactory().getService();
+        const client = await this.getAthenaClient(cli);
+        return new athena_service_1.AthenaService(client);
+    }
+    /**
+     * create awsAthenaClient
+     *
+     * @param cli
+     * @private
+     */
+    async getAthenaClient(cli) {
+        const client = new client_athena_1.AthenaClient(_1.ATHENA_CONFIG);
+        cli.startAction("check for aws credentials");
+        const credentialsResult = await (0, safe_1.safe)(client.config.credentials());
+        if (credentialsResult.success === true) {
+            cli.endAction(cli_1.CliActionStatus.COMPLETED);
+            return client;
+        }
+        cli.endAction(cli_1.CliActionStatus.FAILED);
+        throw new _1.FetchCredentialsError(credentialsResult.error);
+    }
+}
+exports.AthenaServiceFactory = AthenaServiceFactory;

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

@@ -0,0 +1,4 @@
+export declare const DEFAULT_MAX_AGE_IN_MINUTES = 60;
+export declare const ATHENA_CONFIG: {
+    region: string;
+};

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ATHENA_CONFIG = exports.DEFAULT_MAX_AGE_IN_MINUTES = void 0;
+exports.DEFAULT_MAX_AGE_IN_MINUTES = 60;
+exports.ATHENA_CONFIG = {
+    region: "eu-central-1",
+};

package/dist/services/{athena-service.d.ts → athena/athena-service.d.ts}

@@ -1,12 +1,8 @@
-export type UsedPopsPerOrigin = {
-    hits: number;
-    origin: string;
-    pop: string;
-    region: string;
-};
+import { AthenaClient } from "@aws-sdk/client-athena";
 export declare class AthenaService {
     private client;
-    getUsedPopsPerOrigin(app: string, useRum: any): Promise<UsedPopsPerOrigin[]>;
+    constructor(client: AthenaClient);
+    getResult<T>(query: string, parameters?: string[], maxAgeInMinutes?: number): Promise<T[]>;
     private castValueToType;
     /**
      * Fetch the query result of the given query id, if the result is still available
@@ -19,7 +15,7 @@ export declare class AthenaService {
      * 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
+     * @param maxAgeInMinutes - 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

package/dist/services/{athena-service.js → athena/athena-service.js}

@@ -2,38 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AthenaService = void 0;
 const client_athena_1 = require("@aws-sdk/client-athena");
+const athena_service_model_1 = require("./athena-service-model");
 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);
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async getResult(query, parameters = [], maxAgeInMinutes = athena_service_model_1.DEFAULT_MAX_AGE_IN_MINUTES) {
+        const queryId = await this.runQuery(query, parameters, maxAgeInMinutes);
         return (await this.fetchResult(queryId));
     }
     castValueToType(value, type) {
@@ -87,15 +63,15 @@ class AthenaService {
      * 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
+     * @param maxAgeInMinutes - 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));
+    async runQuery(sql, parameters, maxAgeInMinutes) {
+        const executionParameters = parameters.map((value) => typeof value === "string" ? `'${value}'` : String(value));
         const command = new client_athena_1.StartQueryExecutionCommand({
-            ExecutionParameters,
+            ExecutionParameters: executionParameters.length > 0 ? executionParameters : null,
             QueryExecutionContext: {
                 Catalog: "live",
             },
@@ -103,7 +79,7 @@ class AthenaService {
             ResultReuseConfiguration: {
                 ResultReuseByAgeConfiguration: {
                     Enabled: true,
-                    MaxAgeInMinutes: useCacheTTLMinutes,
+                    MaxAgeInMinutes: maxAgeInMinutes,
                 },
             },
         });

package/dist/services/athena/error/fetch-credentials-error.d.ts

@@ -0,0 +1,2 @@
+export declare class FetchCredentialsError extends Error {
+}

package/dist/services/athena/error/fetch-credentials-error.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchCredentialsError = void 0;
+class FetchCredentialsError extends Error {
+}
+exports.FetchCredentialsError = FetchCredentialsError;

package/dist/services/athena/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./athena-service";
+export * from "./athena-service-factory";
+export * from "./athena-service-model";
+export * from "./error/fetch-credentials-error";

package/dist/services/athena/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./athena-service"), exports);
+tslib_1.__exportStar(require("./athena-service-factory"), exports);
+tslib_1.__exportStar(require("./athena-service-model"), exports);
+tslib_1.__exportStar(require("./error/fetch-credentials-error"), exports);

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

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

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

@@ -1,4 +1,4 @@
-import { PluginBuild, LogLevel } from 'esbuild';
+import { PluginBuild, LogLevel } from "esbuild";
 export type BundleEntryPoints = {
     [entryPoint: string]: string;
 };
@@ -6,7 +6,7 @@ export type BundleBasePaths = {
     [basePath: string]: string;
 };
 export declare class BundleService {
-    bundle({ entryPoints, basePaths, define, target, minify, logLevel }: {
+    bundle({ entryPoints, basePaths, define, target, minify, logLevel, }: {
         entryPoints: BundleEntryPoints;
         basePaths: BundleBasePaths;
         target?: string | string[];

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

@@ -7,64 +7,70 @@ const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const node_url_1 = require("node:url");
 const importCache = {};
 class BundleService {
-    async bundle({ entryPoints, basePaths, define, target = 'es5', minify = true, logLevel = 'silent' }) {
+    async bundle({ entryPoints, basePaths, define, target = "es5", minify = true, logLevel = "silent", }) {
         const result = await (0, esbuild_1.build)({
-            plugins: [this.baqendPlugin(basePaths), this.entryPointsPlugin(entryPoints)],
+            plugins: [
+                this.baqendPlugin(basePaths),
+                this.entryPointsPlugin(entryPoints),
+            ],
             bundle: true,
             target,
             define,
             write: false,
             minify,
-            outdir: 'out',
+            outdir: "out",
             entryPoints: Object.keys(entryPoints),
             logLevel,
         });
-        return result.outputFiles.map(e => e.text).join('').trim();
+        return result.outputFiles
+            .map((e) => e.text)
+            .join("")
+            .trim();
     }
     entryPointsPlugin(entryPoints) {
         return {
-            name: 'entryPoints',
+            name: "entryPoints",
             setup(build) {
-                build.onResolve({ filter: /.*/ }, args => {
+                build.onResolve({ filter: /.*/ }, (args) => {
                     if (!entryPoints[args.path]) {
-                        throw new Error('Could not resolve ' + args.path);
+                        throw new Error("Could not resolve " + args.path);
                     }
-                    return ({
+                    return {
                         path: args.path,
-                        namespace: 'entryPoint',
-                    });
+                        namespace: "entryPoint",
+                    };
                 });
-                build.onLoad({ filter: /.*/, namespace: 'entryPoint' }, (args) => {
+                build.onLoad({ filter: /.*/, namespace: "entryPoint" }, (args) => {
                     return {
                         contents: entryPoints[args.path],
-                        loader: 'js',
+                        loader: "js",
                     };
                 });
             },
         };
     }
     baqendPlugin(basePaths) {
-        const filter = new RegExp(`^(${Object.keys(basePaths).join('|')})/`);
+        const filter = new RegExp(`^(${Object.keys(basePaths).join("|")})/`);
         return {
-            name: 'baqend',
+            name: "baqend",
             setup(build) {
-                build.onResolve({ filter }, args => {
-                    const [base, path] = args.path.split('/', 2);
+                build.onResolve({ filter }, (args) => {
+                    const [base, path] = args.path.split("/", 2);
                     const url = new node_url_1.URL(path, basePaths[base]).toString();
                     if (!url.startsWith(basePaths[base])) {
                         throw new Error(`Importing ${path} failed. Can't resolve the path`);
                     }
-                    return ({
+                    return {
                         path: url,
-                        namespace: 'baqend-url',
-                    });
+                        namespace: "baqend-url",
+                    };
                 });
-                build.onResolve({ filter: /.*/, namespace: 'baqend-url' }, args => ({
+                build.onResolve({ filter: /.*/, namespace: "baqend-url" }, (args) => ({
                     path: new node_url_1.URL(args.path, args.importer).toString(),
                     namespace: args.namespace,
                 }));
-                build.onLoad({ filter: /.*/, namespace: 'baqend-url' }, async (args) => {
-                    const url = args.path + (!args.path.endsWith('.js') ? '.js' : '');
+                build.onLoad({ filter: /.*/, namespace: "baqend-url" }, async (args) => {
+                    const url = args.path + (!args.path.endsWith(".js") ? ".js" : "");
                     if (importCache[url]) {
                         return { contents: importCache[url] };
                     }
@@ -73,7 +79,7 @@ class BundleService {
                         throw new Error(`Importing ${url} failed with error ${fetched.status}`);
                     }
                     let text = await fetched.text();
-                    text = text.replace('window.SpeedKit=window.SpeedKit||{},window.SpeedKit.plugins=window.SpeedKit.plugins||{},window.SpeedKit.plugins.', 'export var ');
+                    text = text.replace("window.SpeedKit=window.SpeedKit||{},window.SpeedKit.plugins=window.SpeedKit.plugins||{},window.SpeedKit.plugins.", "export var ");
                     importCache[url] = text;
                     return { contents: text };
                 });

package/dist/services/bundler/index.d.ts

@@ -1,2 +1,2 @@
-export * from './bundle-service-factory';
-export * from './bundle-service';
+export * from "./bundle-service-factory";
+export * from "./bundle-service";

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

@@ -10,7 +10,7 @@ class CliService {
     buffer = [];
     style = chalk_1.default;
     codeStyle(code) {
-        const padding = ' ';
+        const padding = " ";
         return this.style.bgGray.rgb(230, 126, 0)(`${padding}${code}${padding}`);
     }
     write(message, buffered = false) {
@@ -21,7 +21,7 @@ class CliService {
         core_1.ux.info(message);
     }
     spacer() {
-        core_1.ux.info('');
+        core_1.ux.info("");
     }
     writeSuccess(message, buffered = false) {
         if (buffered) {
@@ -64,8 +64,8 @@ class CliService {
         return (0, prompts_1.input)({
             message: this.getFormattedMessage(message),
             default: defaultAnswer,
-            validate: input => {
-                if (typeof validator !== 'function')
+            validate: (input) => {
+                if (typeof validator !== "function")
                     return true;
                 const errorMessage = validator(input);
                 if (!errorMessage) {
@@ -84,7 +84,7 @@ class CliService {
     async select(message, choices) {
         return (0, prompts_1.select)({
             message: this.getFormattedMessage(message),
-            choices
+            choices,
         });
     }
     startAction(message) {

package/dist/services/cli/hooks.js

@@ -20,14 +20,14 @@ class Hooks {
             return;
         }
         this.cli.writeSuccess(this.preHook);
-        this.cli.write((0, child_process_1.execSync)(this.preHook) + '');
+        this.cli.write((0, child_process_1.execSync)(this.preHook) + "");
     }
     async runPostHook() {
         if (!this.postHook) {
             return;
         }
         this.cli.writeSuccess(this.postHook);
-        this.cli.write((0, child_process_1.execSync)(this.postHook) + '');
+        this.cli.write((0, child_process_1.execSync)(this.postHook) + "");
     }
 }
 exports.default = Hooks;

package/dist/services/cli/index.d.ts

@@ -1,3 +1,3 @@
-export * from './cli-service';
-export * from './cli-service-model';
-export * from './cli-service-factory';
+export * from "./cli-service";
+export * from "./cli-service-model";
+export * from "./cli-service-factory";

package/dist/services/config-api/client.d.ts

@@ -11,6 +11,6 @@ export default class Client {
     /**
      * @param requestExtension
      */
-    createRequest(requestExtension: RequestExtensionInterface): Promise<{}>;
+    createRequest(requestExtension: RequestExtensionInterface): Promise<NonNullable<unknown>>;
     private getEntityManager;
 }

package/dist/services/config-api/client.js

@@ -6,7 +6,7 @@ const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
 const race_1 = require("../../helpers/race");
 const REQUEST_TIMEOUT = 10_000;
-const CONTENT_TYPE = 'application/json;charset=UTF-8';
+const CONTENT_TYPE = "application/json;charset=UTF-8";
 class Client {
     entityManagerFactory;
     app;
@@ -25,27 +25,29 @@ class Client {
     }
     async getModule(moduleName) {
         const entityManager = await this.getEntityManager();
-        return await entityManager.code.loadCode(moduleName, 'module');
+        return await entityManager.code.loadCode(moduleName, "module");
     }
     async setModule(moduleName, moduleCode) {
         const entityManager = await this.getEntityManager();
-        return await entityManager.code.saveCode(moduleName, 'module', moduleCode);
+        return await entityManager.code.saveCode(moduleName, "module", moduleCode);
     }
     /**
      * @param requestExtension
      */
     async createRequest(requestExtension) {
         const entityManager = await this.getEntityManager();
-        let baseRequest = {
-            method: 'GET',
+        const baseRequest = {
+            method: "GET",
             headers: {
                 Host: `${this.app}.app.baqend.com`,
                 authorization: `BAT ${entityManager.token}`,
-                'Content-Type': CONTENT_TYPE,
+                "Content-Type": CONTENT_TYPE,
             },
             timeout: REQUEST_TIMEOUT,
         };
-        return Object.assign({}, (0, deepmerge_1.default)(baseRequest, requestExtension), { agent: this.agent });
+        return Object.assign({}, (0, deepmerge_1.default)(baseRequest, requestExtension), {
+            agent: this.agent,
+        });
     }
     async getEntityManager() {
         return await (0, race_1.race)(this.entityManagerFactory.getEntityManager(this.app));

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

@@ -14,21 +14,33 @@ class ConfigApiService {
     }
     async addInstall(configName, origins) {
         const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${configName}`;
-        const body = await this.client.send(updateUrl, { body: `{origins: ${JSON.stringify(origins)}}`, method: 'POST' });
+        const body = await this.client.send(updateUrl, {
+            body: `{origins: ${JSON.stringify(origins)}}`,
+            method: "POST",
+        });
         return body;
     }
     async setInstall(install) {
         const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}`;
-        return (await this.client.send(updateUrl, { body: JSON.stringify(install), method: 'PUT' }));
+        return (await this.client.send(updateUrl, {
+            body: JSON.stringify(install),
+            method: "PUT",
+        }));
     }
     async cloneInstall(install) {
         const cloneUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/clone`;
-        const body = await this.client.send(cloneUrl, { body: '{}', method: 'POST' });
+        const body = await this.client.send(cloneUrl, {
+            body: "{}",
+            method: "POST",
+        });
         return body;
     }
     async activateInstall(install) {
         const activateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/activate`;
-        return (await this.client.send(activateUrl, { body: '{}', method: 'POST' }));
+        return (await this.client.send(activateUrl, {
+            body: "{}",
+            method: "POST",
+        }));
     }
     async getModule(moduleName) {
         return await this.client.getModule(moduleName);
@@ -39,16 +51,16 @@ class ConfigApiService {
     async getServerConfig() {
         const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
         const body = await this.client.send(urlPath);
-        return JSON.stringify(body, null, '\t');
+        return JSON.stringify(body, null, "\t");
     }
     async setServerConfig(localServerConfig, configurationVersion) {
         const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
         await this.client.send(urlPath, {
             body: localServerConfig,
-            method: 'PUT',
+            method: "PUT",
             headers: {
-                'Content-Type': 'application/json',
-                'If-Match': configurationVersion,
+                "Content-Type": "application/json",
+                "If-Match": configurationVersion,
             },
         });
     }

package/dist/services/config-api/factory/config-api-service-factory.js

@@ -22,7 +22,7 @@ class ConfigApiServiceFactory {
     }
     buildService() {
         if (!this.context.app) {
-            throw new context_runtime_error_1.default({ message: 'app is undefined' });
+            throw new context_runtime_error_1.default({ message: "app is undefined" });
         }
         this.createLoginTokenFileIfNotExists();
         const entityManagerFactory = new entity_manager_factory_1.default();

package/dist/services/config-api/interface/request-extension-interface.d.ts

@@ -1,5 +1,5 @@
 export default interface RequestExtensionInterface {
     method?: string;
-    headers?: {};
-    body?: string | {};
+    headers?: NonNullable<unknown>;
+    body?: string | NonNullable<unknown>;
 }

package/dist/services/customer-config/customer-config-service-context.js

@@ -5,7 +5,7 @@ const cli_parameters_1 = require("../../models/cli-parameters");
 class CustomerConfigServiceContext {
     appName;
     customersDir;
-    constructor(appName = '', customersDir = cli_parameters_1.CLIParametersExample.CustomersDir) {
+    constructor(appName = "", customersDir = cli_parameters_1.CLIParametersExample.CustomersDir) {
         this.appName = appName;
         this.customersDir = customersDir;
         this.appName = appName;

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

@@ -16,6 +16,7 @@ export declare class CustomerConfigService {
     private getHandlebarsOutputFileName;
     private getPathWithChangedDir;
     private isDirNotEmpty;
+    private chooseNewOutputDirectoryName;
     private selectOutputDirectory;
     private compileHandlebarsFiles;
     private getEnvironmentConfig;