@celonis/content-cli 1.2.3 → 1.3.0

package/commands/configuration-management/api/node-api.js

@@ -0,0 +1,70 @@
+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", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class NodeApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        findStagingNodeByKey(packageKey, nodeKey, withConfiguration) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("withConfiguration", withConfiguration.toString());
+                return this.httpClient()
+                    .get(`/pacman/api/core/staging/packages/${packageKey}/nodes/${nodeKey}?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem finding node ${nodeKey} in package ${packageKey}: ${e}`);
+                });
+            });
+        }
+        findVersionedNodeByKey(packageKey, nodeKey, version, withConfiguration) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("version", version);
+                queryParams.set("withConfiguration", withConfiguration.toString());
+                return this.httpClient()
+                    .get(`/pacman/api/core/packages/${packageKey}/nodes/${nodeKey}?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem finding node ${nodeKey} in package ${packageKey} for version ${version}: ${e}`);
+                });
+            });
+        }
+        findVersionedNodesByPackage(packageKey, version, withConfiguration, limit, offset) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("version", version);
+                queryParams.set("withConfiguration", withConfiguration.toString());
+                if (limit) {
+                    queryParams.set("limit", limit.toString());
+                }
+                if (offset) {
+                    queryParams.set("offset", offset.toString());
+                }
+                return this.httpClient()
+                    .get(`/pacman/api/core/packages/${packageKey}/nodes?${queryParams.toString()}`)
+                    .catch(e => {
+                    throw new logger_1.FatalError(`Problem fetching nodes from package ${packageKey} for version ${version}: ${e}`);
+                });
+            });
+        }
+    }
+    exports.NodeApi = NodeApi;
+});

package/commands/configuration-management/api/node-dependency-api.js

