@speedkit/cli 2.4.1

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const install_resource_file_1 = tslib_1.__importDefault(require("../../integration-api/struct/install-resource-file"));
+class InstallResourceHandler {
+    customer;
+    configApi;
+    configName;
+    diffService;
+    cli;
+    builder;
+    deletedFilesChecker;
+    constructor(customer, configApi, configName, diffService, cli, builder, deletedFilesChecker) {
+        this.customer = customer;
+        this.configApi = configApi;
+        this.diffService = diffService;
+        this.configName = configName;
+        this.cli = cli;
+        this.builder = builder;
+        this.deletedFilesChecker = deletedFilesChecker;
+    }
+    canHandle(type) {
+        return type === install_resource_file_1.default;
+    }
+    async handle(files) {
+        const installResource = await this.configApi.getActiveInstall(this.configName);
+        for (let iterator = 0; iterator < files.length; iterator++) {
+            let file = files[iterator];
+            await this.processFile(file, installResource);
+        }
+    }
+    async upload(files) {
+        for (let iterator = 0; iterator < files.length; iterator++) {
+            let file = files[iterator];
+            if (file.shouldSkipFile()) {
+                continue;
+            }
+            let resource = {};
+            resource[file.remoteKey] = file.getContent();
+            this.builder.merge(resource);
+        }
+        await this.deletedFilesChecker.hasDeletedFiles(this.builder, files);
+        if (!this.builder.hasChanges()) {
+            return;
+        }
+        this.cli.write('');
+        this.cli.write('Summary');
+        this.cli.writeBuffer();
+        if (!await this.cli.confirm('InstallResource will be created now. Proceed?')) {
+            this.cli.exit();
+        }
+        let install = await this.getInstallResource();
+        await this.deletedFilesChecker.checkForDeletedLocalFiles(install);
+        await this.configApi.setInstall(install);
+        if (await this.cli.confirm('Activate new installation?')) {
+            await this.configApi.activateInstall(install);
+        }
+    }
+    async processFile(file, installResource) {
+        if (!installResource) {
+            await this.confirm(file, true);
+            return;
+        }
+        const { changedFile, diff } = await this.diffService.diffContent(file.name, file.getContent(), installResource[file.remoteKey]);
+        file.setContent(changedFile);
+        if (diff) {
+            this.cli.writeWarning(`skipped ${file.name} (identical with remote)`);
+            file.skipFile();
+            return;
+        }
+        await this.confirm(file);
+    }
+    async confirm(file, isNew = false) {
+        const confirm = await this.cli.confirm(`${isNew ? 'Create' : 'Update'} ${file.name}?`);
+        if (!confirm) {
+            file.skipFile();
+        }
+        else {
+            if (isNew) {
+                this.cli.write(`consider new ${file.name}`, true);
+            }
+            else {
+                this.cli.write(`consider changed ${file.name}`, true);
+            }
+        }
+    }
+    async getInstallResource() {
+        let install = await this.builder.init(this.configName);
+        const remoteClone = await this.prepareRemoteInstallResource(install);
+        install = this.builder.updateFromRemote(remoteClone);
+        install.description = await this.cli.prompt('Describe new configuration:', {
+            defaultAnswer: install.description ? install.description : this.configName,
+            validator: input => input.trim() ? '' : 'Please enter something'
+        });
+        return install;
+    }
+    async prepareRemoteInstallResource(resource) {
+        if (resource && resource.version && resource.id) {
+            return await this.configApi.cloneInstall(resource);
+        }
+        return await this.configApi.addInstall(this.configName, resource.origins);
+    }
+}
+exports.default = InstallResourceHandler;

package/dist/services/deploy/handler/install-resource-modifier/deleted-file-check.d.ts

@@ -0,0 +1,13 @@
+import Install from "../../interface/install";
+import { CliService } from "../../../cli";
+import InstallResourceBuilder from "../../builder/install-resource-builder";
+import { InstallResourceInterface } from "../../../integration-api/integration-api-model";
+export default class DeletedFileCheck {
+    private cli;
+    private readonly hasFileSelection;
+    private keysToDelete;
+    constructor(cli: CliService, hasFileSelection?: boolean);
+    hasDeletedFiles(builder: InstallResourceBuilder, files: InstallResourceInterface[]): Promise<void>;
+    checkForDeletedLocalFiles(installResource: Install): Promise<void>;
+    private getFileByRemoteKey;
+}

