@celonis/content-cli 1.4.0 → 1.5.0

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

@@ -24,7 +24,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         constructor(context) {
             this.httpClient = () => context.httpClient;
         }
-        findAll(packageKey, nodeKey, version) {
+        findAllStaging(packageKey, nodeKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient()
+                    .get(`/pacman/api/core/staging/packages/${packageKey}/nodes/${nodeKey}/dependencies`)
+                    .catch((e) => {
+                    throw new logger_1.FatalError(`Problem finding dependencies for node ${nodeKey} in package ${packageKey}: ${e}`);
+                });
+            });
+        }
+        findAllByVersion(packageKey, nodeKey, version) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("version", version);

package/commands/configuration-management/module.js

@@ -75,7 +75,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             configVersionCommand.command("get")
                 .description("Get version metadata for a specific package version")
                 .requiredOption("--packageKey <packageKey>", "Identifier of the package")
-                .requiredOption("--packageVersion <packageVersion>", "Version of the package")
+                .requiredOption("--packageVersion <packageVersion>", "Version of the package. Can be a specific version or \"LATEST\" keyword, which will return the most recently created version.")
                 .option("--json", "Return the response as a JSON file")
                 .action(this.getPackageVersion);
             const variablesCommand = configCommand.command("variables")
@@ -119,7 +119,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .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("--packageVersion <packageVersion>", "Version of the package. If not sent, the staging state of the package will be used.")
                 .option("--json", "Return the response as a JSON file")
                 .action(this.listNodeDependencies);
             const listCommand = configurator.command("list");
@@ -199,6 +199,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listNodeDependencies(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
+                if (options.packageVersion === "") {
+                    throw new Error("Please specify a valid package version");
+                }
                 yield new node_dependency_service_1.NodeDependencyService(context).listNodeDependencies(options.packageKey, options.nodeKey, options.packageVersion, options.json);
             });
         }

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

@@ -29,7 +29,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listNodeDependencies(packageKey, nodeKey, version, jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
-                const dependencies = yield this.nodeDependencyApi.findAll(packageKey, nodeKey, version);
+                let dependencies;
+                if (version) {
+                    dependencies = yield this.nodeDependencyApi.findAllByVersion(packageKey, nodeKey, version);
+                }
+                else {
+                    dependencies = yield this.nodeDependencyApi.findAllStaging(packageKey, nodeKey);
+                }
                 if (jsonResponse) {
                     const filename = (0, uuid_1.v4)() + ".json";
                     file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(dependencies, null, 2), filename);

package/commands/studio/command-service/package-command.service.js

@@ -54,16 +54,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.packageService.batchExportPackages(packageKeys, includeDependencies, excludeActionFlows);
-            });
-        }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows);
-            });
-        }
     }
     exports.PackageCommandService = PackageCommandService;
 });

package/commands/studio/module.js