@@ -0,0 +1,40 @@
+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", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeDependencyApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class NodeDependencyApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        findAll(packageKey, nodeKey, version) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("version", version);
+                return this.httpClient()
+                    .get(`/pacman/api/core/packages/${packageKey}/nodes/${nodeKey}/dependencies?${queryParams.toString()}`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem finding dependencies for node ${nodeKey} in package ${packageKey} for version ${version}: ${e}`);
+                });
+            });
+        }
+    }
+    exports.NodeDependencyApi = NodeDependencyApi;
+});

package/commands/configuration-management/api/node-diff-api.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", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeDiffApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class NodeDiffApi {
+        constructor(context) {
+            this.httpClient = () => context.httpClient;
+        }
+        diff(request) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("baseVersion", request.baseVersion);
+                queryParams.set("compareVersion", request.compareVersion);
+                return this.httpClient()
+                    .get(`/pacman/api/core/packages/${request.packageKey}/nodes/${request.nodeKey}/diff/configuration?${queryParams.toString()}`)
+                    .catch(exception => {
+                    throw new logger_1.FatalError(`Problem getting the node diff: ${exception}`);
+                });
+            });
+        }
+    }
+    exports.NodeDiffApi = NodeDiffApi;
+});

package/commands/configuration-management/interfaces/node-dependency.interfaces.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/commands/configuration-management/interfaces/node-diff.interfaces.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/commands/configuration-management/interfaces/node.interfaces.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/commands/configuration-management/module.js

@@ -16,13 +16,16 @@ 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", "../../core/command/module-handler", "./config-command.service", "./variable-command.service"], factory);
+        define(["require", "exports", "../../core/command/module-handler", "./config-command.service", "./variable-command.service", "./node.service", "./node-diff.service", "./node-dependency.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     const module_handler_1 = require("../../core/command/module-handler");
     const config_command_service_1 = require("./config-command.service");
     const variable_command_service_1 = require("./variable-command.service");
+    const node_service_1 = require("./node.service");
+    const node_diff_service_1 = require("./node-diff.service");
+    const node_dependency_service_1 = require("./node-dependency.service");
     class Module extends module_handler_1.IModule {
         register(context, configurator) {
             const configCommand = configurator.command("config");
@@ -74,6 +77,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("--keysByVersion <keysByVersion...>", "Mapping of package keys and versions", "")
                 .option("--keysByVersionFile <keysByVersionFile>", "Package keys by version mappings file path.", "")
                 .action(this.listVariables);
+            const nodesCommand = configCommand.command("nodes")
+                .description("Commands related to nodes of the package");
+            nodesCommand.command("get")
+                .description("Find a specific node in a package")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package")
+                .requiredOption("--nodeKey <nodeKey>", "Identifier of the node")
+                .option("--packageVersion <packageVersion>", "Version of the package")
+                .option("--withConfiguration", "Include node configuration in the response", false)
+                .option("--json", "Return the response as a JSON file")
+                .action(this.findNode);
+            nodesCommand.command("list")
+                .description("List nodes in a specific package version")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package")
+                .requiredOption("--packageVersion <packageVersion>", "Version of the package")
+                .option("--limit <limit>", "Limit the number of results returned")
+                .option("--offset <offset>", "Offset for pagination")
+                .option("--withConfiguration", "Include node configuration in the response", false)
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listNodes);
+            nodesCommand.command("diff")
+                .description("Diff two versions of a specific node in a package")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package")
+                .requiredOption("--nodeKey <nodeKey>", "Identifier of the node")
+                .requiredOption("--baseVersion <baseVersion>", "Base version of the node")
+                .requiredOption("--compareVersion <compareVersion>", "Compare version of the node")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.diffNode);
+            const nodeDependenciesCommand = nodesCommand.command("dependencies")
+                .description("Commands related to node dependencies");
+            nodeDependenciesCommand.command("list")
+                .description("List dependencies of a specific node in a package")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package")
+                .requiredOption("--nodeKey <nodeKey>", "Identifier of the node")
+                .requiredOption("--packageVersion <packageVersion>", "Version of the package")
+                .option("--json", "Return the response as a JSON file")
+                .action(this.listNodeDependencies);
             const listCommand = configurator.command("list");
             listCommand.command("assignments")
                 .description("Command to list possible variable assignments for a type")
@@ -93,6 +132,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 if ((options.packageKeys && options.keysByVersion) || (!options.packageKeys && !options.keysByVersion)) {
                     throw new Error("Please provide either --packageKeys or --keysByVersion, but not both.");
                 }
+                if (options.gitProfile && !options.gitBranch) {
+                    throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
+                }
                 options.withDependencies = (_a = options.withDependencies) !== null && _a !== void 0 ? _a : false;
                 yield new config_command_service_1.ConfigCommandService(context).batchExportPackages(options.packageKeys, options.keysByVersion, options.withDependencies, options.gitBranch, options.unzip);
             });
@@ -104,6 +146,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         batchImportPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
+                if (options.gitProfile && !options.gitBranch) {
+                    throw new Error("Please specify a branch using --gitBranch when using a Git profile.");
+                }
                 yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.directory, options.overwrite, options.gitBranch);
             });
         }
@@ -122,6 +167,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 yield new variable_command_service_1.VariableCommandService(context).listAssignments(options.type, options.json, options.params);
             });
         }
+        findNode(context, command, options) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new node_service_1.NodeService(context).findNode(options.packageKey, options.nodeKey, options.withConfiguration, (_a = options.packageVersion) !== null && _a !== void 0 ? _a : null, options.json);
+            });
+        }
+        listNodes(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new node_service_1.NodeService(context).listNodes(options.packageKey, options.packageVersion, options.limit, options.offset, options.withConfiguration, options.json);
+            });
+        }
+        diffNode(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new node_diff_service_1.NodeDiffService(context).diff(options.packageKey, options.nodeKey, options.baseVersion, options.compareVersion, options.json);
+            });
+        }
+        listNodeDependencies(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new node_dependency_service_1.NodeDependencyService(context).listNodeDependencies(options.packageKey, options.nodeKey, options.packageVersion, options.json);
+            });
+        }
     }
     return Module;
 });

package/commands/configuration-management/node-dependency.service.js

@@ -0,0 +1,53 @@
+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", "./api/node-dependency-api", "../../core/utils/file-service", "../../core/utils/logger", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeDependencyService = void 0;
+    const node_dependency_api_1 = require("./api/node-dependency-api");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const uuid_1 = require("uuid");
+    class NodeDependencyService {
+        constructor(context) {
+            this.nodeDependencyApi = new node_dependency_api_1.NodeDependencyApi(context);
+        }
+        listNodeDependencies(packageKey, nodeKey, version, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dependencies = yield this.nodeDependencyApi.findAll(packageKey, nodeKey, version);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(dependencies, null, 2), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    if (dependencies.length === 0) {
+                        logger_1.logger.info("No dependencies found for this node.");
+                    }
+                    else {
+                        logger_1.logger.info(`Found ${dependencies.length} ${dependencies.length === 1 ? "dependency" : "dependencies"}:`);
+                        dependencies.forEach((dep, index) => {
+                            logger_1.logger.info(JSON.stringify(dep));
+                        });
+                    }
+                }
+            });
+        }
+    }
+    exports.NodeDependencyService = NodeDependencyService;
+});

package/commands/configuration-management/node-diff.service.js

@@ -0,0 +1,62 @@
+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", "uuid", "../../core/utils/logger", "../../core/utils/file-service", "./api/node-diff-api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeDiffService = void 0;
+    const uuid_1 = require("uuid");
+    const logger_1 = require("../../core/utils/logger");
+    const file_service_1 = require("../../core/utils/file-service");
+    const node_diff_api_1 = require("./api/node-diff-api");
+    class NodeDiffService {
+        constructor(context) {
+            this.nodeDiffApi = new node_diff_api_1.NodeDiffApi(context);
+        }
+        diff(packageKey, nodeKey, baseVersion, compareVersion, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodeDiff = yield this.nodeDiffApi.diff({
+                    packageKey,
+                    nodeKey,
+                    baseVersion,
+                    compareVersion,
+                });
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodeDiff, null, 2), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    logger_1.logger.info(`Package Key: ${nodeDiff.packageKey}`);
+                    logger_1.logger.info(`Node Key: ${nodeDiff.nodeKey}`);
+                    logger_1.logger.info(`Name: ${nodeDiff.name}`);
+                    logger_1.logger.info(`Type: ${nodeDiff.type}`);
+                    logger_1.logger.info(`Is invalid configuration: ${nodeDiff.invalidContent}`);
+                    if (nodeDiff.parentNodeKey) {
+                        logger_1.logger.info(`Parent Node Key: ${nodeDiff.parentNodeKey}`);
+                    }
+                    logger_1.logger.info(`Change Date: ${new Date(nodeDiff.changeDate).toISOString()}`);
+                    logger_1.logger.info(`Updated By: ${nodeDiff.updatedBy}`);
+                    logger_1.logger.info(`Change Type: ${nodeDiff.changeType}`);
+                    logger_1.logger.info(`Changes: ${JSON.stringify(nodeDiff.changes)}`);
+                    logger_1.logger.info(`Metadata Changes: ${JSON.stringify(nodeDiff.metadataChanges)}`);
+                }
+            });
+        }
+    }
+    exports.NodeDiffService = NodeDiffService;
+});

package/commands/configuration-management/node.service.js

@@ -0,0 +1,83 @@
+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", "./api/node-api", "../../core/utils/file-service", "../../core/utils/logger", "uuid"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NodeService = void 0;
+    const node_api_1 = require("./api/node-api");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const uuid_1 = require("uuid");
+    class NodeService {
+        constructor(context) {
+            this.nodeApi = new node_api_1.NodeApi(context);
+        }
+        findNode(packageKey, nodeKey, withConfiguration, packageVersion, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const node = packageVersion
+                    ? yield this.nodeApi.findVersionedNodeByKey(packageKey, nodeKey, packageVersion, withConfiguration)
+                    : yield this.nodeApi.findStagingNodeByKey(packageKey, nodeKey, withConfiguration);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(node, null, 2), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    this.printNode(node);
+                }
+            });
+        }
+        listNodes(packageKey, packageVersion, limit, offset, withConfiguration, jsonResponse) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodes = yield this.nodeApi.findVersionedNodesByPackage(packageKey, packageVersion, withConfiguration, limit, offset);
+                if (jsonResponse) {
+                    const filename = (0, uuid_1.v4)() + ".json";
+                    file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes, null, 2), filename);
+                    logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                }
+                else {
+                    nodes.forEach(node => {
+                        logger_1.logger.info(JSON.stringify(node));
+                    });
+                }
+            });
+        }
+        printNode(node) {
+            logger_1.logger.info(`ID: ${node.id}`);
+            logger_1.logger.info(`Key: ${node.key}`);
+            logger_1.logger.info(`Name: ${node.name}`);
+            logger_1.logger.info(`Type: ${node.type}`);
+            logger_1.logger.info(`Package Node Key: ${node.packageNodeKey}`);
+            if (node.parentNodeKey) {
+                logger_1.logger.info(`Parent Node Key: ${node.parentNodeKey}`);
+            }
+            logger_1.logger.info(`Created By: ${node.createdBy}`);
+            logger_1.logger.info(`Updated By: ${node.updatedBy}`);
+            logger_1.logger.info(`Creation Date: ${new Date(node.creationDate).toISOString()}`);
+            logger_1.logger.info(`Change Date: ${new Date(node.changeDate).toISOString()}`);
+            if (node.configuration) {
+                logger_1.logger.info(`Configuration: ${JSON.stringify(node.configuration, null, 2)}`);
+            }
+            if (node.invalidContent) {
+                logger_1.logger.info(`Invalid Configuration: ${node.invalidConfiguration}`);
+            }
+            logger_1.logger.info(`Flavor: ${node.flavor}`);
+        }
+    }
+    exports.NodeService = NodeService;
+});

package/commands/deployment/deployment-api.js

@@ -87,9 +87,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("deployableType", deployableType);
-                if (packageKey) {
-                    queryParams.set("packageKey", packageKey);
-                }
+                queryParams.set("packageKey", packageKey);
                 return this.httpClient()
                     .get(`/pacman/api/deployments/targets?${queryParams.toString()}`)
                     .catch((e) => {

package/commands/deployment/module.js

@@ -67,7 +67,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .beta()
                 .description("List all targets for a given deployable type and package key")
                 .requiredOption("--deployableType <deployableType>", "The type of the deployable")
-                .option("--packageKey <packageKey>", "Identifier of the package to list targets for")
+                .requiredOption("--packageKey <packageKey>", "Identifier of the package to list targets for")
                 .option("--json", "Return the response as a JSON file")
                 .action(this.listTargets);
         }

package/commands/git-profile/git-profile-command.service.js

@@ -33,6 +33,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 const questions = new question_service_1.QuestionService();
                 try {
                     profile.name = yield questions.ask("Name of the Git profile to create: ");
+                    this.gitProfileService.validateProfileName(profile.name);
                     profile.username = yield questions.ask("Your Git username: ");
                     profile.repository = yield questions.ask("Your repository (format: repoOwner/repoName): ");
                     const type = yield questions.ask("Authentication type: HTTPS (1), SSH token (2): ");
@@ -52,11 +53,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     if (setAsDefault) {
                         yield this.makeDefaultProfile(profile.name);
                     }
+                    logger_1.logger.info("Git Profile created successfully!");
+                }
+                catch (e) {
+                    logger_1.logger.error(e.toString());
                 }
                 finally {
                     yield questions.close();
                 }
-                logger_1.logger.info("Git Profile created successfully!");
             });
         }
         listProfiles() {

package/core/command/module-handler.js

@@ -197,7 +197,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     this.printBetaNoticeIfBetaCommand();
                     this.printBetaNoticeIfBetaOptions();
                     this.printDeprecationNoticeIfDeprecated();
-                    yield handler(this.ctx, this.cmd, this.cmd.opts());
+                    yield handler(this.ctx, this.cmd, this.cmd.optsWithGlobals());
                 }
                 catch (error) {
                     logger_1.logger.error(`An unexpected error occured executing a command: ${error}`);
@@ -218,7 +218,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             if (this.cmd.isBeta) {
                 return;
             }
-            const providedOptions = this.cmd.opts();
+            const providedOptions = this.cmd.optsWithGlobals();
             for (const option of this.cmd.options) {
                 const optionName = option.attributeName();
                 if (option.isBeta && Object.hasOwn(providedOptions, optionName)) {

package/core/git-profile/git/git.service.js

@@ -13,14 +13,13 @@ 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", "simple-git", "../../utils/logger", "fs", "path", "node:os", "uuid"], factory);
+        define(["require", "exports", "simple-git", "fs", "path", "node:os", "uuid"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.GitService = void 0;
     const simple_git_1 = require("simple-git");
-    const logger_1 = require("../../utils/logger");
     const fs = require("fs");
     const path = require("path");
     const os = require("node:os");
@@ -63,11 +62,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     yield this.checkoutOrCreateLocalBranch(repoGit, branch);
                     fs.cpSync(sourceDir, workingDir, { recursive: true });
                     yield repoGit.add("./*");
-                    const status = yield repoGit.status();
-                    if (status.files.length === 0) {
-                        logger_1.logger.debug("No changes to commit.");
-                        return;
-                    }
                     const commitMessage = "Update from content-cli";
                     yield repoGit.commit(commitMessage);
                     yield repoGit.push(["--set-upstream", "origin", branch]);

package/core/git-profile/git-profile.service.js

@@ -81,6 +81,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 encoding: "utf-8",
             });
         }
+        validateProfileName(name) {
+            if (GitProfileService.INVALID_FILENAME_CHARS.test(name)) {
+                throw new Error(`Invalid profile name "${name}". The following characters are not allowed: / \\ : * ? " < > |`);
+            }
+        }
         buildProfileFromEnvVariables() {
             return __awaiter(this, void 0, void 0, function* () {
                 const profileVariables = this.getProfileEnvVariables();
@@ -131,4 +136,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
     }
     exports.GitProfileService = GitProfileService;
+    GitProfileService.INVALID_FILENAME_CHARS = /[\/\\:*?"<>|.]/;
 });

package/core/profile/profile.service.js

@@ -31,7 +31,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     // use 5 seconds buffer to avoid rare cases when accessToken is just about to expire before the command is sent
     const expiryBuffer = 5000;
     const deviceCodeScopes = ["studio", "package-manager", "integration.data-pools", "action-engine.projects"];
-    const clientCredentialsScopes = ["studio", "integration.data-pools", "action-engine.projects"];
+    const clientCredentialsScopes = ["studio", "integration.data-pools", "action-engine.projects", "package-manager"];
     class ProfileService {
         constructor() {
             this.profileContainerPath = path.resolve(homedir, ".celonis-content-cli-profiles");

package/lib/commands/configuration-management/api/node-api.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "../../../core/command/cli-context";
+import { NodeTransport } from "../interfaces/node.interfaces";
+export declare class NodeApi {
+    private httpClient;
+    constructor(context: Context);
+    findStagingNodeByKey(packageKey: string, nodeKey: string, withConfiguration: boolean): Promise<NodeTransport>;
+    findVersionedNodeByKey(packageKey: string, nodeKey: string, version: string, withConfiguration: boolean): Promise<NodeTransport>;
+    findVersionedNodesByPackage(packageKey: string, version: string, withConfiguration: boolean, limit: number, offset: number): Promise<NodeTransport[]>;
+}

package/lib/commands/configuration-management/api/node-dependency-api.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../../core/command/cli-context";
+import { NodeDependencyTransport } from "../interfaces/node-dependency.interfaces";
+export declare class NodeDependencyApi {
+    private httpClient;
+    constructor(context: Context);
+    findAll(packageKey: string, nodeKey: string, version: string): Promise<NodeDependencyTransport[]>;
+}

package/lib/commands/configuration-management/api/node-diff-api.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../../core/command/cli-context";
+import { GetNodeDiffRequest, NodeConfigurationDiffTransport } from "../interfaces/node-diff.interfaces";
+export declare class NodeDiffApi {
+    private httpClient;
+    constructor(context: Context);
+    diff(request: GetNodeDiffRequest): Promise<NodeConfigurationDiffTransport>;
+}

package/lib/commands/configuration-management/interfaces/node-dependency.interfaces.d.ts

@@ -0,0 +1,5 @@
+export interface NodeDependencyTransport {
+    packageKey: string;
+    key: string;
+    type: string;
+}

package/lib/commands/configuration-management/interfaces/node-diff.interfaces.d.ts

@@ -0,0 +1,20 @@
+import { ConfigurationChangeTransport, NodeConfigurationChangeType } from "./diff-package.interfaces";
+export interface GetNodeDiffRequest {
+    packageKey: string;
+    nodeKey: string;
+    baseVersion: string;
+    compareVersion: string;
+}
+export interface NodeConfigurationDiffTransport {
+    packageKey: string;
+    nodeKey: string;
+    parentNodeKey: string;
+    name: string;
+    type: string;
+    invalidContent: boolean;
+    changeDate: string;
+    updatedBy: string;
+    changeType: NodeConfigurationChangeType;
+    changes: ConfigurationChangeTransport;
+    metadataChanges: ConfigurationChangeTransport;
+}

package/lib/commands/configuration-management/interfaces/node.interfaces.d.ts

@@ -0,0 +1,21 @@
+export interface NodeConfiguration {
+    [key: string]: any;
+}
+export interface NodeTransport {
+    id: string;
+    key: string;
+    name: string;
+    packageNodeKey: string;
+    parentNodeKey?: string;
+    packageNodeId: string;
+    type: string;
+    configuration?: NodeConfiguration;
+    invalidConfiguration?: string;
+    invalidContent: boolean;
+    creationDate: string;
+    changeDate: string;
+    createdBy: string;
+    updatedBy: string;
+    schemaVersion: number;
+    flavor?: string;
+}

package/lib/commands/configuration-management/module.d.ts

@@ -12,5 +12,9 @@ declare class Module extends IModule {
     private diffPackages;
     private listVariables;
     private listAssignments;
+    private findNode;
+    private listNodes;
+    private diffNode;
+    private listNodeDependencies;
 }
 export = Module;

package/lib/commands/configuration-management/node-dependency.service.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../../core/command/cli-context";
+export declare class NodeDependencyService {
+    private readonly nodeDependencyApi;
+    constructor(context: Context);
+    listNodeDependencies(packageKey: string, nodeKey: string, version: string, jsonResponse: boolean): Promise<void>;
+}

package/lib/commands/configuration-management/node-diff.service.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../../core/command/cli-context";
+export declare class NodeDiffService {
+    private nodeDiffApi;
+    constructor(context: Context);
+    diff(packageKey: string, nodeKey: string, baseVersion: string, compareVersion: string, jsonResponse: boolean): Promise<void>;
+}

package/lib/commands/configuration-management/node.service.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../core/command/cli-context";
+export declare class NodeService {
+    private nodeApi;
+    constructor(context: Context);
+    findNode(packageKey: string, nodeKey: string, withConfiguration: boolean, packageVersion: string | null, jsonResponse: boolean): Promise<void>;
+    listNodes(packageKey: string, packageVersion: string, limit: number, offset: number, withConfiguration: boolean, jsonResponse: boolean): Promise<void>;
+    private printNode;
+}

package/lib/commands/deployment/deployment-api.d.ts

@@ -7,7 +7,7 @@ export declare class DeploymentApi {
     getDeployments(filter: GetDeploymentsRequest, limit?: string, offset?: string): Promise<DeploymentTransport[]>;
     getActiveDeploymentsForPackage(packageKey: string, targetIds?: string[], limit?: string, offset?: string): Promise<DeploymentTransport[]>;
     getActiveDeploymentForTarget(targetId: string): Promise<DeploymentTransport>;
-    getTargets(deployableType: string, packageKey?: string): Promise<TargetTransport[]>;
+    getTargets(deployableType: string, packageKey: string): Promise<TargetTransport[]>;
     getDeployables(flavor?: string): Promise<DeployableTransport[]>;
     private addPaginationParams;
 }

package/lib/commands/deployment/deployment.service.d.ts

@@ -6,6 +6,6 @@ export declare class DeploymentService {
     getDeployments(jsonResponse: boolean, packageKey?: string, targetId?: string, deployableType?: string, status?: string, createdBy?: string, limit?: string, offset?: string): Promise<void>;
     getActiveDeploymentForTarget(targetId: string, jsonResponse: boolean): Promise<void>;
     getActiveDeploymentsForPackage(packageKey: string, jsonResponse: boolean, targetIds?: string[], limit?: string, offset?: string): Promise<void>;
-    getTargets(jsonResponse: boolean, deployableType: string, packageKey?: string): Promise<void>;
+    getTargets(jsonResponse: boolean, deployableType: string, packageKey: string): Promise<void>;
     getDeployables(jsonResponse: boolean, flavor?: string): Promise<void>;
 }

package/lib/core/git-profile/git-profile.service.d.ts

@@ -6,10 +6,12 @@ export declare class GitProfileService {
     private readonly homedir;
     private readonly gitProfileContainerPath;
     private readonly configContainer;
+    private static readonly INVALID_FILENAME_CHARS;
     findProfile(profileName: string): Promise<GitProfile>;
     makeDefaultProfile(profileName: string): Promise<GitProfile>;
     getDefaultProfile(): string;
     storeProfile(profile: GitProfile): void;
+    validateProfileName(name: string): void;
     private buildProfileFromEnvVariables;
     private storeConfig;
     private createProfileContainerIfNotExists;

package/package.json

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