@speedkit/cli 2.4.1

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const config_api_service_1 = tslib_1.__importDefault(require("../config-api-service"));
+const client_1 = tslib_1.__importDefault(require("../client"));
+const entity_manager_factory_1 = tslib_1.__importDefault(require("./entity-manager-factory"));
+const context_runtime_error_1 = tslib_1.__importDefault(require("../../context/error/context-runtime-error"));
+const node_fs_1 = require("node:fs");
+const os_1 = tslib_1.__importDefault(require("os"));
+const path_1 = tslib_1.__importDefault(require("path"));
+class ConfigApiServiceFactory {
+    context;
+    service = undefined;
+    constructor(context) {
+        this.context = context;
+    }
+    getService() {
+        if (!(this.service instanceof config_api_service_1.default)) {
+            this.buildService();
+        }
+        return this.service;
+    }
+    buildService() {
+        if (!this.context.app) {
+            throw new context_runtime_error_1.default({ message: 'app is undefined' });
+        }
+        this.createLoginTokenFileIfNotExists();
+        const entityManagerFactory = new entity_manager_factory_1.default();
+        const client = new client_1.default(this.context.app, entityManagerFactory);
+        this.service = new config_api_service_1.default(this.context.app, client);
+    }
+    createLoginTokenFileIfNotExists() {
+        if (!(0, node_fs_1.existsSync)(path_1.default.resolve(os_1.default.homedir(), ".baqend"))) {
+            (0, node_fs_1.writeFileSync)(path_1.default.resolve(os_1.default.homedir(), ".baqend"), "{}");
+        }
+    }
+}
+exports.default = ConfigApiServiceFactory;

package/dist/services/config-api/factory/entity-manager-factory.d.ts

@@ -0,0 +1,5 @@
+import { EntityManager } from "baqend";
+export default class EntityManagerFactory {
+    EntityManager: EntityManager;
+    getEntityManager(app: string): Promise<EntityManager>;
+}

package/dist/services/config-api/factory/entity-manager-factory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const cli_1 = require("baqend/cli");
+const login_error_1 = tslib_1.__importDefault(require("../error/login-error"));
+class EntityManagerFactory {
+    EntityManager;
+    async getEntityManager(app) {
+        if (this.EntityManager) {
+            return this.EntityManager;
+        }
+        try {
+            this.EntityManager = await cli_1.account.login({ app });
+            return this.EntityManager;
+        }
+        catch (e) {
+            throw new login_error_1.default(app);
+        }
+    }
+}
+exports.default = EntityManagerFactory;

package/dist/services/config-api/interface/config-api-context-interface.d.ts

@@ -0,0 +1,4 @@
+import ContextInterface from "../../context/interface/context-interface";
+export default interface ConfigApiContextInterface extends ContextInterface {
+    app: string;
+}

package/dist/services/config-api/interface/config-api-context-interface.js

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

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

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

package/dist/services/config-api/interface/request-extension-interface.js

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

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

