@speedkit/cli 2.4.1

package/dist/services/integration-api/handler/module-handler.d.ts

@@ -0,0 +1,12 @@
+import FileHandler from "./file-handler";
+import { ModuleInterface } from "../integration-api-model";
+export default class ModuleHandler extends FileHandler {
+    blackList: string[];
+    /**
+     * ModuleHandler will try to upload everything left as a module
+     * make sure to call this as last handler
+     * @param filePath
+     */
+    canHandle(filePath: string): boolean;
+    handle(filePath: string): Promise<ModuleInterface>;
+}

package/dist/services/integration-api/handler/module-handler.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_handler_1 = tslib_1.__importDefault(require("./file-handler"));
+const module_file_1 = tslib_1.__importDefault(require("../struct/module-file"));
+class ModuleHandler extends file_handler_1.default {
+    blackList = [];
+    /**
+     * ModuleHandler will try to upload everything left as a module
+     * make sure to call this as last handler
+     * @param filePath
+     */
+    canHandle(filePath) {
+        return this.blackList.indexOf(this.getFileName(filePath)) === -1;
+    }
+    async handle(filePath) {
+        return new module_file_1.default(this.getFileName(filePath), filePath, await this.fileReader.getContent(filePath), module_file_1.default);
+    }
+}
+exports.default = ModuleHandler;

package/dist/services/integration-api/handler/server-config-handler.d.ts

@@ -0,0 +1,8 @@
+import FileHandler from "./file-handler";
+import { ServerConfigInterface } from "../integration-api-model";
+export default class ServerConfigHandler extends FileHandler {
+    allowedFiles: string[];
+    canHandle(filePath: string): boolean;
+    handle(filePath: string): Promise<ServerConfigInterface>;
+    private getConfig;
+}

package/dist/services/integration-api/handler/server-config-handler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_handler_1 = tslib_1.__importDefault(require("./file-handler"));
+const server_config_file_1 = tslib_1.__importDefault(require("../struct/server-config-file"));
+class ServerConfigHandler extends file_handler_1.default {
+    allowedFiles = [
+        'orestes_config',
+    ];
+    canHandle(filePath) {
+        return this.allowedFiles.indexOf(this.getFileName(filePath)) !== -1;
+    }
+    async handle(filePath) {
+        const fileContent = await this.fileReader.getContent(filePath);
+        return new server_config_file_1.default(this.getFileName(filePath), filePath, fileContent, this.getConfig(fileContent));
+    }
+    getConfig(content) {
+        return JSON.parse(content);
+    }
+}
+exports.default = ServerConfigHandler;

package/dist/services/integration-api/integration-api-model.d.ts