@@ -27,26 +27,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const space_command_service_1 = require("./command-service/space-command.service");
     class Module extends module_handler_1.IModule {
         register(context, configurator) {
-            const exportCommand = configurator.command("export");
-            exportCommand.command("packages")
-                .description("Command to export all given packages")
-                .requiredOption("--packageKeys <packageKeys...>", "Exports only given package keys")
-                .option("--includeDependencies", "Include variables and dependencies", "")
-                .option("--excludeActionFlows", "Don't export action flows")
-                .deprecationNotice("`content-cli export packages` is deprecated and is expected to be removed in subsequent updates around: 01-09-2025.\n" +
-                "Please use `content-cli config export` instead.\n")
-                .action(this.batchExportPackages);
-            const importCommand = configurator.command("import");
-            importCommand.command("packages")
-                .description("Command to import all given packages")
-                .option("--spaceMappings <spaceMappings...>", "List of mappings for importing packages to different target spaces. Mappings should follow format 'packageKey:targetSpaceKey'")
-                .option("--overwrite", "Flag to allow overwriting of packages")
-                .option("--excludeActionFlows", "Skip overwrite of action flows of package")
-                .option("--dataModelMappingsFile <dataModelMappingsFile>", "DataModel variable mappings file path. If missing, variables will be mapped from manifest file.")
-                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
-                .deprecationNotice("`content-cli import packages` is deprecated and is expected to be removed in subsequent updates around: 01-09-2025.\n" +
-                "Please use `content-cli config import` instead.\n")
-                .action(this.batchImportPackages);
             const listCommand = configurator.command("list");
             listCommand.command("packages")
                 .description("Command to list all packages")
@@ -103,17 +83,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("--packageManager", "Upload widget to package manager (deprecated)") // Deprecated
                 .action(this.pushWidget);
         }
-        batchExportPackages(context, command, options) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_service_1.PackageCommandService(context).batchExportPackages(options.packageKeys, options.includeDependencies, (_a = options.excludeActionFlows) !== null && _a !== void 0 ? _a : false);
-            });
-        }
-        batchImportPackages(context, command, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_service_1.PackageCommandService(context).batchImportPackages(options.spaceMappings, options.dataModelMappingsFile, options.file, options.overwrite, options.excludeActionFlows);
-            });
-        }
         listPackages(context, command, options) {
             return __awaiter(this, void 0, void 0, function* () {
                 yield new package_command_service_1.PackageCommandService(context).listPackages(options.json, options.includeDependencies, options.packageKeys);

package/commands/studio/service/package.service.js

@@ -13,39 +13,27 @@ 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", "uuid", "fs", "adm-zip", "path", "os", "form-data", "../api/package-api", "../../../core/utils/logger", "../interfaces/package-manager.interfaces", "../../../core/utils/file-service", "../../../core/utils/yaml", "yaml", "../utils/semantic-versioning", "../api/node-api", "../api/package-dependencies-api", "./data-model.service", "./studio-variable.service", "./space.service"], factory);
+        define(["require", "exports", "uuid", "../api/package-api", "../../../core/utils/logger", "../interfaces/package-manager.interfaces", "../../../core/utils/file-service", "../api/package-dependencies-api", "./data-model.service", "./studio-variable.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.PackageService = void 0;
     const uuid_1 = require("uuid");
-    const fs = require("fs");
-    const AdmZip = require("adm-zip");
-    const path = require("path");
-    const os_1 = require("os");
-    const FormData = require("form-data");
     const package_api_1 = require("../api/package-api");
     const logger_1 = require("../../../core/utils/logger");
     const package_manager_interfaces_1 = require("../interfaces/package-manager.interfaces");
     const file_service_1 = require("../../../core/utils/file-service");
-    const yaml_1 = require("../../../core/utils/yaml");
-    const yaml_2 = require("yaml");
-    const semantic_versioning_1 = require("../utils/semantic-versioning");
-    const node_api_1 = require("../api/node-api");
     const package_dependencies_api_1 = require("../api/package-dependencies-api");
     const data_model_service_1 = require("./data-model.service");
     const studio_variable_service_1 = require("./studio-variable.service");
-    const space_service_1 = require("./space.service");
     class PackageService {
         constructor(context) {
             this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
             this.packageApi = new package_api_1.PackageApi(context);
-            this.nodeApi = new node_api_1.NodeApi(context);
             this.packageDependenciesApi = new package_dependencies_api_1.PackageDependenciesApi(context);
             this.dataModelService = new data_model_service_1.DataModelService(context);
             this.variableService = new studio_variable_service_1.StudioVariableService(context);
-            this.spaceService = new space_service_1.SpaceService(context);
         }
         listPackages() {
             return __awaiter(this, void 0, void 0, function* () {
@@ -85,247 +73,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportListOfPackages(nodesListToExport, fieldsToInclude);
             });
         }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                exportedPackagesFile = exportedPackagesFile + (exportedPackagesFile.includes(".zip") ? "" : ".zip");
-                const zip = new AdmZip(exportedPackagesFile);
-                const importedFilePath = path.resolve((0, os_1.tmpdir)(), "export_" + (0, uuid_1.v4)());
-                yield fs.mkdirSync(importedFilePath);
-                yield zip.extractAllTo(importedFilePath);
-                const manifestNodes = yield this.readManifestFile(importedFilePath);
-                if (!overwrite) {
-                    const allTargetPackages = yield this.packageApi.findAllPackages();
-                    const manifestNodeKeys = manifestNodes.map(node => node.packageKey);
-                    const packagesWithDraftChanges = allTargetPackages
-                        .filter(node => manifestNodeKeys.includes(node.key) && node.workingDraftId !== node.activatedDraftId)
-                        .map(node => node.key)
-                        .join(", ");
-                    if (!!packagesWithDraftChanges) {
-                        throw new logger_1.FatalError(`Failed to import. Cannot overwrite packages with key(s) ${packagesWithDraftChanges}`);
-                    }
-                }
-                let dmTargetIdsBySourceIds = new Map();
-                if (dataModelMappingsFilePath) {
-                    const dataModelMappings = yield file_service_1.fileService.readFileToJson(dataModelMappingsFilePath);
-                    dmTargetIdsBySourceIds = new Map(Object.entries(dataModelMappings.dataModelIdMappings));
-                }
-                manifestNodes.map(node => node.dependenciesByVersion = new Map(Object.entries(node.dependenciesByVersion)));
-                const importedVersionsByNodeKey = new Map();
-                const sourceToTargetVersionsByNodeKey = new Map();
-                for (const node of manifestNodes) {
-                    for (const version of node.dependenciesByVersion.keys()) {
-                        yield this.checkNodeForCircularDependency(node, version, manifestNodes, []);
-                    }
-                }
-                const customSpacesMap = new Map();
-                spaceMappings.forEach(spaceMap => {
-                    const packageAndSpaceid = spaceMap.split(":");
-                    customSpacesMap.set(packageAndSpaceid[0], packageAndSpaceid[1]);
-                });
-                const draftIdsByPackageKeyAndVersion = new Map();
-                for (const node of manifestNodes) {
-                    yield this.importPackage(node, manifestNodes, sourceToTargetVersionsByNodeKey, customSpacesMap, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-            });
-        }
-        checkNodeForCircularDependency(node, version, manifestNodes, iteratedNodeAndVersions) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const dependencies = node.dependenciesByVersion.get(version);
-                if (iteratedNodeAndVersions.includes(`${node.packageKey}_${version}`)) {
-                    throw new Error("Circular dependency detected!");
-                }
-                iteratedNodeAndVersions.push(`${node.packageKey}_${version}`);
-                for (const dependency of dependencies) {
-                    const manifestNodeOfDependency = manifestNodes.find(manifestNode => manifestNode.packageKey === dependency.key);
-                    yield this.checkNodeForCircularDependency(manifestNodeOfDependency, dependency.version, manifestNodes, iteratedNodeAndVersions);
-                }
-            });
-        }
-        importPackage(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows) {
-            var _a;
-            return __awaiter(this, void 0, void 0, function* () {
-                const importedPackageVersion = (_a = importedVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _a !== void 0 ? _a : [];
-                const versionsOfPackage = [...packageToImport.dependenciesByVersion.keys()].sort((k1, k2) => {
-                    const version1 = new semantic_versioning_1.SemanticVersioning(k1);
-                    const version2 = new semantic_versioning_1.SemanticVersioning(k1);
-                    return version1.isGreaterThan(version2) ? 1 : -1;
-                }).filter(version => !importedPackageVersion.includes(version));
-                for (const version of versionsOfPackage) {
-                    try {
-                        yield this.importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, version, excludeActionFlows);
-                    }
-                    catch (e) {
-                        logger_1.logger.error(`Problem import package with key: ${packageToImport.packageKey} ${version} ${e}`);
-                    }
-                }
-            });
-        }
-        importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, versionOfPackageBeingImported, excludeActionFlows) {
-            var _a, _b;
-            return __awaiter(this, void 0, void 0, function* () {
-                if (packageToImport.dependenciesByVersion.get(versionOfPackageBeingImported).length) {
-                    const dependenciesOfPackageVersion = packageToImport.dependenciesByVersion.get(versionOfPackageBeingImported);
-                    yield this.importDependencyPackages(dependenciesOfPackageVersion, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-                if (this.checkIfPackageVersionHasBeenImported(packageToImport.packageKey, versionOfPackageBeingImported, importedVersionsByNodeKey)) {
-                    return;
-                }
-                const targetSpace = yield this.getTargetSpaceForExportedPackage(packageToImport, spaceMappings);
-                let nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                const pathToZipFile = path.resolve(importedFilePath, packageToImport.packageKey + "_" + versionOfPackageBeingImported + ".zip");
-                const packageZip = this.createBodyForImport(pathToZipFile);
-                yield this.packageApi.importPackage(packageZip, targetSpace.id, !!nodeInTargetTeam, excludeActionFlows);
-                if (nodeInTargetTeam) {
-                    yield this.packageApi.movePackageToSpace(nodeInTargetTeam.id, targetSpace.id);
-                }
-                nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                if (this.isLatestVersion(versionOfPackageBeingImported, [...packageToImport.dependenciesByVersion.keys()])) {
-                    if (dmTargetIdsBySourceIds.size > 0) {
-                        const variableAssignments = packageToImport.variables
-                            .filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL).map(variable => {
-                            var _a;
-                            variable.value = dmTargetIdsBySourceIds.get((_a = variable.value) === null || _a === void 0 ? void 0 : _a.toString());
-                            return variable;
-                        });
-                        yield this.variableService.assignVariableValues(nodeInTargetTeam.key, variableAssignments);
-                    }
-                    else {
-                        yield this.variableService.assignVariableValues(nodeInTargetTeam.key, packageToImport.variables);
-                    }
-                }
-                draftIdsByPackageKeyAndVersion.set(`${nodeInTargetTeam.key}_${versionOfPackageBeingImported}`, nodeInTargetTeam.workingDraftId);
-                yield this.updateDependencyVersions(packageToImport, versionOfPackageBeingImported, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion);
-                yield this.publishPackage(packageToImport);
-                const packageVersionInTargetTeam = yield this.packageApi.findActiveVersionById(nodeInTargetTeam.id);
-                const mappedVersions = (_a = sourceToTargetVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _a !== void 0 ? _a : new Map();
-                mappedVersions.set(versionOfPackageBeingImported, packageVersionInTargetTeam.version);
-                sourceToTargetVersionsByNodeKey.set(packageToImport.packageKey, mappedVersions);
-                const importedVersionsOfPackage = (_b = importedVersionsByNodeKey.get(packageToImport.packageKey)) !== null && _b !== void 0 ? _b : [];
-                importedVersionsOfPackage.push(versionOfPackageBeingImported);
-                importedVersionsByNodeKey.set(packageToImport.packageKey, importedVersionsOfPackage);
-                const mappedVersion = sourceToTargetVersionsByNodeKey.get(packageToImport.packageKey).get(versionOfPackageBeingImported);
-                logger_1.logger.info(`Imported package with key: ${packageToImport.packageKey} ${versionOfPackageBeingImported} successfully. New version: ${mappedVersion}`);
-            });
-        }
-        isLatestVersion(packageVersion, allPackageVersions) {
-            let isLatestVersion = true;
-            for (const version of allPackageVersions) {
-                const version1 = new semantic_versioning_1.SemanticVersioning(packageVersion);
-                const version2 = new semantic_versioning_1.SemanticVersioning(version);
-                if (version2.isGreaterThan(version1)) {
-                    isLatestVersion = false;
-                    break;
-                }
-            }
-            return isLatestVersion;
-        }
-        importDependencyPackages(dependenciesToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                for (const dependency of dependenciesToImport) {
-                    if (this.checkIfPackageVersionHasBeenImported(dependency.key, dependency.version, importedVersionsByNodeKey)) {
-                        continue;
-                    }
-                    const dependentPackage = manifestNodes.find(node => node.packageKey === dependency.key);
-                    yield this.importPackage(dependentPackage, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
-                }
-            });
-        }
-        checkIfPackageVersionHasBeenImported(packageKey, version, importedVersions) {
-            var _a;
-            const importedPackages = (_a = importedVersions.get(packageKey)) !== null && _a !== void 0 ? _a : [];
-            return importedPackages.includes(version);
-        }
-        createBodyForImport(filename) {
-            const formData = new FormData();
-            formData.append("package", fs.createReadStream(filename, { encoding: null }));
-            return formData;
-        }
-        getTargetSpaceForExportedPackage(packageToImport, spaceMappings) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let targetSpace;
-                const allSpaces = yield this.spaceService.refreshAndGetAllSpaces();
-                if (spaceMappings.has(packageToImport.packageKey)) {
-                    const customSpaceId = spaceMappings.get(packageToImport.packageKey);
-                    const customSpace = allSpaces.find(space => space.id === customSpaceId);
-                    if (!customSpace) {
-                        throw Error("Provided space id does not exist");
-                    }
-                    targetSpace = customSpace;
-                }
-                else {
-                    targetSpace = allSpaces.find(space => space.name === packageToImport.space.spaceName);
-                    if (!targetSpace) {
-                        targetSpace = yield this.spaceService.createSpace(packageToImport.space.spaceName, packageToImport.space.spaceIcon);
-                    }
-                }
-                return targetSpace;
-            });
-        }
-        updateDependencyVersions(node, versionOfPackage, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const createdNode = yield this.nodeApi.findOneByKeyAndRootNodeKey(node.packageKey, node.packageKey);
-                const newDependencies = [];
-                for (const dependency of [...node.dependenciesByVersion.get(versionOfPackage)]) {
-                    const nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(dependency.key, dependency.key);
-                    const draftIdOfVersionedDependency = draftIdsByPackageKeyAndVersion.get(`${dependency.key}_${dependency.version}`);
-                    dependency.version = sourceToTargetVersionsByNodeKey.get(dependency.key).get(dependency.version);
-                    dependency.updateAvailable = dependency.updateAvailable;
-                    dependency.id = nodeInTargetTeam.rootNodeId;
-                    dependency.rootNodeId = createdNode.rootNodeId;
-                    dependency.draftId = draftIdOfVersionedDependency;
-                    newDependencies.push(dependency);
-                    yield this.packageDependenciesApi.deleteDependency(createdNode.id, dependency.key);
-                }
-                if (newDependencies.length) {
-                    yield this.packageDependenciesApi.createDependencies(createdNode.id, newDependencies);
-                }
-            });
-        }
-        publishPackage(packageToImport) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const nodeInTargetTeam = yield this.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
-                const nextVersion = yield this.packageApi.findNextVersion(nodeInTargetTeam.id);
-                yield this.packageApi.publishPackage({
-                    packageKey: packageToImport.packageKey,
-                    version: nextVersion.version,
-                    publishMessage: "Published package after import",
-                    nodeIdsToExclude: []
-                });
-            });
-        }
-        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const allPackages = yield this.packageApi.findAllPackages();
-                let nodesListToExport = allPackages.filter(node => packageKeys.includes(node.key));
-                const versionsByNodeKey = new Map();
-                const allPackageKeys = allPackages.map(p => p.key);
-                for (const packageKey of packageKeys) {
-                    if (!allPackageKeys.includes(packageKey)) {
-                        throw new Error(`Package ${packageKey} does not exist.`);
-                    }
-                }
-                nodesListToExport = yield this.getNodesWithActiveVersion(nodesListToExport);
-                if (includeDependencies) {
-                    const dependencyPackages = yield this.getDependencyPackages(nodesListToExport, [], allPackages, [], versionsByNodeKey);
-                    nodesListToExport.push(...dependencyPackages);
-                }
-                const packagesWithVariableAssignments = yield this.variableService.getVariableAssignmentsForNodes();
-                nodesListToExport.forEach(node => {
-                    var _a;
-                    node.variables = (_a = packagesWithVariableAssignments.find(nodeWithVariablesAssignment => nodeWithVariablesAssignment.key === node.key)) === null || _a === void 0 ? void 0 : _a.variableAssignments;
-                });
-                const packagesWithDataModelVariables = packagesWithVariableAssignments.map(packageWithVariablesAssignments => {
-                    packageWithVariablesAssignments.variableAssignments = packageWithVariablesAssignments.variableAssignments.filter(variable => variable.value && variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
-                    return packageWithVariablesAssignments;
-                });
-                const dataModelDetailsByNode = yield this.dataModelService.getDataModelDetailsForPackages(packagesWithDataModelVariables);
-                nodesListToExport.forEach(node => {
-                    node.datamodels = dataModelDetailsByNode.get(node.key);
-                });
-                nodesListToExport = yield this.spaceService.getParentSpaces(nodesListToExport);
-                yield this.exportToZip(nodesListToExport, versionsByNodeKey, excludeActionFlows);
-            });
-        }
         getNodesWithActiveVersion(nodes) {
             return __awaiter(this, void 0, void 0, function* () {
                 const activeVersionsOfPackage = yield this.packageApi.findActiveVersionByIds(nodes.map(node => node.id));
@@ -340,114 +87,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return yield this.packageDependenciesApi.findPackageDependenciesByIds(draftIdByNodeId);
             });
         }