@@ -0,0 +1,18 @@
+import { EntityManager } from 'baqend';
+import Install from '../models/install';
+export default class ConfigApiService {
+    private db;
+    private readonly app;
+    private readonly requestInit;
+    constructor(db: EntityManager, app: string);
+    fetchActiveInstall(configName: string): Promise<Install | null>;
+    activateInstall(install: Install): Promise<Install>;
+    updateInstall(install: Install): Promise<Install | null>;
+    createNewInstall(domain: string, origins: string[]): Promise<Install>;
+    cloneInstall(install: Install): Promise<Install>;
+    getRemoteModule(moduleName: string): Promise<string>;
+    saveRemoteModule(moduleCode: string, moduleName: string): Promise<string>;
+    getRemoteServerConfig(): Promise<string>;
+    saveRemoteServerConfig(localPath: string, configurationVersion: string): Promise<void>;
+    fetchAndGetBody(url: string, requestInit?: {}): Promise<any>;
+}

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const fetch = require('node-fetch');
+const https = require('https');
+const agent = new https.Agent({
+    rejectUnauthorized: false,
+    keepAlive: true,
+});
+/* eslint-disable no-console */
+class ConfigApiService {
+    db;
+    app;
+    requestInit;
+    constructor(db, app) {
+        this.db = db;
+        this.app = app;
+        this.requestInit = {
+            agent,
+            method: 'GET',
+            headers: {
+                Host: `${this.app}.app.baqend.com`,
+                authorization: `BAT ${this.db.token}`,
+                'Content-Type': 'application/json;charset=UTF-8',
+            },
+            timeout: 10000,
+        };
+    }
+    async fetchActiveInstall(configName) {
+        const urlPath = `https://${this.app}.app.baqend.com/v1/speedkit/installation?domain=${configName}&status=active`;
+        const body = await this.fetchAndGetBody(urlPath);
+        return body[0];
+    }
+    async activateInstall(install) {
+        const activateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/activate`;
+        const postInit = Object.assign({}, this.requestInit, { body: '{}', method: 'POST' });
+        return (await this.fetchAndGetBody(activateUrl, postInit));
+    }
+    // Update live version with the osk local body
+    async updateInstall(install) {
+        const postInit = Object.assign({}, this.requestInit, { body: JSON.stringify(install), method: 'PUT' });
+        const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}`;
+        return (await this.fetchAndGetBody(updateUrl, postInit));
+    }
+    async createNewInstall(domain, origins) {
+        const postInit = Object.assign({}, this.requestInit, { body: `{origins: ${JSON.stringify(origins)}}`, method: 'POST' });
+        const updateUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${domain}`;
+        const body = await this.fetchAndGetBody(updateUrl, postInit);
+        return body;
+    }
+    async cloneInstall(install) {
+        const postInit = Object.assign({}, this.requestInit, { body: '{}', method: 'POST' });
+        const cloneUrl = `https://${this.app}.app.baqend.com/v1/speedkit/installation/${install.domain}/${install.configVersion}/clone`;
+        const body = await this.fetchAndGetBody(cloneUrl, postInit);
+        return body;
+    }
+    async getRemoteModule(moduleName) {
+        return await this.db.code.loadCode(moduleName, 'module');
+    }
+    async saveRemoteModule(moduleCode, moduleName) {
+        return await this.db.code.saveCode(moduleName, 'module', moduleCode);
+    }
+    async getRemoteServerConfig() {
+        const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
+        const body = await this.fetchAndGetBody(urlPath);
+        return JSON.stringify(body, null, '\t');
+    }
+    async saveRemoteServerConfig(localPath, configurationVersion) {
+        const localServerConfigContent = fs.readFileSync(localPath, 'utf-8');
+        const localServerConfig = JSON.parse(localServerConfigContent);
+        localServerConfig.revision.version = configurationVersion;
+        const urlPath = `https://${this.app}.app.baqend.com/v1/config`;
+        const putInit = Object.assign({}, this.requestInit, {
+            body: JSON.stringify(localServerConfig),
+            method: 'PUT',
+            headers: {
+                Host: `${this.app}.app.baqend.com`,
+                // Origin: "origin",
+                authorization: `BAT ${this.db.token}`,
+                'Content-Type': 'application/json',
+                'If-Match': configurationVersion,
+            },
+        });
+        await this.fetchAndGetBody(urlPath, putInit);
+    }
+    async fetchAndGetBody(url, requestInit = this.requestInit) {
+        const res = await fetch(url, requestInit);
+        const body = await res.json();
+        if (res.status !== 200) {
+            throw new Error(body.message);
+        }
+        return body;
+    }
+}
+exports.default = ConfigApiService;

package/dist/services/context/app-context.d.ts

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

package/dist/services/context/app-context.js

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

package/dist/services/context/error/context-runtime-error.d.ts

@@ -0,0 +1,3 @@
+import ApplicationError from "../../error-handling/error/application-error";
+export default class ContextRuntimeError extends ApplicationError {
+}

package/dist/services/context/error/context-runtime-error.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const application_error_1 = tslib_1.__importDefault(require("../../error-handling/error/application-error"));
+class ContextRuntimeError extends application_error_1.default {
+}
+exports.default = ContextRuntimeError;

package/dist/services/context/interface/context-interface.d.ts

@@ -0,0 +1,2 @@
+export default interface ContextInterface {
+}

package/dist/services/context/interface/context-interface.js

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

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

