@celonis/content-cli 0.11.0 → 0.11.1

package/api/action-flow-api.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../services/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.actionFlowApi = void 0;
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class ActionFlowApi {
+        exportRawAssets(packageId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.getFile(`/ems-automation/api/root/${packageId}/export/assets`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting Action Flow assets: ${e}`);
+                });
+            });
+        }
+        analyzeAssets(packageId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/ems-automation/api/root/${packageId}/export/assets/analyze`).catch(e => {
+                    throw new logger_1.FatalError(`Problem analyzing Action Flow assets: ${e}`);
+                });
+            });
+        }
+        importAssets(packageId, data, dryRun) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const params = {
+                    dryRun: dryRun,
+                };
+                return http_client_service_v2_1.httpClientV2.postFile(`/ems-automation/api/root/${packageId}/import/assets`, data, params).catch(e => {
+                    throw new logger_1.FatalError(`Problem importing Action Flow assets: ${e}`);
+                });
+            });
+        }
+    }
+    ActionFlowApi.INSTANCE = new ActionFlowApi();
+    exports.actionFlowApi = ActionFlowApi.INSTANCE;
+});

package/commands/action-flow.command.js

@@ -0,0 +1,41 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../services/action-flow/action-flow-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ActionFlowCommand = void 0;
+    const action_flow_service_1 = require("../services/action-flow/action-flow-service");
+    class ActionFlowCommand {
+        exportActionFlows(packageId, metadataFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield action_flow_service_1.actionFlowService.exportActionFlows(packageId, metadataFile);
+            });
+        }
+        analyzeActionFlows(packageId, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield action_flow_service_1.actionFlowService.analyzeActionFlows(packageId, outputToJsonFile);
+            });
+        }
+        importActionFlows(packageId, filePath, dryRun, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield action_flow_service_1.actionFlowService.importActionFlows(packageId, filePath, dryRun, outputToJsonFile);
+            });
+        }
+    }
+    exports.ActionFlowCommand = ActionFlowCommand;
+});

package/content-cli-analyze.js

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./util/context-initializer", "./util/logger", "./commands/action-flow.command", "commander"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const context_initializer_1 = require("./util/context-initializer");
+    const logger_1 = require("./util/logger");
+    const action_flow_command_1 = require("./commands/action-flow.command");
+    const commander = require("commander");
+    class Analyze {
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Analyze Action Flows dependencies for a certain package")
+                .option("-p, --profile <profile>", "Profile which you want to use to analyze Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package from which you want to export Action Flows")
+                .option("-o, --outputToJsonFile", "Output the analyze result in a JSON file")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().analyzeActionFlows(cmd.packageId, cmd.outputToJsonFile);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    const loadCommands = () => {
+        getAllCommands();
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadCommands, loadCommands)
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+    function getAllCommands() {
+        Analyze.actionFlows(commander);
+        commander.parse(process.argv);
+    }
+});