package/dist/services/deploy/handler/install-resource-modifier/deleted-file-check.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const INSTALL_RESOURCE_FILE_KEYS = [
+    'custom',
+    'sw',
+    'loader',
+    'dynamicFetcher',
+    'dynamicFetcherConfig',
+    'documentHandler',
+    'documentHandlerConfig',
+    'customStyle',
+];
+class DeletedFileCheck {
+    cli;
+    hasFileSelection;
+    keysToDelete = [];
+    constructor(cli, hasFileSelection = false) {
+        this.cli = cli;
+        this.hasFileSelection = hasFileSelection;
+    }
+    async hasDeletedFiles(builder, files) {
+        if (this.hasFileSelection) {
+            return;
+        }
+        const installResource = builder.resource;
+        for (let key of INSTALL_RESOURCE_FILE_KEYS) {
+            const file = this.getFileByRemoteKey(key, files);
+            if (!file && installResource[key]?.length > 0) {
+                const deleteResource = await this.cli.confirm(`Do you want to delete ${key} on installResource?`);
+                if (deleteResource) {
+                    this.keysToDelete.push(key);
+                    builder.changed = true;
+                }
+            }
+        }
+    }
+    async checkForDeletedLocalFiles(installResource) {
+        this.keysToDelete.forEach(key => {
+            installResource[key] = null;
+        });
+    }
+    getFileByRemoteKey(key, files) {
+        const filteredFiles = files.filter((file) => {
+            return file.remoteKey === key;
+        });
+        if (filteredFiles.length > 0) {
+            return filteredFiles[0];
+        }
+    }
+}
+exports.default = DeletedFileCheck;

package/dist/services/deploy/handler/module-handler.d.ts

@@ -0,0 +1,14 @@
+import DeployHandlerInterface from "../interface/deploy-handler-interface";
+import ModuleFile from "../../integration-api/struct/module-file";
+import RuntimeModifier from "../interface/runtime-modifier";
+export default class ModuleHandler implements DeployHandlerInterface {
+    private readonly configApi;
+    private diffService;
+    private cli;
+    private modifiers;
+    constructor(configApi: any, diffService: any, cli: any, modifiers: RuntimeModifier[]);
+    canHandle(type: any): boolean;
+    handle(files: ModuleFile[]): Promise<any>;
+    upload(files: ModuleFile[]): Promise<any>;
+    private confirm;
+}

package/dist/services/deploy/handler/module-handler.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const module_file_1 = tslib_1.__importDefault(require("../../integration-api/struct/module-file"));
+class ModuleHandler {
+    configApi;
+    diffService;
+    cli;
+    modifiers;
+    constructor(configApi, diffService, cli, modifiers) {
+        this.configApi = configApi;
+        this.diffService = diffService;
+        this.cli = cli;
+        this.modifiers = modifiers;
+    }
+    canHandle(type) {
+        return type === module_file_1.default;
+    }
+    async handle(files) {
+        for (let iterator = 0; iterator < files.length; iterator++) {
+            let file = files[iterator];
+            let remote = await this.configApi.getModule(file.name);
+            for (let iterator = 0; iterator < this.modifiers.length; iterator++) {
+                let modifier = this.modifiers[iterator];
+                if (modifier.canModify(file)) {
+                    modifier.modify(file);
+                }
+            }
+            if (!remote) {
+                await this.confirm(file, true);
+                continue;
+            }
+            let { changedFile, diff } = await this.diffService.diffContent(file.name, file.getContent(), remote);
+            file.setContent(changedFile);
+            if (diff) {
+                this.cli.writeWarning(`skipped ${file.name} (identical with remote)`);
+                file.skipFile();
+                continue;
+            }
+            await this.confirm(file);
+        }
+    }
+    async upload(files) {
+        const filesToUpload = files.filter((file) => {
+            return !file.shouldSkipFile();
+        });
+        if (filesToUpload.length === 0) {
+            return;
+        }
+        this.cli.write('');
+        this.cli.write('Summary');
+        this.cli.writeBuffer();
+        if (await this.cli.confirm(`${filesToUpload.length} Module(s) will be uploaded now. Proceed?`)) {
+            for (let iterator = 0; iterator < files.length; iterator++) {
+                let file = files[iterator];
+                await this.configApi.setModule(file.getContent(), file.name);
+                for (let iterator = 0; iterator < this.modifiers.length; iterator++) {
+                    let modifier = this.modifiers[iterator];
+                    if (modifier.canModify(file)) {
+                        modifier.revert(file);
+                    }
+                }
+            }
+        }
+    }
+    async confirm(file, isNew = false) {
+        const confirm = await this.cli.confirm(`${isNew ? 'Create' : 'Update'} ${file.name}?`);
+        if (!confirm) {
+            file.skipFile();
+        }
+        else {
+            if (isNew) {
+                this.cli.write(`consider new ${file.name}`, true);
+            }
+            else {
+                this.cli.write(`consider changed ${file.name}`, true);
+            }
+        }
+    }
+}
+exports.default = ModuleHandler;