-        getDependencyPackages(nodesToResolve, dependencyPackages, allPackages, resolvedDependencies, versionsByNodeKey) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const draftIdByNodeId = new Map();
-                nodesToResolve.forEach(node => draftIdByNodeId.set(node.activatedDraftId, node.id));
-                const dependenciesByPackageDraftIds = yield this.getPackagesWithDependencies(draftIdByNodeId);
-                const nodesWithDependencies = nodesToResolve.map(nodeToExport => {
-                    var _a;
-                    nodeToExport.dependencies = (_a = dependenciesByPackageDraftIds[nodeToExport.activatedDraftId]) !== null && _a !== void 0 ? _a : [];
-                    return nodeToExport;
-                });
-                for (const node of nodesWithDependencies) {
-                    node.dependencies = node.dependencies.filter(dependency => !(dependency.external || dependency.deleted));
-                    node.dependencies.forEach(dependency => {
-                        var _a;
-                        const dependencyVersions = (_a = versionsByNodeKey.get(dependency.key)) !== null && _a !== void 0 ? _a : [];
-                        if (!dependencyVersions.includes(dependency.version)) {
-                            dependencyVersions.push(dependency.version);
-                            versionsByNodeKey.set(dependency.key, dependencyVersions);
-                        }
-                    });
-                    const nodesToGetKeys = node.dependencies.filter(dependency => {
-                        return !this.nodeHasBeenResolvedBefore(resolvedDependencies, dependency.key, dependency.version);
-                    }).map(iteratedNode => iteratedNode.key);
-                    if (nodesToGetKeys.length > 0) {
-                        const dependencyPackagesOfNode = allPackages.filter(packageNode => nodesToGetKeys.includes(packageNode.key)).map(dependency => {
-                            const versionedDep = node.dependencies.find(dep => dependency.key === dep.key);
-                            return Object.assign(Object.assign({}, dependency), { version: {
-                                    version: versionedDep.version
-                                }, activatedDraftId: versionedDep.draftId });
-                        });
-                        dependencyPackages.push(...dependencyPackagesOfNode);
-                        yield this.getDependencyPackages(dependencyPackagesOfNode, dependencyPackages, allPackages, resolvedDependencies, versionsByNodeKey);
-                    }
-                }
-                return dependencyPackages;
-            });
-        }
-        nodeHasBeenResolvedBefore(nodePath, nodeKey, version) {
-            return nodePath.includes(nodeKey + ":" + version);
-        }
         exportListOfPackages(nodes, fieldsToInclude) {
             const filename = (0, uuid_1.v4)() + ".json";
             file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes, fieldsToInclude), filename);
             logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
         }