@@ -0,0 +1,89 @@
+import CustomerConfig from "./struct/customer-config";
+import { RoFile } from "./struct/ro-file";
+import { VirtualFile } from "./struct/virtual-file";
+export interface CustomerConfigOnboardingFile {
+    module: {
+        exports: {
+            [key: string]: CustomerConfig;
+        };
+    };
+    process: {
+        env: {
+            TEST_APP: string;
+        };
+    };
+}
+type FileType = InstallResourceInterface | ModuleInterface | ServerConfigInterface | FileInterface | RoFile | VirtualFile;
+type FileTypes = FileType[];
+export interface FileListInterface {
+    files: (InstallResourceInterface | ModuleInterface | ServerConfigInterface | FileInterface | RoFile | VirtualFile)[];
+    addFile(file: FileInterface): void;
+    getInstallResources(): InstallResourceInterface[];
+    getModules(): ModuleInterface[];
+    getServerConfig(): ServerConfigInterface;
+    getCustomerConfig(): CustomerConfigInterface;
+    getByType(type: any): FileTypes;
+    getTypes(): any[];
+    filter(callback: (file: FileInterface) => boolean): void;
+    hasFile(fileName: string): boolean;
+    getByName<T>(name: string): T;
+    concat(fileList: FileListInterface): void;
+    replace(replace: (InstallResourceInterface | ModuleInterface | ServerConfigInterface | FileInterface | RoFile | VirtualFile)): void;
+}
+export interface IntegrationApiContextInterface {
+    basePath: string;
+    configName: string;
+    whiteList: string[];
+    blockedFolders: string[];
+}
+export interface IntegrationApiHandler {
+    canHandle(filePath: string): boolean;
+    handle(filePath: string): Promise<FileInterface>;
+}
+export interface MandatoryFilesConfigInterface {
+    required: string[];
+    conditionallyRequired: {
+        this: string[];
+        or: string[];
+    };
+}
+export interface FileInterface {
+    readonly type: any;
+    readonly name: string;
+    skipFile(): void;
+    shouldSkipFile(): boolean;
+    getContent(): string;
+}
+export interface ConfigFileInterface extends FileInterface {
+    readonly path: string;
+    setContent(content: string): void;
+    updateFile(): Promise<void>;
+    updateIfChanged(): Promise<void>;
+    isUpdated(): boolean;
+    onChange(callback?: (file: FileInterface) => Promise<void>): void;
+    delete(): Promise<void>;
+}
+export interface ModuleInterface extends ConfigFileInterface, FileInterface {
+}
+export interface ServerConfigInterface extends ConfigFileInterface, FileInterface {
+    config: {};
+}
+export interface InstallResourceInterface extends ConfigFileInterface, FileInterface {
+    readonly remoteKey: string;
+}
+export interface CustomerConfigInterface extends ConfigFileInterface, FileInterface {
+    config: CustomerConfig;
+    readonly configName: string;
+}
+export interface VirtualFileRecipe {
+    createContent(): Promise<string>;
+}
+export interface VirtualFileInterface {
+    getContent(): string;
+}
+export type VirtualFileConfig = {
+    name: string;
+    recipe: VirtualFileRecipe;
+    overrideLocalFile?: boolean;
+};
+export {};

package/dist/services/integration-api/integration-api-model.js

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

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