package/dist/services/deploy/handler/module-modifier/deployment-detection-modifier.d.ts

@@ -0,0 +1,9 @@
+import RuntimeModifier from "../../interface/runtime-modifier";
+import { ModuleInterface } from "../../../integration-api/integration-api-model";
+export default class DeploymentDetectionModifier implements RuntimeModifier {
+    private readonly slackToken;
+    constructor(slackToken?: string);
+    canModify(file: ModuleInterface): boolean;
+    modify(file: ModuleInterface): void;
+    revert(file: ModuleInterface): void;
+}

package/dist/services/deploy/handler/module-modifier/deployment-detection-modifier.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FILE = 'deploymentDetection';
+const SLACK_TOKEN_PLACEHOLDER = '<1Password deployment token>';
+class DeploymentDetectionModifier {
+    slackToken;
+    constructor(slackToken) {
+        this.slackToken = slackToken;
+    }
+    canModify(file) {
+        return file.name === FILE;
+    }
+    modify(file) {
+        if (this.slackToken) {
+            file.setContent(file.getContent().replace(SLACK_TOKEN_PLACEHOLDER, this.slackToken));
+        }
+    }
+    revert(file) {
+        if (this.slackToken) {
+            file.setContent(file.getContent().replace(this.slackToken, SLACK_TOKEN_PLACEHOLDER));
+        }
+    }
+}
+exports.default = DeploymentDetectionModifier;

package/dist/services/deploy/handler/server-config-handler.d.ts

@@ -0,0 +1,12 @@
+import DeployHandlerInterface from "../interface/deploy-handler-interface";
+import ServerConfigFile from "../../integration-api/struct/server-config-file";
+export default class ServerConfigHandler implements DeployHandlerInterface {
+    private readonly configApi;
+    private diffService;
+    private cli;
+    constructor(configApi: any, diffService: any, cli: any);
+    canHandle(type: any): boolean;
+    handle(files: ServerConfigFile[]): Promise<any>;
+    upload(files: ServerConfigFile[]): Promise<any>;
+    private confirm;
+}

package/dist/services/deploy/handler/server-config-handler.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const server_config_file_1 = tslib_1.__importDefault(require("../../integration-api/struct/server-config-file"));
+class ServerConfigHandler {
+    configApi;
+    diffService;
+    cli;
+    constructor(configApi, diffService, cli) {
+        this.configApi = configApi;
+        this.diffService = diffService;
+        this.cli = cli;
+    }
+    canHandle(type) {
+        return type === server_config_file_1.default;
+    }
+    async handle(files) {
+        let file = files[0];
+        let remote = await this.configApi.getServerConfig();
+        if (!remote) {
+            this.cli.writeError(`${file.name} could not be found on remote`);
+            await this.confirm(file, true);
+            return;
+        }
+        const remoteConfig = JSON.parse(remote);
+        file.config.revision.version = remoteConfig.revision.version;
+        const { changedFile, diff } = await this.diffService.diffContent(file.name, file.getContent(), remote);
+        file.setContent(changedFile);
+        if (diff) {
+            this.cli.writeWarning(`skipped ${file.name} (identical with remote)`);
+            file.skipFile();
+            return;
+        }
+        await this.confirm(file);
+    }
+    async upload(files) {
+        const file = files[0];
+        if (file.shouldSkipFile()) {
+            return;
+        }
+        this.cli.write('');
+        this.cli.write('Summary');
+        this.cli.writeBuffer();
+        if (await this.cli.confirm(`ServerConfig will be uploaded now. Proceed?`)) {
+            await this.configApi.setServerConfig(file.getContent(), file.config.revision.version);
+        }
+    }
+    async confirm(file, isNew = false) {
+        const confirm = await this.cli.confirm(`Deploy ${file.name}?`, true);
+        if (!confirm) {
+            file.skipFile();
+        }
+        else {
+            if (isNew) {
+                this.cli.writeSuccess(`${file.name} is new`, true);
+            }
+            else {
+                this.cli.writeSuccess(`${file.name} has changed`, true);
+            }
+        }
+    }
+}
+exports.default = ServerConfigHandler;

package/dist/services/deploy/interface/deploy-handler-interface.d.ts

@@ -0,0 +1,6 @@
+import { FileInterface } from "../../integration-api/integration-api-model";
+export default interface DeployHandlerInterface {
+    canHandle(type: any): boolean;
+    handle(files: FileInterface[]): Promise<any>;
+    upload(files: FileInterface[]): Promise<any>;
+}

package/dist/services/deploy/interface/deploy-handler-interface.js

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

package/dist/services/deploy/interface/install-configs.d.ts