-        exportPackagesAndAssets(nodes, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const zips = [];
-                for (const rootPackage of nodes) {
-                    const exportedPackage = yield this.packageApi.exportPackage(rootPackage.key, rootPackage.version.version, excludeActionFlows);
-                    zips.push({
-                        data: exportedPackage,
-                        packageKey: rootPackage.key,
-                        version: rootPackage.version.version
-                    });
-                }
-                return zips;
-            });
-        }
-        exportToZip(nodes, versionsByNodeKey, excludeActionFlows) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const manifestNodes = this.exportManifestOfPackages(nodes, versionsByNodeKey);
-                const packageZips = yield this.exportPackagesAndAssets(nodes, excludeActionFlows);
-                const zip = new AdmZip();
-                zip.addFile("manifest.yml", Buffer.from((0, yaml_2.stringify)(manifestNodes), "utf8"));
-                for (const packageZip of packageZips) {
-                    zip.addFile(`${packageZip.packageKey}_${packageZip.version}.zip`, packageZip.data);
-                }
-                const fileName = "export_" + (0, uuid_1.v4)() + ".zip";
-                zip.writeZip(fileName);
-                logger_1.logger.info(this.fileDownloadedMessage + fileName);
-            });
-        }
-        exportManifestOfPackages(nodes, dependencyVersionsByNodeKey) {
-            const manifestNodesByPackageKey = new Map();
-            nodes.forEach(node => {
-                var _a, _b, _c, _d;
-                const manifestNode = (_a = manifestNodesByPackageKey.get(node.key)) !== null && _a !== void 0 ? _a : {};
-                manifestNode.packageKey = node.key;
-                manifestNode.packageId = node.id;
-                manifestNode.space = {
-                    spaceName: node.space.name,
-                    spaceIcon: node.space.iconReference
-                };
-                manifestNode.variables = (_b = node.variables) === null || _b === void 0 ? void 0 : _b.map(variable => {
-                    var _a;
-                    if (variable.type === package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL) {
-                        // @ts-ignore
-                        const dataModel = (_a = node.datamodels) === null || _a === void 0 ? void 0 : _a.find(dataModel => dataModel.dataModelId === variable.value);
-                        return {
-                            key: variable.key,
-                            type: variable.type,
-                            value: variable.value,
-                            dataModelName: dataModel === null || dataModel === void 0 ? void 0 : dataModel.name,
-                        };
-                    }
-                    return variable;
-                });
-                manifestNode.dependenciesByVersion = (_c = manifestNode.dependenciesByVersion) !== null && _c !== void 0 ? _c : new Map();
-                manifestNode.dependenciesByVersion.set(node.version.version, (_d = node.dependencies) !== null && _d !== void 0 ? _d : []);
-                manifestNodesByPackageKey.set(node.key, manifestNode);
-            });
-            return [...manifestNodesByPackageKey.values()];
-        }
-        readManifestFile(importedFileName) {
-            const manifest = (0, yaml_1.parse)(fs.readFileSync(path.resolve(importedFileName + "/manifest.yml"), { encoding: "utf-8" }));
-            return Promise.all(manifest);
-        }
     }
     exports.PackageService = PackageService;
 });

