@celonis/content-cli 0.6.1 → 0.8.0

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

@@ -0,0 +1,25 @@
+import { PackageExportTransport, StudioPackageManifest, VariableManifestTransport } from "../../interfaces/package-export-transport";
+import { ContentNodeTransport } from "../../interfaces/package-manager.interfaces";
+import { IZipEntry } from "adm-zip";
+import * as AdmZip from "adm-zip";
+declare class StudioService {
+    getExportPackagesWithStudioData(packagesToExport: PackageExportTransport[], withDependencies: boolean): Promise<PackageExportTransport[]>;
+    fixConnectionVariables(variables: VariableManifestTransport[]): VariableManifestTransport[];
+    getStudioPackageManifests(studioPackageKeys: string[]): Promise<StudioPackageManifest[]>;
+    processPackageForExport(exportedPackage: IZipEntry, exportedVariables: VariableManifestTransport[]): AdmZip;
+    processImportedPackages(configs: AdmZip, existingStudioPackages: ContentNodeTransport[], studioManifests: StudioPackageManifest[]): Promise<void>;
+    private setSpaceIdForStudioPackages;
+    private setDataModelsForStudioPackages;
+    private fixConnectionVariable;
+    private deleteScenarioAssets;
+    private fixConnectionVariablesForRootNodeFiles;
+    private getPackageKeyAndVersion;
+    private getConnectionVariablesByKeyForPackage;
+    mapSpaces(exportedFiles: AdmZip, studioManifests: StudioPackageManifest[]): Promise<AdmZip>;
+    private isStudioPackage;
+    private findDesiredSpaceIdForPackage;
+    private assignRuntimeVariables;
+    private updateSpaceIdForNode;
+}
+export declare const studioService: StudioService;
+export {};