@@ -0,0 +1,11 @@
+export default interface InstallConfigs<T> {
+    config: T;
+    custom: T;
+    sw: T;
+    loader: T;
+    dynamicFetcher: T;
+    dynamicFetcherConfig: T;
+    documentHandler: T;
+    documentHandlerConfig: T;
+    customStyle: T;
+}

package/dist/services/deploy/interface/install-configs.js

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

package/dist/services/deploy/interface/install-resource-processor-interface.d.ts

@@ -0,0 +1,5 @@
+import { InstallResourceInterface } from "../../integration-api/integration-api-model";
+export default interface InstallResourceProcessorInterface {
+    canProcess(file: InstallResourceInterface): boolean;
+    process(file: InstallResourceInterface): Promise<void>;
+}

package/dist/services/deploy/interface/install-resource-processor-interface.js

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

package/dist/services/deploy/interface/install.d.ts

@@ -0,0 +1,14 @@
+import InstallConfigs from './install-configs';
+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/services/deploy/interface/install.js

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

package/dist/services/deploy/interface/post-deploy-check-interface.d.ts

@@ -0,0 +1,3 @@
+export default interface PostDeployCheckInterface {
+    check(): Promise<void>;
+}

package/dist/services/deploy/interface/post-deploy-check-interface.js

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

package/dist/services/deploy/interface/runtime-modifier.d.ts

@@ -0,0 +1,6 @@
+import { FileInterface } from "../../integration-api/integration-api-model";
+export default interface RuntimeModifier {
+    canModify(file: FileInterface): boolean;
+    modify(file: FileInterface): void;
+    revert(file: FileInterface): void;
+}

package/dist/services/deploy/interface/runtime-modifier.js

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

package/dist/services/deploy/interface/validate-origins-response.d.ts

@@ -0,0 +1,4 @@
+export default interface ValidateOriginsResponse {
+    readonly apply: boolean;
+    readonly report: string[];
+}

package/dist/services/deploy/interface/validate-origins-response.js

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

package/dist/services/diff/diff-model.d.ts

@@ -0,0 +1,5 @@
+export declare class DiffContext {
+    readonly executablePath: string;
+    readonly executableTemplate: string;
+    constructor(executablePath: string, executableTemplate: string);
+}

package/dist/services/diff/diff-model.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffContext = void 0;
+class DiffContext {
+    executablePath;
+    executableTemplate;
+    constructor(executablePath, executableTemplate) {
+        this.executablePath = executablePath;
+        this.executableTemplate = executableTemplate;
+    }
+}
+exports.DiffContext = DiffContext;

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

@@ -0,0 +1,7 @@
+import { DiffContext, DiffService } from ".";
+export declare class DiffServiceFactory {
+    private context;
+    service?: DiffService;
+    constructor(context: DiffContext);
+    getService(): DiffService;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffServiceFactory = void 0;
+const cli_1 = require("../cli");
+const _1 = require(".");
+class DiffServiceFactory {
+    context;
+    service = undefined;
+    constructor(context) {
+        this.context = context;
+    }
+    getService() {
+        if (!(this.service instanceof _1.DiffService)) {
+            const cliService = new cli_1.CliServiceFactory().getService();
+            this.service = new _1.DiffService(cliService, this.context.executablePath, this.context.executableTemplate);
+        }
+        return this.service;
+    }
+}
+exports.DiffServiceFactory = DiffServiceFactory;

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

@@ -0,0 +1,34 @@
+import { CliService } from "../cli";
+export declare class DiffService {
+    private cli;
+    private diffExecutablePath?;
+    private diffExecutableTemplate?;
+    private tempPath;
+    constructor(cli: CliService, diffExecutablePath?: string, diffExecutableTemplate?: string);
+    diff(localPath: string, fileName: string, tmpContent: string): Promise<boolean>;
+    diffContent(fileName: string, localContent: string, remoteContent: string): Promise<{
+        changedFile: string;
+        diff: boolean;
+    }>;
+    /**
+     * Returns a temporal directory path.
+     */
+    getTemporalDirectoryPath(): Promise<string>;
+    writeContentToTemporalFile(tempFileName: string, content: string): Promise<string>;
+    /**
+     * @param localContent local file content.
+     * @param remoteContent remote content.
+     * @description removes whitespaces, newlines and compares both params content for equality.
+     * @return returns true if both localContent and remoteContent are equal otherwise returns false.
+     */
+    isContentEqual(localContent?: string, remoteContent?: string): boolean;
+    /**
+     *
+     * check if content of two files are equal
+     *
+     * @param localPath
+     * @param remotePath
+     * @param skipDiffExecution
+     */
+    executeDiff(localPath: string, remotePath: string, skipDiffExecution?: boolean): Promise<boolean>;
+}