package/core/profile/profile.service.js

@@ -40,18 +40,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         findProfile(profileName) {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.mapCelonisEnvProfile();
-                    this.checkIfMissingProfile(profileName, reject);
                     try {
-                        if (process.env.TEAM_URL && process.env.API_TOKEN) {
-                            resolve(this.buildProfileFromEnvVariables());
-                        }
-                        else {
+                        if (!this.checkIfMissingProfile(profileName)) {
                             const file = fs.readFileSync(path.resolve(this.profileContainerPath, this.constructProfileFileName(profileName)), { encoding: "utf-8" });
                             const profile = JSON.parse(file);
                             this.refreshProfile(profile)
                                 .then(() => resolve(profile));
                         }
+                        else if (process.env.TEAM_URL && process.env.API_TOKEN) {
+                            resolve(this.buildProfileFromEnvVariables());
+                        }
+                        else if (process.env.CELONIS_URL && process.env.CELONIS_API_TOKEN) {
+                            this.mapCelonisEnvProfile();
+                            resolve(this.buildProfileFromEnvVariables());
+                        }
+                        else {
+                            reject(`The profile ${profileName} couldn't be resolved due to missing environment variables.`);
+                        }
                     }
                     catch (e) {
                         reject(`The profile ${profileName} couldn't be resolved.`);
@@ -307,16 +312,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        checkIfMissingProfile(profileName, reject) {
-            if (!profileName && (!process.env.TEAM_URL || !process.env.API_TOKEN)) {
-                reject("Profile not found");
+        checkIfMissingProfile(profileName) {
+            if (!profileName) {
+                return true;
             }
         }
         mapCelonisEnvProfile() {
-            if (!process.env.CELONIS_URL) {
-                return;
+            let celonisUrl = process.env.CELONIS_URL;
+            if (!celonisUrl.startsWith("http://") && !celonisUrl.startsWith("https://")) {
+                celonisUrl = `https://${celonisUrl}`;
             }
-            process.env.TEAM_URL = process.env.CELONIS_URL;
+            process.env.TEAM_URL = celonisUrl;
             if (process.env.CELONIS_API_TOKEN) {
                 process.env.API_TOKEN = process.env.CELONIS_API_TOKEN;
             }

package/core/utils/file-service.js

@@ -63,20 +63,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
             return targetDir;
         }
-        copyDirectoryToCurrentLocation(sourceDir, targetName) {
-            fs.mkdirSync(targetName, { recursive: true });
-            fs.cpSync(sourceDir, targetName, { recursive: true });
-        }
         isDirectory(sourcePath) {
             var _a;
             return (_a = fs.statSync(sourcePath)) === null || _a === void 0 ? void 0 : _a.isDirectory();
         }
         zipDirectoryInBatchExportFormat(sourceDir) {
+            if (fs.lstatSync(sourceDir).isSymbolicLink()) {
+                throw new logger_1.FatalError("Source directory cannot be a symbolic link.");
+            }
             const files = fs.readdirSync(sourceDir);
             const finalZip = new AdmZip();
             files.forEach(file => {
                 const fullPath = path.join(sourceDir, file);
-                const stat = fs.statSync(fullPath);
+                const stat = fs.lstatSync(fullPath);
                 if (stat.isDirectory()) {
                     const zip = new AdmZip();
                     zip.addLocalFolder(fullPath);

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

@@ -3,5 +3,6 @@ import { NodeDependencyTransport } from "../interfaces/node-dependency.interface
 export declare class NodeDependencyApi {
     private httpClient;
     constructor(context: Context);
-    findAll(packageKey: string, nodeKey: string, version: string): Promise<NodeDependencyTransport[]>;
+    findAllStaging(packageKey: string, nodeKey: string): Promise<NodeDependencyTransport[]>;
+    findAllByVersion(packageKey: string, nodeKey: string, version: string): Promise<NodeDependencyTransport[]>;
 }

package/lib/commands/studio/command-service/package-command.service.d.ts

@@ -8,6 +8,4 @@ export declare class PackageCommandService {
     pushPackage(spaceKey: string, fileName: string, newKey: string, overwrite: boolean): Promise<void>;
     pushPackages(spaceKey: string): Promise<void>;
     listPackages(jsonResponse: boolean, includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows?: boolean): Promise<void>;
 }

package/lib/commands/studio/module.d.ts

@@ -5,8 +5,6 @@ import { Configurator, IModule } from "../../core/command/module-handler";
 import { Context } from "../../core/command/cli-context";
 declare class Module extends IModule {
     register(context: Context, configurator: Configurator): void;
-    private batchExportPackages;
-    private batchImportPackages;
     private listPackages;
     private listSpaces;
     private listAssets;

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

@@ -1,37 +1,16 @@
 import { Context } from "../../../core/command/cli-context";
 import { PackageDependencyTransport } from "../interfaces/package-manager.interfaces";
 import { BatchExportNodeTransport } from "../interfaces/batch-export-node.interfaces";
-import { ManifestNodeTransport } from "../interfaces/manifest.interface";
 export declare class PackageService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     private packageApi;
-    private nodeApi;
     private packageDependenciesApi;
     private dataModelService;
     private variableService;
-    private spaceService;
     constructor(context: Context);
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows: boolean): Promise<void>;
-    private checkNodeForCircularDependency;
-    private importPackage;
-    private importPackageVersion;
-    private isLatestVersion;
-    private importDependencyPackages;
-    private checkIfPackageVersionHasBeenImported;
-    private createBodyForImport;
-    private getTargetSpaceForExportedPackage;
-    private updateDependencyVersions;
-    publishPackage(packageToImport: ManifestNodeTransport): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
     getNodesWithActiveVersion(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
     getPackagesWithDependencies(draftIdByNodeId: Map<string, string>): Promise<Map<string, PackageDependencyTransport[]>>;
-    private getDependencyPackages;
-    private nodeHasBeenResolvedBefore;
     private exportListOfPackages;
-    private exportPackagesAndAssets;
-    private exportToZip;
-    private exportManifestOfPackages;
-    private readManifestFile;
 }

package/lib/core/utils/file-service.d.ts

@@ -6,7 +6,6 @@ export declare class FileService {
     readFile(filename: string): string;
     extractExportedZipWithNestedZips(zipFile: AdmZip): string;
     extractExportedZipWithNestedZipsToDir(zipFile: AdmZip, targetDir: string): string;
-    copyDirectoryToCurrentLocation(sourceDir: string, targetName: string): void;
     isDirectory(sourcePath: string): boolean;
     zipDirectoryInBatchExportFormat(sourceDir: string): string;
     private getSerializedFileContent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celonis/content-cli",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "CLI Tool to help manage content in Celonis Platform",
   "main": "content-cli.js",
   "bin": {
@@ -53,5 +53,8 @@
       "prettier --write",
       "git add"
     ]
+  },
+  "repository": {
+    "url": "https://github.com/celonis/content-cli"
   }
 }