@speedkit/cli 2.4.1

package/dist/services/customer-config/templates/downtimeDetection.js.hbs

@@ -0,0 +1,110 @@
+const fetch = require('node-fetch');
+const { SLACK_WEB_HOOK_URL, APP_API_TOKEN } = require('./parameters');
+
+/**
+ * Run this as a CRON job every 5 minutes.
+ *
+ * NOTE: Do not forget to change page specific parts for your customer!
+ * NOTE: Do not forget to create the parameters module with slack URL and admin API token
+ */
+async function call(db, data, req) {
+  const landingPage = 'https://{{production.host}}/';
+  const maintenancePageRegex = /maintenance\.{{appName}}/g;
+
+  const landingPageDown = await isLandingPageDown(landingPage, maintenancePageRegex);
+
+  if (!landingPageDown) {
+    return { status: 'success' };
+  }
+
+  loginAdmin(db);
+
+  const deactivated = await deactiveSpeedKit(db);
+  if (deactivated) {
+    notifyBaqend(landingPage);
+  }
+
+  return { status: 'downtime' };
+}
+
+/**
+ * Logs in an admin.
+ *
+ * @param db The database to perform the login with
+ */
+async function loginAdmin(db) {
+  await db.loginWithToken(APP_API_TOKEN);
+}
+
+function notifyBaqend(landingPage) {
+  const body = JSON.stringify({
+    "username": 'Downtime Detection',
+    "text": `Speed Kit was deactivated due to downtime of ${landingPage}`,
+  });
+  return fetch(SLACK_WEB_HOOK_URL, { method: 'POST', body })
+}
+
+/**
+ * Deactivates Speed Kit via the config.
+ */
+async function deactiveSpeedKit(db) {
+  const config = (await db.send(new db.message.GetOrestesConfig())).entity;
+
+  if (!config.speedKit.enabled) {
+    // Speed Kit already deactivated
+    return false;
+  }
+
+  // Deactivate Speed Kit
+  config.speedKit.enabled = false;
+  const configUpdate = new db.message.UpdateOrestesConfig(config).ifMatch(config.revision.version);
+  await db.send(configUpdate);
+  return true;
+}
+
+/**
+ * Returns whether the landing page is not reachable.
+ *
+ * @param landingPage The page to test.
+ * @param maintenancePageRegex The page to identify redirects to maintenance page.
+ * @param retry The number of already failed tries to load the page.
+ * @returns `true` if the landing page is not reachable, `false` otherwise.
+ */
+async function isLandingPageDown(landingPage, maintenancePageRegex, retry = 0) {
+  const res = await fetch(landingPage);
+
+  // Valid response
+  if (res.status < 300) {
+    return false;
+  }
+
+  // Redirect
+  if (res.status < 400) {
+    return isMaintenanceRedirect(res, maintenancePageRegex);
+  }
+
+  // Error
+  if (retry > 3) {
+    return true;
+  }
+
+  // Retry after error
+  await sleep(10000);
+  return isLandingPageDown(retry + 1);
+}
+
+/**
+ * Returns whether the response redirects to the maintenance page.
+ *
+ * @param maintenancePageRegex The page to identify redirects to maintenance page.
+ */
+async function isMaintenanceRedirect(res, maintenancePageRegex) {
+  const location = res.headers.get('Location') || '';
+  return maintenancePageRegex.test(location);
+}
+
+async function sleep(milliseconds) {
+  return new Promise(res => setTimeout(res, milliseconds));
+}
+
+exports.call = call;

package/dist/services/deploy/builder/install-resource-builder.d.ts

