@celonis/content-cli 0.3.4 → 0.4.1

package/services/file-service.js

@@ -4,19 +4,27 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "fs", "path"], factory);
+        define(["require", "exports", "fs", "path", "yaml"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const fs = require("fs");
     const path = require("path");
+    const YAML = require("yaml");
     class FileService {
         writeToFileWithGivenName(data, filename) {
             fs.writeFileSync(path.resolve(process.cwd(), filename), this.getSerializedFileContent(data), {
                 encoding: "utf-8",
             });
         }
+        createDirectoryWithGivenName(dirName) {
+            fs.mkdirSync(path.resolve(process.cwd(), dirName));
+        }
+        readManifestFile(importedFileName) {
+            const manifest = YAML.parse(fs.readFileSync(path.resolve(importedFileName + "/manifest.yml"), { encoding: "utf-8" }));
+            return Promise.all(manifest);
+        }
         getSerializedFileContent(data) {
             return data;
         }

package/services/http-client-service.v2.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", "../interfaces/profile.interface", "request", "./context.service", "../util/logger"], factory);
+        define(["require", "exports", "../interfaces/profile.interface", "request", "./context.service", "../util/logger", "querystring"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const request = require("request");
     const context_service_1 = require("./context.service");
     const logger_1 = require("../util/logger");
+    const querystring = require("querystring");
     class HttpClientServiceV2 {
         get(url) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -34,9 +35,90 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        postFile(url, body, parameters) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request.post(this.resolveUrl(url) + "?" + querystring.stringify(parameters), this.makeOptions(context_service_1.contextService.getContext().profile, body), (err, res) => {
+                        this.handleResponse(res, resolve, reject);
+                    });
+                }).catch(e => {
+                    throw new logger_1.FatalError(e);
+                });
+            });
+        }
+        post(url, body) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request.post(this.resolveUrl(url), this.makeOptionsJson(context_service_1.contextService.getContext().profile, JSON.stringify(body), "application/json;charset=utf-8"), (err, res) => {
+                        this.handleResponse(res, resolve, reject);
+                    });
+                }).catch(e => {
+                    throw new logger_1.FatalError(e);
+                });
+            });
+        }
+        put(url, body) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request.put(this.resolveUrl(url), this.makeOptionsJson(context_service_1.contextService.getContext().profile, JSON.stringify(body), "application/json;charset=utf-8"), (err, res) => {
+                        this.handleResponse(res, resolve, reject);
+                    });
+                }).catch(e => {
+                    throw new logger_1.FatalError(e);
+                });
+            });
+        }
+        delete(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request.delete(this.resolveUrl(url), this.makeOptionsJson(context_service_1.contextService.getContext().profile, "application/json;charset=utf-8"), (err, res) => {
+                        this.handleResponse(res, resolve, reject);
+                    });
+                }).catch(e => {
+                    throw new logger_1.FatalError(e);
+                });
+            });
+        }
+        downloadFile(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request
+                        .post(this.resolveUrl(url), this.makeFileDownloadOptions(context_service_1.contextService.getContext().profile))
+                        .on("response", (response) => {
+                        const data = [];
+                        response.on("data", (chunk) => {
+                            data.push(chunk);
+                        });
+                        response.on("end", () => {
+                            if (this.checkBadRequest(response.statusCode)) {
+                                this.handleBadRequest(response.statusCode, data.toString(), reject);
+                            }
+                            else {
+                                this.handleResponseStreamData(Buffer.concat(data), resolve, reject);
+                            }
+                        });
+                    })
+                        .on("error", error => reject(error));
+                });
+            });
+        }
+        handleResponseStreamData(data, resolve, reject) {
+            if (data) {
+                resolve(data);
+                return;
+            }
+            logger_1.logger.error("Could not get file stream from response");
+            reject();
+        }
         resolveUrl(url) {
             return context_service_1.contextService.getContext().profile.team.replace(/\/?$/, url);
         }
+        makeFileDownloadOptions(profile) {
+            return {
+                headers: this.buildAuthorizationHeaders(profile),
+                responseType: "binary",
+            };
+        }
         handleResponse(res, resolve, reject) {
             if (this.checkBadRequest(res.statusCode)) {
                 this.handleBadRequest(res.statusCode, res.body, reject);
@@ -72,11 +154,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             };
             return Object.assign(options, body);
         }