package/package.json

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

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", "./context.service", "../util/logger", "../util/tracing", "../util/version", "axios", "form-data"], factory);
+        define(["require", "exports", "../interfaces/profile.interface", "./context.service", "../util/logger", "../util/tracing", "../util/version", "axios"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -25,7 +25,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const tracing_1 = require("../util/tracing");
     const version_1 = require("../util/version");
     const axios_1 = require("axios");
-    const FormData = require("form-data");
     class HttpClientServiceV2 {
         get(url) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -42,11 +41,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        postFile(url, body, parameters) {
+        getFile(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    axios_1.default.get(this.resolveUrl(url), {
+                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile),
+                        responseType: "stream",
+                        validateStatus: status => status >= 200
+                    }).then(response => {
+                        const data = [];
+                        response.data.on("data", (chunk) => {
+                            data.push(chunk);
+                        });
+                        response.data.on("end", () => {
+                            if (response.status !== 200) {
+                                reject(Buffer.concat(data).toString());
+                                return;
+                            }
+                            this.handleResponseStreamData(Buffer.concat(data), resolve, reject);
+                        });
+                    }).catch(err => {
+                        this.handleError(err, resolve, reject);
+                    });
+                });
+            });
+        }
+        postFile(url, formData, parameters) {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    const formData = new FormData();
-                    formData.append("package", body.formData.package);
                     axios_1.default.post(this.resolveUrl(url), formData, {
                         headers: Object.assign(Object.assign({}, this.buildHeaders(context_service_1.contextService.getContext().profile, "multipart/form-data")), formData.getHeaders()),
                         params: parameters

package/services/package-manager/batch-import-export-service.js

@@ -0,0 +1,151 @@
+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/batch-import-export-api", "../../util/logger", "uuid", "../file-service", "../studio/studio.service", "../../util/yaml", "form-data", "../../interfaces/batch-export-import-constants", "../../api/package-api", "stream", "adm-zip"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.batchImportExportService = void 0;
+    const batch_import_export_api_1 = require("../../api/batch-import-export-api");
+    const logger_1 = require("../../util/logger");
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../file-service");
+    const studio_service_1 = require("../studio/studio.service");
+    const yaml_1 = require("../../util/yaml");
+    const FormData = require("form-data");
+    const batch_export_import_constants_1 = require("../../interfaces/batch-export-import-constants");
+    const package_api_1 = require("../../api/package-api");
+    const stream_1 = require("stream");
+    const AdmZip = require("adm-zip");
+    class BatchImportExportService {
+        listActivePackages(flavors) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const activePackages = yield batch_import_export_api_1.batchImportExportApi.findAllActivePackages(flavors);
+                activePackages.forEach(pkg => {
+                    logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
+                });
+            });
+        }
+        findAndExportListOfActivePackages(flavors, packageKeys, withDependencies) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let packagesToExport;
+                if (packageKeys.length) {
+                    packagesToExport = yield batch_import_export_api_1.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
+                }
+                else {
+                    packagesToExport = yield batch_import_export_api_1.batchImportExportApi.findAllActivePackages(flavors, withDependencies);
+                }
+                packagesToExport = yield studio_service_1.studioService.getExportPackagesWithStudioData(packagesToExport, withDependencies);
+                this.exportListOfPackages(packagesToExport);
+            });
+        }
+        batchExportPackages(packageKeys, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const exportedPackagesData = yield batch_import_export_api_1.batchImportExportApi.exportPackages(packageKeys, withDependencies);
+                const exportedPackagesZip = new AdmZip(exportedPackagesData);
+                const manifest = (0, yaml_1.parse)(exportedPackagesZip.getEntry(batch_export_import_constants_1.BatchExportImportConstants.MANIFEST_FILE_NAME).getData().toString());
+                const versionsByPackageKey = this.getVersionsByPackageKey(manifest);
+                let exportedVariables = yield this.getVersionedVariablesForPackagesWithKeys(versionsByPackageKey);
+                exportedVariables = studio_service_1.studioService.fixConnectionVariables(exportedVariables);
+                exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME, Buffer.from((0, yaml_1.stringify)(exportedVariables), "utf8"));
+                const studioPackageKeys = manifest.filter(packageManifest => packageManifest.flavor === batch_export_import_constants_1.BatchExportImportConstants.STUDIO)
+                    .map(packageManifest => packageManifest.packageKey);
+                const studioData = yield studio_service_1.studioService.getStudioPackageManifests(studioPackageKeys);
+                exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.STUDIO_FILE_NAME, Buffer.from((0, yaml_1.stringify)(studioData), "utf8"));
+                exportedPackagesZip.getEntries().forEach(entry => {
+                    if (entry.name.endsWith(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION)) {
+                        const lastUnderscoreIndex = entry.name.lastIndexOf("_");
+                        const packageKey = entry.name.substring(0, lastUnderscoreIndex);
+                        if (studioPackageKeys.includes(packageKey)) {
+                            const updatedPackage = studio_service_1.studioService.processPackageForExport(entry, exportedVariables);
+                            exportedPackagesZip.updateFile(entry, updatedPackage.toBuffer());
+                        }
+                    }
+                });
+                const fileDownloadedMessage = "File downloaded successfully. New filename: ";
+                const filename = `export_${(0, uuid_1.v4)()}.zip`;
+                exportedPackagesZip.writeZip(filename);
+                logger_1.logger.info(fileDownloadedMessage + filename);
+            });
+        }
+        batchImportPackages(file, overwrite) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let configs = new AdmZip(file);
+                const studioManifests = this.parseEntryData(configs, batch_export_import_constants_1.BatchExportImportConstants.STUDIO_FILE_NAME);
+                const variablesManifests = this.parseEntryData(configs, batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME);
+                configs = yield studio_service_1.studioService.mapSpaces(configs, studioManifests);
+                const existingStudioPackages = yield package_api_1.packageApi.findAllPackages();
+                const formData = this.buildBodyForImport(configs, variablesManifests);
+                const postPackageImportData = yield batch_import_export_api_1.batchImportExportApi.importPackages(formData, overwrite);
+                yield studio_service_1.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
+                const reportFileName = "config_import_report_" + (0, uuid_1.v4)() + ".json";
+                file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(postPackageImportData), reportFileName);
+                logger_1.logger.info("Config import report file: " + reportFileName);
+            });
+        }
+        exportListOfPackages(packages) {
+            const filename = (0, uuid_1.v4)() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(packages), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+        getVersionsByPackageKey(manifests) {
+            const versionsByPackageKey = new Map();
+            manifests.forEach(packageManifest => {
+                versionsByPackageKey.set(packageManifest.packageKey, Object.keys(packageManifest.dependenciesByVersion));
+            });
+            return versionsByPackageKey;
+        }
+        getVersionedVariablesForPackagesWithKeys(versionsByPackageKey) {
+            const variableExportRequest = [];
+            versionsByPackageKey === null || versionsByPackageKey === void 0 ? void 0 : versionsByPackageKey.forEach((versions, key) => {
+                versions === null || versions === void 0 ? void 0 : versions.forEach(version => {
+                    variableExportRequest.push({
+                        packageKey: key,
+                        version: version,
+                    });
+                });
+            });
+            return batch_import_export_api_1.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
+        }
+        buildBodyForImport(configs, variablesManifests) {
+            const formData = new FormData();
+            const readableStream = this.getReadableStream(configs);
+            formData.append("file", readableStream, { filename: "configs.zip" });
+            if (variablesManifests) {
+                formData.append("mappedVariables", JSON.stringify(variablesManifests), {
+                    contentType: "application/json"
+                });
+            }
+            return formData;
+        }
+        getReadableStream(configs) {
+            return new stream_1.Readable({
+                read() {
+                    this.push(configs.toBuffer());
+                    this.push(null);
+                },
+            });
+        }
+        parseEntryData(configs, fileName) {
+            const entry = configs.getEntry(fileName);
+            if (entry) {
+                return ((0, yaml_1.parse)(entry.getData().toString()));
+            }
+            return null;
+        }
+    }
+    exports.batchImportExportService = new BatchImportExportService();
+});

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", "../../interfaces/package-manager.interfaces", "../../api/node-api", "../../api/package-dependencies-api", "./variable-service", "./space-service", "fs", "adm-zip", "path", "os", "../../util/semantic-versioning", "../../util/yaml"], factory);
+        define(["require", "exports", "../../util/logger", "../../api/package-api", "uuid", "../file-service", "./datamodel-service", "../../interfaces/package-manager.interfaces", "../../api/node-api", "../../api/package-dependencies-api", "./variable-service", "./space-service", "fs", "adm-zip", "path", "os", "../../util/semantic-versioning", "../../util/yaml", "form-data"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -35,6 +35,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const os_1 = require("os");
     const semantic_versioning_1 = require("../../util/semantic-versioning");
     const yaml_1 = require("../../util/yaml");
+    const FormData = require("form-data");
     class PackageService {
         constructor() {
             this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
@@ -56,8 +57,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
                 if (includeDependencies) {
                     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 => !packagesKeyWithActionFlows.includes(node.rootNodeKey));
                     const unPublishedNodes = nodesListToExport.filter(node => !node.activatedDraftId);
                     let publishedNodes = nodesListToExport.filter(node => node.activatedDraftId);
                     publishedNodes = yield this.getNodesWithActiveVersion(publishedNodes);
@@ -69,7 +68,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     });
                     const draftIdByNodeId = new Map();
                     nodesListToExport.forEach(node => draftIdByNodeId.set(node.workingDraftId, node.id));
-                    const dependenciesByPackageIds = yield this.getPackagesWithDependencies(draftIdByNodeId, packagesKeyWithActionFlows);
+                    const dependenciesByPackageIds = yield this.getPackagesWithDependencies(draftIdByNodeId);
                     nodesListToExport = nodesListToExport.map(nodeToExport => {
                         var _a;
                         nodeToExport.dependencies = (_a = dependenciesByPackageIds[nodeToExport.workingDraftId]) !== null && _a !== void 0 ? _a : [];
@@ -79,7 +78,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.exportListOfPackages(nodesListToExport, fieldsToInclude);
             });
         }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite) {
+        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);
@@ -118,7 +117,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
                 const draftIdsByPackageKeyAndVersion = new Map();
                 for (const node of manifestNodes) {
-                    yield this.importPackage(node, manifestNodes, sourceToTargetVersionsByNodeKey, customSpacesMap, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath);
+                    yield this.importPackage(node, manifestNodes, sourceToTargetVersionsByNodeKey, customSpacesMap, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
                 }
             });
         }