@@ -0,0 +1,14 @@
+import Install from "../interface/install";
+import ConfigApi from "../../config-api/config-api-service";
+export default class InstallResourceBuilder {
+    changed: boolean;
+    resource: Install;
+    configApi: ConfigApi;
+    constructor(configApi: ConfigApi);
+    init(configName: string): Promise<Install>;
+    merge(installParams: Install): void;
+    updateFromRemote(remoteParams: Install): Install;
+    hasChanges(): boolean;
+    getInstallResource(): Install;
+    private deepMerge;
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deepmerge_1 = tslib_1.__importDefault(require("deepmerge"));
+class InstallResourceBuilder {
+    changed = false;
+    resource;
+    configApi;
+    constructor(configApi) {
+        this.configApi = configApi;
+    }
+    async init(configName) {
+        if (this.resource !== undefined) {
+            return this.resource;
+        }
+        this.resource = await this.configApi.getActiveInstall(configName) || {
+            domain: configName,
+            origins: [],
+            configVersion: 1
+        };
+        return this.resource;
+    }
+    merge(installParams) {
+        this.changed = true;
+        this.resource = this.deepMerge(this.resource, installParams);
+    }
+    updateFromRemote(remoteParams) {
+        this.changed = true;
+        this.resource = this.deepMerge(remoteParams, this.resource);
+        this.resource.id = remoteParams.id;
+        this.resource.version = remoteParams.version;
+        this.resource.configVersion = remoteParams.configVersion;
+        this.resource.status = 'inactive';
+        return this.resource;
+    }
+    hasChanges() {
+        return this.changed;
+    }
+    getInstallResource() {
+        return this.resource;
+    }
+    deepMerge(object1, object2) {
+        return (0, deepmerge_1.default)(object1, object2, {
+            arrayMerge: (destinationArray, sourceArray, options) => sourceArray
+        });
+    }
+}
+exports.default = InstallResourceBuilder;

package/dist/services/deploy/checks/post-deploy/revalidated-module-check.d.ts

@@ -0,0 +1,11 @@
+import { CliService } from "../../../cli";
+import ConfigApiService from "../../../config-api/config-api-service";
+import PostDeployCheckInterface from "../../interface/post-deploy-check-interface";
+export default class RevalidatedModuleCheck implements PostDeployCheckInterface {
+    private readonly configApi;
+    private cli;
+    private readonly app;
+    constructor(configApi: ConfigApiService, cli: CliService, app: string);
+    check(): Promise<void>;
+    private showMessage;
+}

package/dist/services/deploy/checks/post-deploy/revalidated-module-check.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const REVALIDATED_MODULE_NAME = 'speedKit.Revalidated';
+class RevalidatedModuleCheck {
+    configApi;
+    cli;
+    app;
+    constructor(configApi, cli, app) {
+        this.configApi = configApi;
+        this.cli = cli;
+        this.app = app;
+    }
+    async check() {
+        try {
+            const module = await this.configApi.getModule(REVALIDATED_MODULE_NAME);
+            if (!module) {
+                this.showMessage();
+            }
+        }
+        catch (error) {
+            this.showMessage();
+        }
+    }
+    showMessage() {
+        this.cli.writeError(`it seems ${REVALIDATED_MODULE_NAME} does not exists in the app ${this.app}`);
+        this.cli.write('please execute:');
+        this.cli.code(`sk generate-pop-config ${this.app}`);
+    }
+}
+exports.default = RevalidatedModuleCheck;

package/dist/services/deploy/checks/post-deploy/save-files-check.d.ts

@@ -0,0 +1,9 @@
+import { CliService } from "../../../cli";
+import PostDeployCheckInterface from "../../interface/post-deploy-check-interface";
+import { FileListInterface } from "../../../integration-api/integration-api-model";
+export default class SaveFilesCheck implements PostDeployCheckInterface {
+    private fileList;
+    private readonly cli;
+    constructor(fileList: FileListInterface, cli: CliService);
+    check(): Promise<void>;
+}

package/dist/services/deploy/checks/post-deploy/save-files-check.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SaveFilesCheck {
+    fileList;
+    cli;
+    constructor(fileList, cli) {
+        this.fileList = fileList;
+        this.cli = cli;
+    }
+    async check() {
+        const fileList = this.fileList.files.filter((file) => {
+            return file.isUpdated();
+        });
+        if (fileList.length < 1) {
+            return;
+        }
+        if (await this.cli.confirm(`Changes to localFiles will be saved now. Proceed?`)) {
+            fileList.forEach(((file) => {
+                file.updateIfChanged();
+                this.cli.writeSuccess(`${file.name} saved`);
+            }));
+        }
+    }
+}
+exports.default = SaveFilesCheck;

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

@@ -0,0 +1,12 @@
+export default class DeployContext {
+    readonly customerPath: string;
+    readonly configName: string;
+    readonly slackToken?: string;
+    readonly artifacts?: string[];
+    readonly dryRun?: boolean;
+    runTime: {
+        app: string;
+    };
+    constructor(customerPath: string, configName?: string, slackToken?: string, artifacts?: string, dryRun?: boolean);
+    hasArtifacts(): boolean;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const dotenv = tslib_1.__importStar(require("dotenv"));
+dotenv.config();
+const DEFAULT_CONFIG_NAME = 'production';
+const ARTIFACTS_SEPARATOR = ',';
+class DeployContext {
+    customerPath;
+    configName;
+    slackToken;
+    artifacts;
+    dryRun = false;
+    runTime = { app: undefined };
+    constructor(customerPath, configName = DEFAULT_CONFIG_NAME, slackToken, artifacts, dryRun) {
+        this.customerPath = customerPath;
+        this.configName = configName;
+        this.slackToken = slackToken || process.env.SLACK_TOKEN || undefined;
+        this.artifacts = artifacts ? artifacts.split(ARTIFACTS_SEPARATOR) : [];
+        this.dryRun = dryRun;
+    }
+    hasArtifacts() {
+        return this.artifacts?.length > 0;
+    }
+}
+exports.default = DeployContext;

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

@@ -0,0 +1,15 @@
+import DeployService from "./deploy-service";
+import DeployContext from "./context/deploy-context";
+import AbstractAsyncErrorHandlingFactory from "../error-handling/abstract/abstract-async-error-handling-factory";
+import { UserCliConfig } from "../../helpers/cli-config";
+export default class DeployServiceFactory extends AbstractAsyncErrorHandlingFactory {
+    private context;
+    private cliConfig;
+    private service?;
+    constructor(context: DeployContext, cliConfig: UserCliConfig);
+    _buildService(): Promise<DeployService>;
+    private build;
+    private getConfigApi;
+    private getIntegrationFiles;
+    private getPostDeployChecks;
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deploy_service_1 = tslib_1.__importDefault(require("./deploy-service"));
+const integration_api_context_1 = tslib_1.__importDefault(require("../integration-api/context/integration-api-context"));
+const integration_api_service_factory_1 = tslib_1.__importDefault(require("../integration-api/factory/integration-api-service-factory"));
+const config_api_service_factory_1 = tslib_1.__importDefault(require("../config-api/factory/config-api-service-factory"));
+const config_api_context_1 = tslib_1.__importDefault(require("../config-api/context/config-api-context"));
+const install_resource_handler_1 = tslib_1.__importDefault(require("./handler/install-resource-handler"));
+const customer_config_handler_1 = tslib_1.__importDefault(require("./handler/customer-config-handler"));
+const diff_1 = require("../diff");
+const cli_1 = require("../cli");
+const install_resource_builder_1 = tslib_1.__importDefault(require("./builder/install-resource-builder"));
+const module_handler_1 = tslib_1.__importDefault(require("./handler/module-handler"));
+const server_config_handler_1 = tslib_1.__importDefault(require("./handler/server-config-handler"));
+const deployment_detection_modifier_1 = tslib_1.__importDefault(require("./handler/module-modifier/deployment-detection-modifier"));
+const abstract_async_error_handling_factory_1 = tslib_1.__importDefault(require("../error-handling/abstract/abstract-async-error-handling-factory"));
+const save_files_check_1 = tslib_1.__importDefault(require("./checks/post-deploy/save-files-check"));
+const revalidated_module_check_1 = tslib_1.__importDefault(require("./checks/post-deploy/revalidated-module-check"));
+const deleted_file_check_1 = tslib_1.__importDefault(require("./handler/install-resource-modifier/deleted-file-check"));
+class DeployServiceFactory extends abstract_async_error_handling_factory_1.default {
+    context;
+    cliConfig;
+    service = undefined;
+    constructor(context, cliConfig) {
+        super();
+        this.context = context;
+        this.cliConfig = cliConfig;
+    }
+    async _buildService() {
+        if (!(this.service instanceof deploy_service_1.default)) {
+            await this.build();
+        }
+        return this.service;
+    }
+    async build() {
+        const files = await this.getIntegrationFiles();
+        const customer = files.getCustomerConfig().config;
+        const configName = customer.name || this.context.configName;
+        const configApi = this.getConfigApi(customer.app);
+        const diffService = new diff_1.DiffServiceFactory(new diff_1.DiffContext(this.cliConfig.diffExec, this.cliConfig.diffExecTemplate)).getService();
+        const cliService = new cli_1.CliServiceFactory().getService();
+        const installResourceBuilder = new install_resource_builder_1.default(configApi);
+        const deletedFilesChecker = new deleted_file_check_1.default(cliService, this.context.hasArtifacts());
+        this.service = new deploy_service_1.default(files, [
+            new customer_config_handler_1.default(customer, configApi, configName, diffService, cliService, installResourceBuilder),
+            new install_resource_handler_1.default(customer, configApi, configName, diffService, cliService, installResourceBuilder, deletedFilesChecker),
+            new module_handler_1.default(configApi, diffService, cliService, [new deployment_detection_modifier_1.default(this.context.slackToken)]),
+            new server_config_handler_1.default(configApi, diffService, cliService)
+        ], cliService, this.getPostDeployChecks(files, cliService, configApi, customer.app), this.context.dryRun);
+    }
+    getConfigApi(app) {
+        const configApiContext = new config_api_context_1.default(app);
+        return new config_api_service_factory_1.default(configApiContext).getService();
+    }
+    async getIntegrationFiles() {
+        const integrationApiContext = new integration_api_context_1.default(this.context.customerPath, this.context.configName, this.context.artifacts);
+        const integrationApi = new integration_api_service_factory_1.default(integrationApiContext, this.cliConfig).buildService();
+        return await integrationApi.run();
+    }
+    getPostDeployChecks(files, cliService, configApi, app) {
+        return [
+            new save_files_check_1.default(files, cliService),
+            new revalidated_module_check_1.default(configApi, cliService, app),
+        ];
+    }
+}
+exports.default = DeployServiceFactory;

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

@@ -0,0 +1,17 @@
+import DeployHandlerInterface from "./interface/deploy-handler-interface";
+import { CliService } from "../cli";
+import PostDeployCheckInterface from "./interface/post-deploy-check-interface";
+import AbstractAsyncErrorHandlingService from "../error-handling/abstract/abstract-async-error-handling-service";
+import { FileListInterface } from "../integration-api/integration-api-model";
+export default class DeployService extends AbstractAsyncErrorHandlingService {
+    private readonly fileList;
+    private readonly deployHandler;
+    private readonly cli;
+    private readonly dryRun;
+    private readonly postDeployChecks;
+    constructor(fileList: FileListInterface, deployHandler: DeployHandlerInterface[], cli: CliService, postDeployChecks: PostDeployCheckInterface[], dryRun: boolean);
+    _run(): Promise<void>;
+    private handleType;
+    private uploadType;
+    private runPostDeployChecks;
+}

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const abstract_async_error_handling_service_1 = tslib_1.__importDefault(require("../error-handling/abstract/abstract-async-error-handling-service"));
+class DeployService extends abstract_async_error_handling_service_1.default {
+    fileList;
+    deployHandler;
+    cli;
+    dryRun = false;
+    postDeployChecks;
+    constructor(fileList, deployHandler, cli, postDeployChecks, dryRun) {
+        super();
+        this.fileList = fileList;
+        this.deployHandler = deployHandler;
+        this.cli = cli;
+        this.postDeployChecks = postDeployChecks;
+        this.dryRun = dryRun;
+    }
+    async _run() {
+        const types = this.fileList.getTypes();
+        this.cli.spacer();
+        this.cli.write(`App: "${this.fileList.getCustomerConfig().config.app}", Install: "${this.fileList.getCustomerConfig().config.name}"`);
+        this.cli.write('Preparing deployment...');
+        this.cli.spacer();
+        for (let iterator = 0; iterator < types.length; iterator++) {
+            let type = types[iterator];
+            await this.handleType(type);
+        }
+        if (this.dryRun) {
+            this.cli.comment('dryRunFlag -d is set, skip upload');
+        }
+        else {
+            for (let iterator = 0; iterator < types.length; iterator++) {
+                let type = types[iterator];
+                await this.uploadType(type);
+            }
+        }
+        await this.runPostDeployChecks();
+    }
+    async handleType(type) {
+        for (let iterator = 0; iterator < this.deployHandler.length; iterator++) {
+            let handler = this.deployHandler[iterator];
+            if (handler.canHandle(type)) {
+                await handler.handle(this.fileList.getByType(type));
+            }
+        }
+    }
+    async uploadType(type) {
+        for (let iterator = 0; iterator < this.deployHandler.length; iterator++) {
+            let handler = this.deployHandler[iterator];
+            if (handler.canHandle(type)) {
+                await handler.upload(this.fileList.getByType(type));
+            }
+        }
+    }
+    async runPostDeployChecks() {
+        for (let iterator = 0; iterator < this.postDeployChecks.length; iterator++) {
+            let check = this.postDeployChecks[iterator];
+            await check.check();
+        }
+    }
+}
+exports.default = DeployService;

package/dist/services/deploy/error/create-find-temp-directory-error.d.ts

@@ -0,0 +1,4 @@
+import DeployAppError from "./deploy-app-error";
+export default class CreateFindTempDirectoryError extends DeployAppError {
+    constructor();
+}

package/dist/services/deploy/error/create-find-temp-directory-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deploy_app_error_1 = tslib_1.__importDefault(require("./deploy-app-error"));
+class CreateFindTempDirectoryError extends deploy_app_error_1.default {
+    constructor() {
+        super(`No temporary Directory found and unable to create a new temporary Directory`);
+    }
+}
+exports.default = CreateFindTempDirectoryError;

package/dist/services/deploy/error/deploy-app-error.d.ts

@@ -0,0 +1,2 @@
+export default class DeployAppError extends Error {
+}

package/dist/services/deploy/error/deploy-app-error.js

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

package/dist/services/deploy/error/no-active-installation-error.d.ts

@@ -0,0 +1,4 @@
+import DeployAppError from "./deploy-app-error";
+export default class NoActiveInstallationError extends DeployAppError {
+    constructor(configName: any);
+}

package/dist/services/deploy/error/no-active-installation-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const deploy_app_error_1 = tslib_1.__importDefault(require("./deploy-app-error"));
+class NoActiveInstallationError extends deploy_app_error_1.default {
+    constructor(configName) {
+        super(`No active installation for the config ${configName} was found. A new one will be created.`);
+    }
+}
+exports.default = NoActiveInstallationError;

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

@@ -0,0 +1,21 @@
+import DeployHandlerInterface from "../interface/deploy-handler-interface";
+import CustomerConfigFile from "../../integration-api/struct/customer-config-file";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import ConfigApi from "../../config-api/config-api-service";
+import { DiffService } from "../../diff";
+import { CliService } from "../../cli";
+import InstallResourceBuilder from "../builder/install-resource-builder";
+export default class CustomerConfigHandler implements DeployHandlerInterface {
+    private readonly customer;
+    private readonly configApi;
+    private readonly configName;
+    private diffService;
+    private cli;
+    private builder;
+    constructor(customer: CustomerConfig, configApi: ConfigApi, configName: string, diffService: DiffService, cli: CliService, builder: InstallResourceBuilder);
+    canHandle(type: any): boolean;
+    handle(files: CustomerConfigFile[]): Promise<any>;
+    upload(files: CustomerConfigFile[]): Promise<any>;
+    private handleMissingRemoteInstallResource;
+    private prepareOriginDiff;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const customer_config_file_1 = tslib_1.__importDefault(require("../../integration-api/struct/customer-config-file"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class CustomerConfigHandler {
+    customer;
+    configApi;
+    configName;
+    diffService;
+    cli;
+    builder;
+    constructor(customer, configApi, configName, diffService, cli, builder) {
+        this.customer = customer;
+        this.configApi = configApi;
+        this.configName = configName;
+        this.diffService = diffService;
+        this.cli = cli;
+        this.builder = builder;
+    }
+    canHandle(type) {
+        return type === customer_config_file_1.default;
+    }
+    async handle(files) {
+        const installResource = await this.configApi.getActiveInstall(this.configName);
+        const file = files[0];
+        const config = file.config;
+        if (!installResource) {
+            await this.handleMissingRemoteInstallResource(config);
+            this.cli.write('with origins:', true);
+            this.cli.code(JSON.stringify(config.origins), true);
+            return;
+        }
+        if (!installResource.origins || installResource.origins.length < 1) {
+            this.cli.write('with origins:', true);
+            this.cli.code(JSON.stringify(config.origins), true);
+            return;
+        }
+        const isEqual = this.diffService.isContentEqual(JSON.stringify(config.origins.sort()), JSON.stringify(installResource.origins.sort(), null, `\t`));
+        if (isEqual) {
+            this.cli.writeWarning('skipped origins (identical with remote)');
+            file.skipFile();
+            return;
+        }
+        // todo: only diff origins update local file if tmp file was changed
+        // todo: add changedThrowable, let the handler catch and decide what to do with it
+        const { changedFile, diff } = await this.diffService.diffContent(file.name, file.getContent(), this.prepareOriginDiff(installResource));
+        file.setContent(changedFile);
+        if (!(await this.cli.confirm('Update origins?', true))) {
+            file.skipFile();
+            return;
+        }
+        this.cli.write('will update origins to:', true);
+        this.cli.code(JSON.stringify(config.origins), true);
+        return;
+    }
+    async upload(files) {
+        const file = files[0];
+        let installResource = await this.builder.init(this.configName);
+        if (file.shouldSkipFile()) { // if installResource already exists its possible to skip the origin update
+            return;
+        }
+        installResource.origins = file.config.origins;
+        this.builder.merge(installResource);
+    }
+    async handleMissingRemoteInstallResource(config) {
+        const configName = config?.name || this.configName;
+        const { app: appName } = this.customer;
+        this.cli.spacer();
+        this.cli.writeWarning(`No ${chalk_1.default.underline('active')} remote config named ${chalk_1.default.bold(configName)} found in app ${chalk_1.default.bold(appName)}`);
+        this.cli.spacer();
+        if (await this.cli.confirm('Continue creating a new config?')) {
+            this.cli.write(`New configuration named ${chalk_1.default.bold(configName)} will be created in app ${chalk_1.default.bold(appName)}`, true);
+        }
+        else {
+            this.cli.exit();
+        }
+    }
+    prepareOriginDiff(installResource) {
+        let remoteConfig = {};
+        remoteConfig[this.configName] = { origins: installResource.origins };
+        return JSON.stringify(remoteConfig, null, 4);
+    }
+}
+exports.default = CustomerConfigHandler;

package/dist/services/deploy/handler/install-resource-handler.d.ts

@@ -0,0 +1,25 @@
+import DeployHandlerInterface from "../interface/deploy-handler-interface";
+import CustomerConfig from "../../integration-api/struct/customer-config";
+import ConfigApi from "../../config-api/config-api-service";
+import { DiffService } from "../../diff";
+import { CliService } from "../../cli";
+import InstallResourceBuilder from "../builder/install-resource-builder";
+import DeletedFileCheck from "./install-resource-modifier/deleted-file-check";
+import { InstallResourceInterface } from "../../integration-api/integration-api-model";
+export default class InstallResourceHandler implements DeployHandlerInterface {
+    private readonly customer;
+    private readonly configApi;
+    private readonly configName;
+    private diffService;
+    private cli;
+    private builder;
+    private deletedFilesChecker;
+    constructor(customer: CustomerConfig, configApi: ConfigApi, configName: string, diffService: DiffService, cli: CliService, builder: InstallResourceBuilder, deletedFilesChecker: DeletedFileCheck);
+    canHandle(type: any): boolean;
+    handle(files: InstallResourceInterface[]): Promise<void>;
+    upload(files: InstallResourceInterface[]): Promise<any>;
+    private processFile;
+    private confirm;
+    private getInstallResource;
+    private prepareRemoteInstallResource;
+}