-        buildAuthorizationHeaders(profile) {
+        makeOptionsJson(profile, body, contentType) {
+            return {
+                headers: this.buildAuthorizationHeaders(profile, contentType),
+                body: body
+            };
+        }
+        buildAuthorizationHeaders(profile, contentType) {
             const authenticationType = profile.authenticationType || profile_interface_1.AuthenticationType.BEARER;
             return {
                 authorization: `${authenticationType} ${profile.apiToken}`,
-                "content-type": "application/json",
+                "content-type": contentType !== null && contentType !== void 0 ? contentType : "application/json",
             };
         }
     }

package/services/package-manager/datamodel-service.js

@@ -22,14 +22,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     class DatamodelService {
         getDatamodelsForNodes(nodesListToExport) {
             return __awaiter(this, void 0, void 0, function* () {
-                const promises = [];
-                nodesListToExport.forEach(node => {
-                    promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                        node.datamodels = yield compute_pool_api_1.computePoolApi.findAssignedDatamodels(node.key);
-                        resolve(node);
-                    })));
-                });
-                return Promise.all(promises);
+                const dataModelsMap = new Map();
+                for (const node of nodesListToExport) {
+                    const assignedDataModels = yield compute_pool_api_1.computePoolApi.findAssignedDatamodels(node.key);
+                    dataModelsMap.set(node.key, assignedDataModels);
+                }
+                return dataModelsMap;
             });
         }
     }