@@ -135,7 +134,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        importPackage(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath) {
+        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 : [];
@@ -146,7 +145,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }).filter(version => !importedPackageVersion.includes(version));
                 for (const version of versionsOfPackage) {
                     try {
-                        yield this.importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, version);
+                        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}`);
@@ -154,12 +153,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        importPackageVersion(packageToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, versionOfPackageBeingImported) {
+        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);
+                    yield this.importDependencyPackages(dependenciesOfPackageVersion, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
                 }
                 if (this.checkIfPackageVersionHasBeenImported(packageToImport.packageKey, versionOfPackageBeingImported, importedVersionsByNodeKey)) {
                     return;
@@ -167,8 +166,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 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);
+                const packageZip = this.createBodyForImport(pathToZipFile);
+                yield package_api_1.packageApi.importPackage(packageZip, targetSpace.id, !!nodeInTargetTeam, excludeActionFlows);
                 if (nodeInTargetTeam) {
                     yield package_api_1.packageApi.movePackageToSpace(nodeInTargetTeam.id, targetSpace.id);
                 }
@@ -213,14 +212,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
             return isLatestVersion;
         }
-        importDependencyPackages(dependenciesToImport, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath) {
+        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);
+                    yield this.importPackage(dependentPackage, manifestNodes, sourceToTargetVersionsByNodeKey, spaceMappings, dmTargetIdsBySourceIds, importedVersionsByNodeKey, draftIdsByPackageKeyAndVersion, importedFilePath, excludeActionFlows);
                 }
             });
         }
@@ -230,13 +229,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return importedPackages.includes(version);
         }
         createBodyForImport(filename) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return {
-                    formData: {
-                        package: yield fs.createReadStream(filename, { encoding: null })
-                    },
-                };
-            });
+            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* () {
@@ -291,12 +286,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        batchExportPackages(packageKeys, includeDependencies) {
+        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 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) {
@@ -306,7 +299,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
                 nodesListToExport = yield this.getNodesWithActiveVersion(nodesListToExport);
                 if (includeDependencies) {
-                    const dependencyPackages = yield this.getDependencyPackages(nodesListToExport, [], allPackages, actionFlowsPackageKeys, [], versionsByNodeKey);
+                    const dependencyPackages = yield this.getDependencyPackages(nodesListToExport, [], allPackages, [], versionsByNodeKey);
                     nodesListToExport.push(...dependencyPackages);
                 }
                 const packagesWithVariableAssignments = yield variable_service_1.variableService.getVariableAssignmentsForNodes();
@@ -323,7 +316,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     node.datamodels = dataModelDetailsByNode.get(node.key);
                 });
                 nodesListToExport = yield space_service_1.spaceService.getParentSpaces(nodesListToExport);
-                yield this.exportToZip(nodesListToExport, versionsByNodeKey);
+                yield this.exportToZip(nodesListToExport, versionsByNodeKey, excludeActionFlows);
             });
         }
         getNodesWithActiveVersion(nodes) {
@@ -335,20 +328,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return nodes;
             });
         }
-        getPackagesWithDependencies(draftIdByNodeId, actionFlowPackageKeys) {
+        getPackagesWithDependencies(draftIdByNodeId) {
             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 allPackageDependencies;
             });
         }
-        getDependencyPackages(nodesToResolve, dependencyPackages, allPackages, actionFlowPackageKeys, resolvedDependencies, versionsByNodeKey) {
+        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, actionFlowPackageKeys);
+                const dependenciesByPackageDraftIds = yield this.getPackagesWithDependencies(draftIdByNodeId);
                 const nodesWithDependencies = nodesToResolve.map(nodeToExport => {
                     var _a;
                     nodeToExport.dependencies = (_a = dependenciesByPackageDraftIds[nodeToExport.activatedDraftId]) !== null && _a !== void 0 ? _a : [];
@@ -375,7 +365,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                                 }, activatedDraftId: versionedDep.draftId });
                         });
                         dependencyPackages.push(...dependencyPackagesOfNode);
-                        yield this.getDependencyPackages(dependencyPackagesOfNode, dependencyPackages, allPackages, actionFlowPackageKeys, resolvedDependencies, versionsByNodeKey);
+                        yield this.getDependencyPackages(dependencyPackagesOfNode, dependencyPackages, allPackages, resolvedDependencies, versionsByNodeKey);
                     }
                 }
                 return dependencyPackages;
@@ -389,11 +379,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes, fieldsToInclude), filename);
             logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
         }
-        exportPackagesAndAssets(nodes) {
+        exportPackagesAndAssets(nodes, excludeActionFlows) {
             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);
+                    const exportedPackage = yield package_api_1.packageApi.exportPackage(rootPackage.key, rootPackage.version.version, excludeActionFlows);
                     zips.push({
                         data: exportedPackage,
                         packageKey: rootPackage.key,
@@ -403,10 +393,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return zips;
             });
         }
-        exportToZip(nodes, versionsByNodeKey) {
+        exportToZip(nodes, versionsByNodeKey, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 const manifestNodes = this.exportManifestOfPackages(nodes, versionsByNodeKey);
-                const packageZips = yield this.exportPackagesAndAssets(nodes);
+                const packageZips = yield this.exportPackagesAndAssets(nodes, excludeActionFlows);
                 const zip = new AdmZip();
                 zip.addFile("manifest.yml", Buffer.from((0, yaml_1.stringify)(manifestNodes), "utf8"));
                 for (const packageZip of packageZips) {

package/services/package-manager/variable-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", "../../api/package-api", "../../api/variables-api", "uuid", "../../util/logger", "../file-service", "url"], factory);
+        define(["require", "exports", "../../api/package-api", "../../api/variables-api", "uuid", "../../util/logger", "../file-service", "url", "../studio/studio.service", "../../api/batch-import-export-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -25,6 +25,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const logger_1 = require("../../util/logger");
     const file_service_1 = require("../file-service");
     const url_1 = require("url");
+    const studio_service_1 = require("../studio/studio.service");
+    const batch_import_export_api_1 = require("../../api/batch-import-export-api");
     class VariableService {
         getVariableAssignmentsForNodes(type) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -49,9 +51,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 const parsedParams = this.parseParams(params);
                 const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
-                const filename = (0, uuid_1.v4)() + ".json";
-                file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(assignments), filename);
-                logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+                this.exportToJson(assignments);
+            });
+        }
+        listVariables(keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const variableManifests = yield this.getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile);
+                variableManifests.forEach(variableManifest => {
+                    logger_1.logger.info(JSON.stringify(variableManifest));
+                });
+            });
+        }
+        exportVariables(keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const variableManifests = yield this.getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile);
+                this.exportToJson(variableManifests);
             });
         }
         parseParams(params) {
@@ -69,6 +83,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
             return queryParams;
         }
+        getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const variablesExportRequest = yield this.buildKeyVersionPairs(keysByVersion, keysByVersionFile);
+                const variableManifests = yield batch_import_export_api_1.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variablesExportRequest);
+                return studio_service_1.studioService.fixConnectionVariables(variableManifests);
+            });
+        }
+        buildKeyVersionPairs(keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let variablesExportRequest = [];
+                if (keysByVersion.length !== 0) {
+                    variablesExportRequest = this.buildKeyAndVersionPairsFromArrayInput(keysByVersion);
+                }
+                else if (keysByVersion.length === 0 && keysByVersionFile !== "") {
+                    variablesExportRequest = yield file_service_1.fileService.readFileToJson(keysByVersionFile);
+                }
+                else {
+                    throw new logger_1.FatalError("Please provide keysByVersion mappings or file path!");
+                }
+                return variablesExportRequest;
+            });
+        }
+        buildKeyAndVersionPairsFromArrayInput(keysByVersion) {
+            return keysByVersion.map(keyAndVersion => {
+                const keyAndVersionSplit = keyAndVersion.split(":");
+                return {
+                    packageKey: keyAndVersionSplit[0],
+                    version: keyAndVersionSplit[1]
+                };
+            });
+        }
+        exportToJson(data) {
+            const filename = (0, uuid_1.v4)() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(data), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
     }
     exports.variableService = new VariableService();
 });