@@ -0,0 +1,21 @@
+import FileReader from "./file-reader";
+import MandatoryFilesValidator from "./validator/mandatory-files-validator";
+import FileWriter from "./file-writer";
+import { FileListInterface, IntegrationApiHandler, VirtualFileConfig } from "./integration-api-model";
+import { VirtualFileHandler } from "./virtual/virtual-file-handler";
+export default class IntegrationApiService {
+    private fileReader;
+    private virtualFileHandler;
+    private validator;
+    private handlers;
+    private fileWriter;
+    private shouldValidate;
+    constructor(fileReader: FileReader, virtualFileHandler: VirtualFileHandler, validator: MandatoryFilesValidator, handlers: IntegrationApiHandler[], fileWriter: FileWriter, shouldValidate: boolean);
+    run(virtualFiles?: VirtualFileConfig[]): Promise<FileListInterface>;
+    fileExists(fileName: string, extension?: string): boolean;
+    writeFile(fileName: string, extension?: string, content?: string): void;
+    createFolder(path: string): void;
+    private collectFiles;
+    private processFile;
+    private filterFilesToProcess;
+}

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_list_1 = tslib_1.__importDefault(require("./file-list"));
+class IntegrationApiService {
+    fileReader;
+    virtualFileHandler;
+    validator;
+    handlers;
+    fileWriter;
+    shouldValidate;
+    constructor(fileReader, virtualFileHandler, validator, handlers, fileWriter, shouldValidate) {
+        this.fileReader = fileReader;
+        this.virtualFileHandler = virtualFileHandler;
+        this.validator = validator;
+        this.handlers = handlers;
+        this.fileWriter = fileWriter;
+        this.shouldValidate = shouldValidate;
+    }
+    async run(virtualFiles) {
+        const fileList = await this.collectFiles();
+        if (virtualFiles?.length > 0) {
+            await this.virtualFileHandler.processFiles(fileList, virtualFiles);
+        }
+        return fileList;
+    }
+    fileExists(fileName, extension = 'js') {
+        return this.fileWriter.hasFile(fileName, extension);
+    }
+    writeFile(fileName, extension = 'js', content = '') {
+        this.fileWriter.writeFile(fileName, extension, content);
+    }
+    createFolder(path) {
+        this.fileWriter.mkdir(path);
+    }
+    async collectFiles() {
+        const files = await this.fileReader.getFileList();
+        const fileList = new file_list_1.default();
+        for (let iteration = 0; iteration < files.length; iteration++) {
+            let file = files[iteration];
+            fileList.addFile(await this.processFile(file));
+        }
+        if (this.shouldValidate) {
+            this.filterFilesToProcess(fileList);
+            this.validator.validate(fileList);
+        }
+        return fileList;
+    }
+    async processFile(file) {
+        for (let iterator = 0; iterator < this.handlers.length; iterator++) {
+            let handler = this.handlers[iterator];
+            if (handler.canHandle(file)) {
+                return await handler.handle(file);
+            }
+        }
+        throw Error(`No handler found for file: ${file}`);
+    }
+    filterFilesToProcess(fileList) {
+        fileList.filter((file) => {
+            // if we have a documentHandlerConfig we don't need an assetHandler
+            if (file.name === 'speedKit.Asset' && fileList.hasFile('config_documentHandler')) {
+                return false;
+            }
+            // if we don't have a documentHandlerConfig we don't need styles
+            if (file.name === 'config_dynamicStyles' && !fileList.hasFile('config_documentHandler')) {
+                return false;
+            }
+            // if we don't have a documentHandlerConfig we don't need dynamicBlocks
+            if (file.name === 'config_dynamicBlocks' && !fileList.hasFile('config_documentHandler')) {
+                return false;
+            }
+            return true;
+        });
+    }
+}
+exports.default = IntegrationApiService;

package/dist/services/integration-api/struct/customer-config-file.d.ts

@@ -0,0 +1,10 @@
+import File from "./file";
+import CustomerConfig from "./customer-config";
+import { CustomerConfigInterface } from "../integration-api-model";
+export default class CustomerConfigFile extends File implements CustomerConfigInterface {
+    config: CustomerConfig;
+    readonly configName: string;
+    constructor(name: string, path: string, content: string, config: CustomerConfig, configName: string);
+    setContent(content: string): void;
+    private updateConfigByContent;
+}

package/dist/services/integration-api/struct/customer-config-file.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_1 = tslib_1.__importDefault(require("./file"));
+const customer_config_1 = tslib_1.__importDefault(require("./customer-config"));
+const vm = tslib_1.__importStar(require("vm"));
+class CustomerConfigFile extends file_1.default {
+    config;
+    configName;
+    constructor(name, path, content, config, configName) {
+        super(name, path, content, CustomerConfigFile);
+        this.config = config;
+        this.configName = configName;
+    }
+    setContent(content) {
+        super.setContent(content);
+        this.updateConfigByContent();
+    }
+    updateConfigByContent() {
+        const customerConfigContext = {
+            module: { exports: {} },
+            process: {
+                env: { TEST_APP: process.env.TEST_APP } // make TEST_APP available for vm
+            }
+        };
+        vm.runInNewContext(this.getContent(), customerConfigContext);
+        if (this.configName in customerConfigContext.module.exports) {
+            this.config = customer_config_1.default.createFrom(customerConfigContext.module.exports[this.configName], this.configName);
+        }
+    }
+}
+exports.default = CustomerConfigFile;

package/dist/services/integration-api/struct/customer-config.d.ts