@@ -0,0 +1,5 @@
+export declare class CustomerConfigServiceContext {
+    appName: string;
+    customersDir: string;
+    constructor(appName?: string, customersDir?: string);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerConfigServiceContext = void 0;
+const cli_parameters_1 = require("../../models/cli-parameters");
+class CustomerConfigServiceContext {
+    appName;
+    customersDir;
+    constructor(appName = '', customersDir = cli_parameters_1.CLIParametersExample.CustomersDir) {
+        this.appName = appName;
+        this.customersDir = customersDir;
+        this.appName = appName;
+        this.customersDir = customersDir;
+    }
+}
+exports.CustomerConfigServiceContext = CustomerConfigServiceContext;

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

@@ -0,0 +1,8 @@
+import { CustomerConfigService, CustomerConfigServiceContext } from ".";
+export declare class CustomerConfigServiceFactory {
+    private readonly context;
+    private service?;
+    constructor(context: CustomerConfigServiceContext);
+    buildService(): Promise<CustomerConfigService>;
+    private build;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerConfigServiceFactory = void 0;
+const cli_1 = require("../cli");
+const _1 = require(".");
+class CustomerConfigServiceFactory {
+    context;
+    service;
+    constructor(context) {
+        this.context = context;
+    }
+    async buildService() {
+        if (!(this.service instanceof _1.CustomerConfigService)) {
+            await this.build();
+        }
+        return this.service;
+    }
+    async build() {
+        const context = this.context;
+        const cliService = new cli_1.CliServiceFactory().getService();
+        this.service = new _1.CustomerConfigService(context, cliService);
+    }
+}
+exports.CustomerConfigServiceFactory = CustomerConfigServiceFactory;

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

@@ -0,0 +1,39 @@
+export declare enum DirectoryOverwriteOption {
+    NEW_NAME = "Choose a new directory name",
+    OVERWRITE_FILE_WISE = "Keep and overwrite file-wise (ask)",
+    OVERWRITE_COMPLETELY = "Empty and create new"
+}
+export declare enum ShopSystem {
+    OTHER = "None of the below-mentioned",
+    SHOPIFY = "Shopify",
+    SHOPWARE = "Shopware",
+    SALESFORCE = "Salesforce Commerce Cloud",
+    PLENTYMARKETS = "Plentymarkets"
+}
+export declare enum EnvironmentType {
+    PRODUCTION = "production",
+    STAGING = "staging",
+    TEST = "test"
+}
+export interface EnvironmentConfig {
+    host?: string;
+    forceInstall?: boolean;
+}
+export interface CustomerConfigSettings {
+    appName?: string;
+    production?: EnvironmentConfig;
+    staging?: EnvironmentConfig;
+    includeServiceWorker?: string;
+    activateImageOptimisation?: boolean;
+    removeLazyLoading?: boolean;
+    addPreRendering?: boolean;
+    activateRumTracking?: boolean;
+    useGATracking?: boolean;
+    withGoogleOptimize?: boolean;
+    activateCfRocketLoaderWorkaround?: boolean;
+    isShopify?: boolean;
+    isShopware?: boolean;
+    isSalesforce?: boolean;
+    isPlentymarkets?: boolean;
+    shopifyId?: string;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentType = exports.ShopSystem = exports.DirectoryOverwriteOption = void 0;
+var DirectoryOverwriteOption;
+(function (DirectoryOverwriteOption) {
+    DirectoryOverwriteOption["NEW_NAME"] = "Choose a new directory name";
+    DirectoryOverwriteOption["OVERWRITE_FILE_WISE"] = "Keep and overwrite file-wise (ask)";
+    DirectoryOverwriteOption["OVERWRITE_COMPLETELY"] = "Empty and create new";
+})(DirectoryOverwriteOption || (exports.DirectoryOverwriteOption = DirectoryOverwriteOption = {}));
+var ShopSystem;
+(function (ShopSystem) {
+    ShopSystem["OTHER"] = "None of the below-mentioned";
+    ShopSystem["SHOPIFY"] = "Shopify";
+    ShopSystem["SHOPWARE"] = "Shopware";
+    ShopSystem["SALESFORCE"] = "Salesforce Commerce Cloud";
+    ShopSystem["PLENTYMARKETS"] = "Plentymarkets";
+})(ShopSystem || (exports.ShopSystem = ShopSystem = {}));
+var EnvironmentType;
+(function (EnvironmentType) {
+    EnvironmentType["PRODUCTION"] = "production";
+    EnvironmentType["STAGING"] = "staging";
+    EnvironmentType["TEST"] = "test";
+})(EnvironmentType || (exports.EnvironmentType = EnvironmentType = {}));

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

@@ -0,0 +1,27 @@
+import { CliService } from "../cli";
+import { CustomerConfigServiceContext } from "./customer-config-service-context";
+import { CustomerConfigSettings } from "./customer-config-service-model";
+export declare class CustomerConfigService {
+    private context;
+    private cli;
+    private _appName;
+    private _outputDirPath;
+    private get appName();
+    private set appName(value);
+    private set outputDirPath(value);
+    private get outputDirPath();
+    private templates;
+    constructor(context: CustomerConfigServiceContext, cli: CliService);
+    private getOutputDirPath;
+    private getHandlebarsOutputFileName;
+    private getPathWithChangedDir;
+    private isDirNotEmpty;
+    private selectOutputDirectory;
+    private compileHandlebarsFiles;
+    private getEnvironmentConfig;
+    private shouldFileBeOverwritten;
+    private downloadAndSaveFile;
+    private getConfigSettings;
+    handleDocumentHandler({ addPreRendering }: CustomerConfigSettings): Promise<void>;
+    generateConfig(): Promise<void>;
+}

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

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomerConfigService = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const Handlebars = tslib_1.__importStar(require("handlebars"));
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const cli_1 = require("../cli");
+const customer_config_service_model_1 = require("./customer-config-service-model");
+class CustomerConfigService {
+    context;
+    cli;
+    _appName;
+    _outputDirPath;
+    get appName() {
+        return this._appName;
+    }
+    set appName(newName) {
+        this._appName = newName;
+        this.outputDirPath = this.getOutputDirPath(newName);
+    }
+    set outputDirPath(newPath) {
+        this._outputDirPath = newPath;
+    }
+    get outputDirPath() {
+        return this._outputDirPath;
+    }
+    templates = [
+        'config_customer.js.hbs',
+        'config_documentHandler.js.hbs',
+        'config_dynamicBlocks.es6.hbs',
+        'config_dynamicStyles.css.hbs',
+        'config_loadHandler.js.hbs',
+        'config_SpeedKit.js.hbs'
+    ];
+    constructor(context, cli) {
+        this.context = context;
+        const { appName } = this.context;
+        this.appName = appName;
+        this.cli = cli;
+    }
+    getOutputDirPath(dirName = '') {
+        return path.join(process.cwd(), this.context.customersDir, dirName);
+    }
+    getHandlebarsOutputFileName(fileName) {
+        return fileName.replace('.hbs', '');
+    }
+    getPathWithChangedDir(dirPath, newDir) {
+        return path.join(path.dirname(dirPath), newDir);
+    }
+    isDirNotEmpty(dirPath) {
+        return fs.existsSync(dirPath) && fs.readdirSync(dirPath).length > 0;
+    }
+    async selectOutputDirectory(dirPath) {
+        // protect output directory if already existing and not empty:
+        if (this.isDirNotEmpty(dirPath)) {
+            this.cli.spacer();
+            const selectedDirectoryOverwriteOption = await this.cli.select(`Output directory ${dirPath} is not empty. How to proceed?`, Object.values(customer_config_service_model_1.DirectoryOverwriteOption).map(option => ({ name: option, value: option })));
+            switch (selectedDirectoryOverwriteOption) {
+                case customer_config_service_model_1.DirectoryOverwriteOption.OVERWRITE_COMPLETELY:
+                    fs.rmSync(dirPath, { recursive: true, force: true });
+                    fs.mkdirSync(dirPath, { recursive: true });
+                    break;
+                case customer_config_service_model_1.DirectoryOverwriteOption.NEW_NAME:
+                    const dirName = path.basename(dirPath);
+                    let proposedNewDirName;
+                    const regExFollowingNumber = /-(\d+)$/;
+                    const match = dirName.match(regExFollowingNumber);
+                    if (match && match.length > 1) {
+                        const numberAtTheEndOfDirName = Number(match[1]);
+                        proposedNewDirName = dirName.replace(regExFollowingNumber, `-${String(numberAtTheEndOfDirName + 1)}`);
+                    }
+                    else {
+                        proposedNewDirName = `${dirName}-2`;
+                    }
+                    const newDirName = await this.cli.prompt(`Please enter new output directory name:`, {
+                        defaultAnswer: proposedNewDirName
+                    });
+                    return this.selectOutputDirectory(this.getPathWithChangedDir(dirPath, newDirName));
+            }
+        }
+        return dirPath;
+    }
+    async compileHandlebarsFiles(configSettings) {
+        // overwriting protection for output directory:
+        this.outputDirPath = await this.selectOutputDirectory(this.outputDirPath);
+        this.cli.spacer();
+        // write files:
+        for (const templateFile of this.templates) {
+            const outputFileName = this.getHandlebarsOutputFileName(templateFile);
+            this.cli.startAction(`Adding ${outputFileName}`);
+            try {
+                const outputFilePath = path.join(this.outputDirPath, outputFileName);
+                if (!await this.shouldFileBeOverwritten(outputFilePath)) {
+                    this.cli.endAction(cli_1.CliActionStatus.SKIPPED);
+                    continue;
+                }
+                const filePath = path.join(__dirname, './templates', templateFile);
+                const content = fs.readFileSync(filePath, 'utf8');
+                const template = Handlebars.compile(content);
+                const result = template(configSettings);
+                fs.mkdirSync(path.dirname(outputFilePath), { recursive: true });
+                fs.writeFileSync(outputFilePath, result);
+                this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
+            }
+            catch (error) {
+                this.cli.endAction(cli_1.CliActionStatus.FAILED);
+            }
+        }
+        this.cli.spacer();
+    }
+    async getEnvironmentConfig(environmentType, defaultHost) {
+        const host = await this.cli.prompt(`Enter ${environmentType.toUpperCase()} Host (without https://):`, {
+            defaultAnswer: defaultHost
+        });
+        const forceInstall = !(await this.cli.confirm(`Is the install.js already present on ${environmentType.toUpperCase()}?`, false));
+        return {
+            host,
+            forceInstall
+        };
+    }
+    async shouldFileBeOverwritten(outputFilePath) {
+        if (fs.existsSync(outputFilePath)) {
+            const overwrite = await this.cli.confirm(`File ${path.basename(outputFilePath)} already exists. Overwrite?`);
+            if (!overwrite)
+                return false;
+        }
+        return true;
+    }
+    async downloadAndSaveFile(url, outputFilePath) {
+        this.cli.startAction(`Adding ${path.basename(outputFilePath)}`);
+        try {
+            if (!await this.shouldFileBeOverwritten(outputFilePath)) {
+                this.cli.endAction(cli_1.CliActionStatus.SKIPPED);
+                return;
+            }
+            const response = await axios_1.default.get(url, { responseType: 'text' });
+            const date = new Date();
+            const day = String(date.getDate()).padStart(2, '0');
+            const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-indexed
+            const year = date.getFullYear();
+            const time = date.toLocaleTimeString('de-DE');
+            const formattedDate = `${day}.${month}.${year}, ${time}`;
+            // Add timestamp banner to the file
+            const banner = `/**\n * Downloaded from:\n * ${url}\n * \n * Date: ${formattedDate}\n */\n\n`;
+            const contentWithBanner = banner + response.data;
+            fs.writeFileSync(outputFilePath, contentWithBanner);
+            this.cli.endAction(cli_1.CliActionStatus.COMPLETED);
+        }
+        catch (error) {
+            this.cli.endAction(cli_1.CliActionStatus.FAILED);
+        }
+    }
+    async getConfigSettings() {
+        let { production, staging, includeServiceWorker, activateImageOptimisation, removeLazyLoading, addPreRendering, activateRumTracking, useGATracking, withGoogleOptimize, activateCfRocketLoaderWorkaround, isShopify, isShopware, isSalesforce, isPlentymarkets, shopifyId } = {};
+        this.appName = await this.cli.prompt(`Enter SK App Name:`, {
+            validator: (input) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(input) ? '' : 'No valid kebab-case',
+            defaultAnswer: this.appName
+        });
+        const selectedShopSystem = await this.cli.select('Which Shop System is in use?', Object.values(customer_config_service_model_1.ShopSystem).map(option => ({ name: option, value: option })));
+        switch (selectedShopSystem) {
+            case customer_config_service_model_1.ShopSystem.SHOPIFY:
+                isShopify = true;
+                break;
+            case customer_config_service_model_1.ShopSystem.SHOPWARE:
+                isShopware = true;
+                break;
+            case customer_config_service_model_1.ShopSystem.SALESFORCE:
+                isSalesforce = true;
+                break;
+            case customer_config_service_model_1.ShopSystem.PLENTYMARKETS:
+                isPlentymarkets = true;
+        }
+        production = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.PRODUCTION, `www.${this.appName}.de`);
+        if (isShopify) {
+            shopifyId = await this.cli.prompt(`Enter Shopify ID:`, { defaultAnswer: this.appName });
+        }
+        else {
+            const withStaging = await this.cli.confirm(`Add Config for ${customer_config_service_model_1.EnvironmentType.STAGING.toUpperCase()} Environment?`, false);
+            if (withStaging) {
+                staging = await this.getEnvironmentConfig(customer_config_service_model_1.EnvironmentType.STAGING, production.host.replace('www', 'stg'));
+            }
+        }
+        if (await this.cli.confirm('Is there a Service Worker which needs to be included?', false)) {
+            includeServiceWorker = await this.cli.prompt('Enter path of Service Worker to be included:', { defaultAnswer: '/sw.js' });
+        }
+        activateImageOptimisation = await this.cli.confirm('Activate Image Optimisation?', false);
+        removeLazyLoading = await this.cli.confirm('Remove Lazy-Loading?');
+        addPreRendering = await this.cli.confirm('Add Pre-Rendering? This requires a set-up Lambda function to work. Also requires a DOM-based DocumentHandler.', false);
+        activateRumTracking = await this.cli.confirm('Activate RUM Tracking?');
+        if (activateRumTracking) {
+            if (!isShopify) {
+                useGATracking = await this.cli.confirm('Add Tracking based on Google Analytics\' DataLayer?');
+            }
+        }
+        withGoogleOptimize = await this.cli.confirm('Is Google Optimize being used?', false);
+        if (isShopify) {
+            activateCfRocketLoaderWorkaround = true;
+        }
+        else {
+            activateCfRocketLoaderWorkaround = await this.cli.confirm('Activate Workaround for Cloudflare\'s Rocket Loader?', false);
+        }
+        return {
+            appName: this.appName,
+            production,
+            staging,
+            includeServiceWorker,
+            activateImageOptimisation,
+            removeLazyLoading,
+            addPreRendering,
+            activateRumTracking,
+            useGATracking,
+            withGoogleOptimize,
+            activateCfRocketLoaderWorkaround,
+            isShopify,
+            isShopware,
+            isSalesforce,
+            isPlentymarkets,
+            shopifyId
+        };
+    }
+    async handleDocumentHandler({ addPreRendering }) {
+        /*
+          TODO:
+           remove this custom DocumentHandler handling as soon as the DOM-parsing DocumentHandler has been released
+           and can be controlled/activated by the DocumentHandler Config properly
+         */
+        if (addPreRendering) {
+            const documentHandlerBranchName = 'dom-parser/develop';
+            const customDocumentHandlerOutputPath = path.join(this.outputDirPath, 'custom_documentHandler.js');
+            this.cli.writeWarning(`
+      ⚠️ MANUAL ACTION NEEDED ⚠️
+
+      Your config needs the DOM-parsing DocumentHandler which has not been publicly released yet.
+
+      Working Branch: ${this.cli.codeStyle(documentHandlerBranchName)} (https://gitlab.orestes.info/baqend/document-handler/-/tree/${documentHandlerBranchName})
+
+      Please add it to your newly created config directory manually:
+
+      1. ${this.cli.codeStyle(`git clone -b ${documentHandlerBranchName} git@vm.orestes.info:baqend/document-handler.git`)}
+      2. ${this.cli.codeStyle(`cd ./document-handler`)}
+      3. ${this.cli.codeStyle(`npm ci && npm run build`)}
+      4. ${this.cli.codeStyle(`cp ./dist/DocumentHandler.js ${customDocumentHandlerOutputPath}`)}
+    `);
+        }
+    }
+    async generateConfig() {
+        this.cli.write('\nLet\'s generate a config...\n');
+        const configSettings = await this.getConfigSettings();
+        if (configSettings.isSalesforce) {
+            this.templates.push('deploymentDetection.es6.hbs');
+        }
+        const addDowntimeDetection = await this.cli.confirm('Add Downtime Detection?', false);
+        if (addDowntimeDetection) {
+            this.templates.push('downtimeDetection.js.hbs');
+        }
+        await this.compileHandlebarsFiles(configSettings);
+        await this.handleDocumentHandler(configSettings);
+        this.cli.writeSuccess('\nConfig generation completed 👏\n');
+    }
+}
+exports.CustomerConfigService = CustomerConfigService;

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

@@ -0,0 +1,4 @@
+export * from './customer-config-service';
+export * from './customer-config-service-context';
+export * from './customer-config-service-model';
+export * from './customer-config-service-factory';