package/services/package-manager/package-service.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", "../../util/logger", "../../api/package-api", "uuid", "../file-service", "./datamodel-service", "../../api/node-api", "../../api/package-dependencies-api"], factory);
+        define(["require", "exports", "../../util/logger", "../../api/package-api", "uuid", "../file-service", "./datamodel-service", "../../api/node-api", "../../api/package-dependencies-api", "./variable-service", "./space-service", "yaml", "fs", "adm-zip", "path", "os"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -25,6 +25,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const datamodel_service_1 = require("./datamodel-service");
     const node_api_1 = require("../../api/node-api");
     const package_dependencies_api_1 = require("../../api/package-dependencies-api");
+    const variable_service_1 = require("./variable-service");
+    const space_service_1 = require("./space-service");
+    const YAML = require("yaml");
+    const fs = require("fs");
+    const AdmZip = require("adm-zip");
+    const path = require("path");
+    const os_1 = require("os");
     class PackageService {
         constructor() {
             this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
@@ -37,73 +44,363 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        findAndExportAllPackages(includeDependencies) {
+        findAndExportListOfAllPackages(includeDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
                 const fieldsToInclude = ["key", "name", "changeDate", "activatedDraftId", "spaceId"];
                 let nodesListToExport = yield package_api_1.packageApi.findAllPackages();
                 if (includeDependencies) {
-                    fieldsToInclude.push("type", "value", "dependencies", "id", "version", "poolId", "node", "dataModelId", "dataPool", "datamodels");
+                    fieldsToInclude.push("type", "value", "dependencies", "id", "updateAvailable", "version", "poolId", "node", "dataModelId", "dataPool", "datamodels");
                     const packagesKeyWithActionFlows = (yield node_api_1.nodeApi.findAllNodesOfType("SCENARIO")).map(node => node.rootNodeKey);
                     nodesListToExport = nodesListToExport.filter(node => {
                         return !packagesKeyWithActionFlows.includes(node.rootNodeKey);
                     });
-                    //TODO need to replace all these individual calls with a single api call that gets all the required data.
-                    nodesListToExport = yield this.getVersionOfPackages(nodesListToExport);
-                    nodesListToExport = yield datamodel_service_1.dataModelService.getDatamodelsForNodes(nodesListToExport);
-                    const draftIdByNodeId = new Map();
-                    const nodeIds = nodesListToExport.map(node => {
-                        draftIdByNodeId.set(node.id, node.workingDraftId);
-                        return node.id;
+                    const unPublishedNodes = nodesListToExport.filter(node => !node.activatedDraftId);
+                    let publishedNodes = nodesListToExport.filter(node => node.activatedDraftId);
+                    publishedNodes = yield this.getNodesWithActiveVersion(publishedNodes);
+                    nodesListToExport = [...publishedNodes, ...unPublishedNodes];
+                    const dataModelAssignments = yield datamodel_service_1.dataModelService.getDatamodelsForNodes(nodesListToExport);
+                    nodesListToExport.forEach(node => {
+                        node.datamodels = dataModelAssignments.get(node.key);
                     });
-                    const dependenciesByPackageId = yield this.getPackagesDependenciesByPackageId(nodeIds, draftIdByNodeId);
+                    const draftIdByNodeId = new Map();
+                    nodesListToExport.forEach(node => draftIdByNodeId.set(node.workingDraftId, node.id));
+                    const dependenciesByPackageIds = yield this.getPackagesWithDependencies(draftIdByNodeId, packagesKeyWithActionFlows);
                     nodesListToExport = nodesListToExport.map(nodeToExport => {
-                        nodeToExport.dependencies = dependenciesByPackageId.get(nodeToExport.id);
+                        var _a;
+                        nodeToExport.dependencies = (_a = dependenciesByPackageIds[nodeToExport.workingDraftId]) !== null && _a !== void 0 ? _a : [];
                         return nodeToExport;
                     });
                 }
                 this.exportListOfPackages(nodesListToExport, fieldsToInclude);
             });
         }
-        getPackagesDependenciesByPackageId(nodeIds, draftIdByNodeId) {
+        batchImportPackages(spaceMappings, exportedPackagesFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                exportedPackagesFile = exportedPackagesFile + (exportedPackagesFile.includes(".zip") ? "" : ".zip");
+                const zip = new AdmZip(exportedPackagesFile);
+                const importedFilePath = path.resolve(os_1.tmpdir(), "export_" + uuid_1.v4());
+                yield fs.mkdirSync(importedFilePath);
+                yield zip.extractAllTo(importedFilePath);
+                const manifestNodes = yield file_service_1.fileService.readManifestFile(importedFilePath);
+                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, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath);
+                }
+            });
+        }
+        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, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath) {
+            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) => this.compareVersions(k1, k2)).filter(version => !importedPackageVersion.includes(version));
+                for (const version of versionsOfPackage) {
+                    yield this.importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, version);
+                }
+            });
+        }
+        compareVersions(version1, version2) {
+            const splitVersion1 = version1.split(".");
+            const splitVersion2 = version2.split(".");
+            const majorVersion1 = splitVersion1[0];
+            const majorVersion2 = splitVersion2[0];
+            const minorVersion1 = splitVersion1[1];
+            const minorVersion2 = splitVersion2[1];
+            const patchVersion1 = splitVersion1[2];
+            const patchVersion2 = splitVersion2[2];
+            const firstVersionIsGreaterThanFirst = (majorVersion1 > majorVersion2) || (minorVersion1 > minorVersion2) || (patchVersion1 > patchVersion2);
+            return firstVersionIsGreaterThanFirst ? 1 : -1;
+        }
+        importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, versionOfPackageBeingImported) {
+            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, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath);
+                }
+                if (this.checkIfPackageVersionHasBeenImported(packageToImport.packageKey, versionOfPackageBeingImported, importedVersionsByNodeKey)) {
+                    return;
+                }
+                const targetSpace = yield this.getTargetSpaceForExportedPackage(packageToImport, spaceMappings);
+                let nodeInTargetTeam = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
+                const pathToZipFile = path.resolve(importedFilePath, packageToImport.packageKey + "_" + versionOfPackageBeingImported + ".zip");
+                const packageZip = yield this.createBodyForImport(pathToZipFile);
+                yield package_api_1.packageApi.importPackage(packageZip, targetSpace.id, !!nodeInTargetTeam);
+                if (nodeInTargetTeam) {
+                    yield package_api_1.packageApi.movePackageToSpace(nodeInTargetTeam.id, targetSpace.id);
+                }
+                nodeInTargetTeam = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
+                draftIdsByPackageKeyAndVersion.set(`${nodeInTargetTeam.key}_${versionOfPackageBeingImported}`, nodeInTargetTeam.workingDraftId);
+                yield this.updateDependencyVersions(packageToImport, versionOfPackageBeingImported, sourceToTargetVersionsByNodeKey, draftIdsByPackageKeyAndVersion);
+                yield this.publishPackage(packageToImport);
+                const packageVersionInTargetTeam = yield package_api_1.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}`);
+            });
+        }
+        importDependencyPackages(dependenciesToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath) {
+            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, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath);
+                }
+            });
+        }
+        checkIfPackageVersionHasBeenImported(packageKey, version, importedVersions) {
+            var _a;
+            const importedPackages = (_a = importedVersions.get(packageKey)) !== null && _a !== void 0 ? _a : [];
+            return importedPackages.includes(version);
+        }
+        createBodyForImport(filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return {
+                    formData: {
+                        package: yield fs.createReadStream(filename, { encoding: null })
+                    },
+                };
+            });
+        }
+        getTargetSpaceForExportedPackage(packageToImport, spaceMappings) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let targetSpace;
+                const allSpaces = yield space_service_1.spaceService.getAllSpaces();
+                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 space_service_1.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 node_api_1.nodeApi.findOneByKeyAndRootNodeKey(node.packageKey, node.packageKey);
+                const newDependencies = [];
+                for (const dependency of [...node.dependenciesByVersion.get(versionOfPackage)]) {
+                    const nodeInTargetTeam = yield node_api_1.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 package_dependencies_api_1.packageDependenciesApi.deleteDependency(createdNode.id, dependency.key);
+                }
+                if (newDependencies.length) {
+                    yield package_dependencies_api_1.packageDependenciesApi.createDependencies(createdNode.id, newDependencies);
+                }
+            });
+        }
+        publishPackage(packageToImport) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodeInTargetTeam = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageToImport.packageKey, packageToImport.packageKey);
+                const nextVersion = yield package_api_1.packageApi.findNextVersion(nodeInTargetTeam.id);
+                yield package_api_1.packageApi.publishPackage({
+                    packageKey: packageToImport.packageKey,
+                    version: nextVersion.version,
+                    publishMessage: "Published package after import",
+                    nodeIdsToExclude: []
+                });
+            });
+        }
+        batchExportPackages(packageKeys, includeDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
-                const dependenciesByPackageId = new Map();
-                const packageWithDependencies = yield this.getPackagesWithDependencies(nodeIds, draftIdByNodeId);
-                packageWithDependencies.forEach(packageWithDependency => {
+                const allPackages = yield package_api_1.packageApi.findAllPackages();
+                let nodesListToExport = allPackages.filter(node => packageKeys.includes(node.key));
+                const actionFlowsPackageKeys = (yield node_api_1.nodeApi.findAllNodesOfType("SCENARIO")).map(node => node.rootNodeKey);
+                nodesListToExport = nodesListToExport.filter(node => !actionFlowsPackageKeys.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, actionFlowsPackageKeys, [], versionsByNodeKey);
+                    nodesListToExport.push(...dependencyPackages);
+                }
+                const variableAssignments = yield variable_service_1.variableService.getVariableAssignmentsForNodes(nodesListToExport);
+                nodesListToExport.forEach(node => {
                     var _a;
-                    const dependenciesOfPackage = (_a = dependenciesByPackageId.get(packageWithDependency.rootNodeId)) !== null && _a !== void 0 ? _a : [];
-                    dependenciesOfPackage.push(packageWithDependency);
-                    dependenciesByPackageId.set(packageWithDependency === null || packageWithDependency === void 0 ? void 0 : packageWithDependency.rootNodeId, dependenciesOfPackage);
+                    node.variables = (_a = variableAssignments.find(nodeWithVariablesAssignment => nodeWithVariablesAssignment.key === node.key)) === null || _a === void 0 ? void 0 : _a.variableAssignments;
+                });
+                const dataModelAssignments = yield datamodel_service_1.dataModelService.getDatamodelsForNodes(nodesListToExport);
+                nodesListToExport.forEach(node => {
+                    node.datamodels = dataModelAssignments.get(node.key);
                 });
-                return dependenciesByPackageId;
+                nodesListToExport = yield space_service_1.spaceService.getParentSpaces(nodesListToExport);
+                yield this.exportToZip(nodesListToExport, versionsByNodeKey);
             });
         }
-        getVersionOfPackages(nodes) {
+        getNodesWithActiveVersion(nodes) {
             return __awaiter(this, void 0, void 0, function* () {
-                const promises = [];
+                const activeVersionsOfPackage = yield package_api_1.packageApi.findActiveVersionByIds(nodes.map(node => node.id));
                 nodes.forEach(node => {
-                    promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                        node.version = yield package_api_1.packageApi.findLatestVersionById(node.id);
-                        resolve(node);
-                    })));
+                    node.version = activeVersionsOfPackage.find(packageVersion => packageVersion.id === node.id);
+                });
+                return nodes;
+            });
+        }
+        getPackagesWithDependencies(draftIdByNodeId, actionFlowPackageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const allPackageDependencies = yield package_dependencies_api_1.packageDependenciesApi.findPackageDependenciesByIds(draftIdByNodeId);
+                Object.values(allPackageDependencies).forEach((value, key) => {
+                    value = value.filter((dependency => actionFlowPackageKeys.includes(dependency.key)));
                 });
-                return Promise.all(promises);
+                return allPackageDependencies;
             });
         }
-        getPackagesWithDependencies(nodeIds, draftIdByNodeId) {
+        getDependencyPackages(nodesToResolve, dependencyPackages, allPackages, actionFlowPackageKeys, resolvedDependencies, versionsByNodeKey) {
             return __awaiter(this, void 0, void 0, function* () {
-                const promises = [];
-                nodeIds.forEach((nodeId) => __awaiter(this, void 0, void 0, function* () { return promises.push(package_dependencies_api_1.packageDependenciesApi.findDependenciesOfPackage(nodeId, draftIdByNodeId.get(nodeId))); }));
-                const results = yield Promise.all(promises);
-                const dependencies = [];
-                results.forEach(result => dependencies.push(...result));
-                return dependencies;
+                const draftIdByNodeId = new Map();
+                nodesToResolve.forEach(node => draftIdByNodeId.set(node.activatedDraftId, node.id));
+                const dependenciesByPackageDraftIds = yield this.getPackagesWithDependencies(draftIdByNodeId, actionFlowPackageKeys);
+                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, actionFlowPackageKeys, resolvedDependencies, versionsByNodeKey);
+                    }
+                }
+                return dependencyPackages;
             });
         }
+        nodeHasBeenResolvedBefore(nodePath, nodeKey, version) {
+            return nodePath.includes(nodeKey + ":" + version);
+        }
         exportListOfPackages(nodes, fieldsToInclude) {
             const filename = 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) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const zips = [];
+                for (const rootPackage of nodes) {
+                    const exportedPackage = yield package_api_1.packageApi.exportPackage(rootPackage.key, rootPackage.version.version);
+                    zips.push({
+                        data: exportedPackage,
+                        packageKey: rootPackage.key,
+                        version: rootPackage.version.version
+                    });
+                }
+                return zips;
+            });
+        }
+        exportToZip(nodes, versionsByNodeKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const manifestNodes = this.exportManifestOfPackages(nodes, versionsByNodeKey);
+                const packageZips = yield this.exportPackagesAndAssets(nodes);
+                const zip = new AdmZip();
+                zip.addFile("manifest.yml", Buffer.from(YAML.stringify(manifestNodes), "utf8"));
+                for (const packageZip of packageZips) {
+                    zip.addFile(`${packageZip.packageKey}_${packageZip.version}.zip`, packageZip.data);
+                }
+                const fileName = "export_" + 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 === "DATA_MODEL") {
+                        // @ts-ignore
+                        const dataModel = (_a = node.datamodels) === null || _a === void 0 ? void 0 : _a.find(dataModel => dataModel.node.dataModelId === variable.value);
+                        return {
+                            key: variable.key,
+                            type: variable.type,
+                            value: variable.value,
+                            dataModelName: dataModel === null || dataModel === void 0 ? void 0 : dataModel.node.name,
+                            dataPoolName: dataModel === null || dataModel === void 0 ? void 0 : dataModel.dataPool.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()];
+        }
     }
     exports.packageService = new PackageService();
 });