@@ -0,0 +1,22 @@
+export default class CustomerConfig {
+    readonly app: string;
+    readonly origins: string[];
+    readonly domain: string;
+    readonly swPath: string;
+    readonly scope: string;
+    readonly appDomain?: string;
+    readonly installPath?: string;
+    readonly installParams?: string;
+    readonly name?: string;
+    readonly forceInstall?: boolean;
+    readonly chromeFlags?: string[];
+    readonly dependencies?: {
+        [dependency: string]: string;
+    };
+    readonly skCliPre?: string;
+    readonly skCliPost?: string;
+    constructor(app: string, origins: string[], domain: string, swPath: string, scope: string, appDomain?: string, installPath?: string, installParams?: string, name?: string, forceInstall?: boolean, chromeFlags?: string[], dependencies?: {
+        [dependency: string]: string;
+    }, skCliPre?: string, skCliPost?: string);
+    static createFrom(configFile: any, configName?: string): CustomerConfig;
+}

package/dist/services/integration-api/struct/customer-config.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const customer_config_error_1 = tslib_1.__importDefault(require("../error/customer-config-error"));
+class CustomerConfig {
+    app;
+    origins;
+    domain;
+    swPath;
+    scope;
+    appDomain;
+    installPath;
+    installParams;
+    name;
+    forceInstall;
+    chromeFlags;
+    dependencies;
+    skCliPre;
+    skCliPost;
+    constructor(app, origins, domain, swPath, scope, appDomain, installPath, installParams, name, forceInstall, chromeFlags, dependencies, skCliPre, skCliPost) {
+        this.app = app;
+        this.origins = origins;
+        this.domain = domain;
+        this.swPath = swPath;
+        this.scope = scope;
+        this.appDomain = appDomain;
+        this.installPath = installPath;
+        this.installParams = installParams;
+        this.name = name;
+        this.forceInstall = forceInstall;
+        this.chromeFlags = chromeFlags;
+        this.dependencies = dependencies;
+        this.skCliPre = skCliPre;
+        this.skCliPost = skCliPost;
+    }
+    static createFrom(configFile, configName) {
+        const { app, origins, domain, swPath, scope, appDomain, installPath, installParams, name, forceInstall, chromeFlags, dependencies, skCliPre, skCliPost } = configFile;
+        return new CustomerConfig(new RequiredParam('app', app).isString().getValue(), new RequiredParam('origins', origins).isArray().getValue(), new RequiredParam('domain', domain).isString().getValue(), new RequiredParam('swPath', swPath).isString().getValue(), new RequiredParam('scope', scope).isString().getValue(), appDomain || `${app}.app.baqend.com`, installPath || `https://${app}.app.baqend.com/v1/speedkit/install.js?d=${name || configName}`, installParams || 'async="" crossorigin="anonymous"', name, forceInstall, chromeFlags, dependencies, skCliPre, skCliPost);
+    }
+}
+exports.default = CustomerConfig;
+class RequiredParam {
+    key;
+    value;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+        if (!this.value) {
+            throw new customer_config_error_1.default(`param: "${this.key}" is mandatory in config_customer`);
+        }
+    }
+    isString() {
+        if (typeof this.value !== "string") {
+            throw new customer_config_error_1.default(`param: "${this.key}" must be a string`);
+        }
+        return this;
+    }
+    isArray() {
+        if (!Array.isArray(this.value)) {
+            throw new customer_config_error_1.default(`param: "${this.key}" must be an array`);
+        }
+        return this;
+    }
+    getValue() {
+        return this.value;
+    }
+}

package/dist/services/integration-api/struct/file.d.ts