package/content-cli-export.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "commander", "./commands/package.command", "./util/logger", "./commands/data-pool.command", "./util/context-initializer"], factory);
+        define(["require", "exports", "commander", "./commands/package.command", "./util/logger", "./commands/data-pool.command", "./util/context-initializer", "./commands/action-flow.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const logger_1 = require("./util/logger");
     const data_pool_command_1 = require("./commands/data-pool.command");
     const context_initializer_1 = require("./util/context-initializer");
+    const action_flow_command_1 = require("./commands/action-flow.command");
     class Export {
         static packages(program) {
             program
@@ -53,6 +54,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Command to export all Action Flows in a package with their objects and dependencies")
+                .option("-p, --profile <profile>", "Profile which you want to use to export Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package from which you want to export Action Flows")
+                .option("-f, --file <file>", "Action flows metadata file (relative path)")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().exportActionFlows(cmd.packageId, cmd.file);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.Export = Export;
     const loadCommands = () => {
@@ -70,6 +84,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     function getAllCommands() {
         Export.packages(commander);
         Export.dataPool(commander);
+        Export.actionFlows(commander);
         commander.parse(process.argv);
     }
 });

package/content-cli-import.js

@@ -13,7 +13,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "commander", "./commands/package.command", "./commands/data-pool.command", "./util/context-initializer", "./util/logger"], factory);
+        define(["require", "exports", "commander", "./commands/package.command", "./commands/data-pool.command", "./util/context-initializer", "./util/logger", "./commands/action-flow.command"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const data_pool_command_1 = require("./commands/data-pool.command");
     const context_initializer_1 = require("./util/context-initializer");
     const logger_1 = require("./util/logger");
+    const action_flow_command_1 = require("./commands/action-flow.command");
     class Import {
         static packages(program) {
             program
@@ -54,6 +55,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static actionFlows(program) {
+            program
+                .command("action-flows")
+                .description("Command to import all Action Flows in a package with their objects and dependencies")
+                .option("-p, --profile <profile>", "Profile which you want to use to import Action Flows")
+                .requiredOption("--packageId <packageId>", "ID of the package to which you want to export Action Flows")
+                .requiredOption("-f, --file <file>", "Exported Action Flows file (relative path)")
+                .requiredOption("-d, --dryRun <dryRun>", "Execute the import on dry run mode")
+                .option("-o, --outputToJsonFile", "Output the import result in a JSON file")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new action_flow_command_1.ActionFlowCommand().importActionFlows(cmd.packageId, cmd.file, cmd.dryRun, cmd.outputToJsonFile);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.Import = Import;
     const loadCommands = () => {
@@ -71,6 +87,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     function getAllCommands() {
         Import.packages(commander);
         Import.dataPools(commander);
+        Import.actionFlows(commander);
         commander.parse(process.argv);
     }
 });

package/content-cli.js

@@ -22,13 +22,14 @@
     program.command("profile", "Commands related to profiles.");
     program.command("pull", "Commands to pull content.");
     program.command("export", "Commands to export content.");
-    program.command("import", "Commands to export content.");
+    program.command("import", "Commands to import content.");
     program.command("push", "Commands to push content.");
     program.command("update", "Commands to update content.");
     program.command("list", "Commands to list content.").alias("ls");
     program.command("get", "Commands to get configuration properties.");
     program.command("set", "Commands to set configuration properties.");
     program.command("config", "Commands related to config management.");
+    program.command("analyze", "Commands to analyze assets dependencies.");
     program.version(version_1.VersionUtils.getCurrentCliVersion());
     program.parse(process.argv);
     if (!process.argv.slice(2).length) {

package/lib/api/action-flow-api.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as FormData from "form-data";
+declare class ActionFlowApi {
+    static readonly INSTANCE: ActionFlowApi;
+    exportRawAssets(packageId: string): Promise<Buffer>;
+    analyzeAssets(packageId: string): Promise<any>;
+    importAssets(packageId: string, data: FormData, dryRun: boolean): Promise<any>;
+}
+export declare const actionFlowApi: ActionFlowApi;
+export {};

package/lib/commands/action-flow.command.d.ts

@@ -0,0 +1,5 @@
+export declare class ActionFlowCommand {
+    exportActionFlows(packageId: string, metadataFile: string): Promise<void>;
+    analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
+    importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;
+}

package/lib/content-cli-analyze.d.ts

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

package/lib/content-cli-export.d.ts

@@ -2,4 +2,5 @@ import { CommanderStatic } from "commander";
 export declare class Export {
     static packages(program: CommanderStatic): CommanderStatic;
     static dataPool(program: CommanderStatic): CommanderStatic;
+    static actionFlows(program: CommanderStatic): CommanderStatic;
 }

package/lib/content-cli-import.d.ts

@@ -2,4 +2,5 @@ import { CommanderStatic } from "commander";
 export declare class Import {
     static packages(program: CommanderStatic): CommanderStatic;
     static dataPools(program: CommanderStatic): CommanderStatic;
+    static actionFlows(program: CommanderStatic): CommanderStatic;
 }

package/lib/services/action-flow/action-flow-service.d.ts

@@ -0,0 +1,11 @@
+declare class ActionFlowService {
+    static readonly METADATA_FILE_NAME = "metadata.json";
+    exportActionFlows(packageId: string, metadataFilePath: string): Promise<void>;
+    analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
+    importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;
+    private createBodyForImport;
+    private attachMetadataFile;
+}
+export declare const actionFlowService: ActionFlowService;
+export declare const metadataFileName = "metadata.json";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "CLI Tool to help manage content in Celonis EMS",
   "main": "content-cli.js",
   "bin": {

package/services/action-flow/action-flow-service.js

@@ -0,0 +1,90 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../util/logger", "uuid", "../file-service", "../../api/action-flow-api", "adm-zip", "form-data", "fs"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.metadataFileName = exports.actionFlowService = void 0;
+    const logger_1 = require("../../util/logger");
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../file-service");
+    const action_flow_api_1 = require("../../api/action-flow-api");
+    const AdmZip = require("adm-zip");
+    const FormData = require("form-data");
+    const fs = require("fs");
+    class ActionFlowService {
+        exportActionFlows(packageId, metadataFilePath) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const exportedActionFlowsData = yield action_flow_api_1.actionFlowApi.exportRawAssets(packageId);
+                const tmpZip = new AdmZip(exportedActionFlowsData);
+                const zip = new AdmZip();
+                tmpZip.getEntries().forEach(entry => {
+                    zip.addFile(entry.entryName, entry.getData());
+                });
+                if (metadataFilePath) {
+                    this.attachMetadataFile(metadataFilePath, zip);
+                }
+                const fileName = "action-flows_export_" + (0, uuid_1.v4)() + ".zip";
+                zip.writeZip(fileName);
+                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + fileName);
+            });
+        }
+        analyzeActionFlows(packageId, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const actionFlowsMetadata = yield action_flow_api_1.actionFlowApi.analyzeAssets(packageId);
+                const actionFlowsMetadataString = JSON.stringify(actionFlowsMetadata, null, 4);
+                if (outputToJsonFile) {
+                    const metadataFileName = "action-flows_metadata_" + (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(actionFlowsMetadataString, metadataFileName);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + metadataFileName);
+                }
+                else {
+                    logger_1.logger.info("Action flows analyze metadata: \n" + actionFlowsMetadataString);
+                }
+            });
+        }
+        importActionFlows(packageId, filePath, dryRun, outputToJsonFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const actionFlowsZip = this.createBodyForImport(filePath);
+                const eventLog = yield action_flow_api_1.actionFlowApi.importAssets(packageId, actionFlowsZip, dryRun);
+                const eventLogString = JSON.stringify(eventLog, null, 4);
+                if (outputToJsonFile) {
+                    const eventLogFileName = "action-flows_import_event_log_" + (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(eventLogString, eventLogFileName);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + eventLogFileName);
+                }
+                else {
+                    logger_1.logger.info("Action flows import event log: \n" + eventLogString);
+                }
+            });
+        }
+        createBodyForImport(fileName) {
+            fileName = fileName + (fileName.endsWith(".zip") ? "" : ".zip");
+            const formData = new FormData();
+            formData.append("file", fs.createReadStream(fileName, { encoding: null }), { filename: fileName });
+            return formData;
+        }
+        attachMetadataFile(fileName, zip) {
+            fileName = fileName + (fileName.endsWith(".json") ? "" : ".json");
+            const metadata = file_service_1.fileService.readFile(fileName);
+            zip.addFile(ActionFlowService.METADATA_FILE_NAME, Buffer.from(metadata));
+        }
+    }
+    ActionFlowService.METADATA_FILE_NAME = "metadata.json";
+    exports.actionFlowService = new ActionFlowService();
+    exports.metadataFileName = ActionFlowService.METADATA_FILE_NAME;
+});