@@ -0,0 +1,19 @@
+import { ConfigFileInterface, FileInterface } from "../integration-api-model";
+export default class File implements ConfigFileInterface, FileInterface {
+    readonly name: string;
+    readonly path: string;
+    readonly type: string;
+    private content;
+    private skip;
+    private updated;
+    constructor(name: string, path: string, content: string, type?: any);
+    skipFile(): void;
+    shouldSkipFile(): boolean;
+    getContent(): string;
+    setContent(content: string): void;
+    isUpdated(): boolean;
+    updateFile(): Promise<void>;
+    updateIfChanged(): Promise<void>;
+    onChange(callback: (file: FileInterface) => Promise<void>): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/services/integration-api/struct/file.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const promises_2 = require("fs/promises");
+class File {
+    name;
+    path;
+    type;
+    content;
+    skip = false;
+    updated = false;
+    constructor(name, path, content, type = File) {
+        this.name = name;
+        this.path = path;
+        this.content = content;
+        this.type = type;
+    }
+    skipFile() {
+        this.skip = true;
+    }
+    shouldSkipFile() {
+        return this.skip;
+    }
+    getContent() {
+        return this.content;
+    }
+    setContent(content) {
+        if (content === this.content) {
+            return;
+        }
+        this.updated = true;
+        this.content = content;
+    }
+    isUpdated() {
+        return this.updated;
+    }
+    async updateFile() {
+        await (0, promises_1.writeFile)(this.path, this.content);
+        this.updated = false;
+    }
+    async updateIfChanged() {
+        const content = await (0, promises_1.readFile)(this.path, 'utf-8');
+        if (content !== this.content) {
+            await this.updateFile();
+        }
+    }
+    async onChange(callback) {
+        const watcher = (0, promises_1.watch)(this.path, { encoding: 'utf-8' });
+        for await (const info of watcher) {
+            if (info.eventType !== 'change') {
+                continue;
+            }
+            this.setContent(await (0, promises_1.readFile)(this.path, 'utf-8'));
+            await callback(this);
+        }
+    }
+    async delete() {
+        await (0, promises_2.unlink)(this.path);
+    }
+}
+exports.default = File;

package/dist/services/integration-api/struct/install-resource-file.d.ts

@@ -0,0 +1,6 @@
+import File from "./file";
+import { InstallResourceInterface } from "../integration-api-model";
+export default class InstallResourceFile extends File implements InstallResourceInterface {
+    readonly remoteKey: string;
+    constructor(name: string, path: string, content: string, remoteKey: string);
+}

package/dist/services/integration-api/struct/install-resource-file.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_1 = tslib_1.__importDefault(require("./file"));
+class InstallResourceFile extends file_1.default {
+    remoteKey;
+    constructor(name, path, content, remoteKey) {
+        super(name, path, content, InstallResourceFile);
+        this.remoteKey = remoteKey;
+    }
+}
+exports.default = InstallResourceFile;

package/dist/services/integration-api/struct/module-file.d.ts

@@ -0,0 +1,5 @@
+import File from "./file";
+import { ModuleInterface } from "../integration-api-model";
+export default class ModuleFile extends File implements ModuleInterface {
+    constructor(name: string, path: string, content: string, config: {});
+}

package/dist/services/integration-api/struct/module-file.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_1 = tslib_1.__importDefault(require("./file"));
+class ModuleFile extends file_1.default {
+    constructor(name, path, content, config) {
+        super(name, path, content, ModuleFile);
+    }
+}
+exports.default = ModuleFile;

package/dist/services/integration-api/struct/ro-file.d.ts

@@ -0,0 +1,13 @@
+import { FileInterface } from "../integration-api-model";
+export declare class RoFile implements FileInterface {
+    readonly name: string;
+    readonly path: string;
+    protected content: string;
+    protected skip: boolean;
+    protected updated: boolean;
+    readonly type: any;
+    constructor(name: string, path: string, content: string);
+    skipFile(): void;
+    shouldSkipFile(): boolean;
+    getContent(): string;
+}

package/dist/services/integration-api/struct/ro-file.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoFile = void 0;
+class RoFile {
+    name;
+    path;
+    content;
+    skip = false;
+    updated = false;
+    type = RoFile;
+    constructor(name, path, content) {
+        this.name = name;
+        this.path = path;
+        this.content = content;
+    }
+    skipFile() {
+        this.skip = true;
+    }
+    shouldSkipFile() {
+        return this.skip;
+    }
+    getContent() {
+        return this.content;
+    }
+}
+exports.RoFile = RoFile;

package/dist/services/integration-api/struct/server-config-file.d.ts

@@ -0,0 +1,9 @@
+import File from "./file";
+import { ServerConfigInterface } from "../integration-api-model";
+export default class ServerConfigFile extends File implements ServerConfigInterface {
+    config: any;
+    constructor(name: string, path: string, content: string, config: {});
+    getContent(): string;
+    setContent(content: string): void;
+    private getConfigAsString;
+}

package/dist/services/integration-api/struct/server-config-file.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const file_1 = tslib_1.__importDefault(require("./file"));
+class ServerConfigFile extends file_1.default {
+    config;
+    constructor(name, path, content, config) {
+        super(name, path, content, ServerConfigFile);
+        this.config = config;
+    }
+    getContent() {
+        return this.getConfigAsString();
+    }
+    setContent(content) {
+        super.setContent(content);
+        this.config = JSON.parse(content);
+    }
+    getConfigAsString() {
+        return JSON.stringify(this.config);
+    }
+}
+exports.default = ServerConfigFile;

package/dist/services/integration-api/struct/virtual-file.d.ts

@@ -0,0 +1,14 @@
+import { FileInterface, VirtualFileInterface, VirtualFileRecipe } from "../integration-api-model";
+export declare class VirtualFile implements VirtualFileInterface, FileInterface {
+    readonly name: string;
+    private recipe;
+    protected skip: boolean;
+    protected updated: boolean;
+    protected content: string;
+    readonly type: any;
+    constructor(name: string, recipe: VirtualFileRecipe);
+    skipFile(): void;
+    shouldSkipFile(): boolean;
+    getContent(): string;
+    buildContent(): Promise<void>;
+}

package/dist/services/integration-api/struct/virtual-file.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualFile = void 0;
+class VirtualFile {
+    name;
+    recipe;
+    skip = false;
+    updated = false;
+    content;
+    type = VirtualFile;
+    constructor(name, recipe) {
+        this.name = name;
+        this.recipe = recipe;
+    }
+    skipFile() {
+        this.skip = true;
+    }
+    shouldSkipFile() {
+        return this.skip;
+    }
+    getContent() {
+        return this.content;
+    }
+    async buildContent() {
+        this.content = await this.recipe.createContent();
+    }
+}
+exports.VirtualFile = VirtualFile;

package/dist/services/integration-api/validator/customer-config-validator.d.ts

@@ -0,0 +1,5 @@
+import CustomerConfig from "../struct/customer-config";
+export default class CustomerConfigValidator {
+    validate(config: CustomerConfig): void;
+    private checkIfDuplicateExists;
+}

package/dist/services/integration-api/validator/customer-config-validator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const origin_error_1 = tslib_1.__importDefault(require("../error/origin-error"));
+class CustomerConfigValidator {
+    validate(config) {
+        const withoutProtocol = config.origins.filter(origin => !origin.startsWith('http'));
+        // There was at least one origin not having a protocol => Do not allow creation of install resource.
+        if (withoutProtocol.length > 0) {
+            throw new origin_error_1.default({ app: config.app, message: 'There was at least one origin configured in the local customer_config.js not having a protocol.' });
+        }
+        if (config.origins.length === 0) {
+            throw new origin_error_1.default({ app: config.app, message: 'No origins were found in local config_customer.js! Add origins and restart deploy!' });
+        }
+        if (this.checkIfDuplicateExists(config.origins)) {
+            throw new origin_error_1.default({ app: config.app, message: 'Duplicate origins found! Remove duplicates and restart deploy!' });
+        }
+    }
+    checkIfDuplicateExists(arr) {
+        return new Set(arr).size !== arr.length;
+    }
+}
+exports.default = CustomerConfigValidator;