@celonis/content-cli 0.6.1 → 0.7.0

package/api/batch-import-export-api.js

@@ -0,0 +1,35 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../services/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.batchImportExportApi = void 0;
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class BatchImportExportApi {
+        findAllActivePackages(flavors, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            queryParams.set("withDependencies", withDependencies.toString());
+            flavors.forEach(flavor => queryParams.append("flavors", flavor));
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/core/packages/export/list?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting active packages: ${e}`);
+            });
+        }
+        findActivePackagesByKeys(packageKeys, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            packageKeys.forEach(key => queryParams.append("packageKeys", key));
+            queryParams.set("withDependencies", withDependencies.toString());
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/core/packages/export/list-by-keys?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting active packages by keys: ${e}`);
+            });
+        }
+    }
+    BatchImportExportApi.INSTANCE = new BatchImportExportApi();
+    exports.batchImportExportApi = BatchImportExportApi.INSTANCE;
+});

package/api/package-api.js

@@ -29,11 +29,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        exportPackage(rootPackageKey, version) {
+        exportPackage(rootPackageKey, version, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("newKey", rootPackageKey);
                 queryParams.set("version", version !== null && version !== void 0 ? version : "");
+                queryParams.set("excludeActionFlows", excludeActionFlows ? "true" : "false");
                 return yield http_client_service_v2_1.httpClientV2.downloadFile(`/package-manager/api/packages/${rootPackageKey}/export?${queryParams.toString()}`).catch(e => {
                     throw new logger_1.FatalError(`Pacakge ${rootPackageKey}_${version} failed to export.`);
                 });
@@ -78,11 +79,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        importPackage(nodeContent, spaceId, overwrite) {
+        importPackage(nodeContent, spaceId, overwrite, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 yield http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/packages/import", nodeContent, {
                     spaceId: spaceId,
-                    overwrite: overwrite
+                    overwrite: overwrite,
+                    excludeActionFlows: excludeActionFlows
                 }).catch(e => {
                     throw new logger_1.FatalError(`Problem importing package: ${e}`);
                 });

package/commands/config.command.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../services/package-manager/batch-import-export-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConfigCommand = void 0;
+    const batch_import_export_service_1 = require("../services/package-manager/batch-import-export-service");
+    class ConfigCommand {
+        listActivePackages(jsonResponse, flavors, withDependencies, packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield batch_import_export_service_1.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
+                }
+                else {
+                    yield batch_import_export_service_1.batchImportExportService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : []);
+                }
+            });
+        }
+    }
+    exports.ConfigCommand = ConfigCommand;
+});

package/commands/package.command.js

@@ -52,14 +52,14 @@ 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* () {
-                yield package_service_1.packageService.batchExportPackages(packageKeys, includeDependencies);
+                yield package_service_1.packageService.batchExportPackages(packageKeys, includeDependencies, excludeActionFlows);
             });
         }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite) {
+        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield package_service_1.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite);
+                yield package_service_1.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows);
             });
         }
     }

package/content-cli-config.js

@@ -0,0 +1,60 @@
+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", "./commands/config.command", "commander", "./util/logger", "./util/context-initializer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Config = void 0;
+    const config_command_1 = require("./commands/config.command");
+    const commander = require("commander");
+    const logger_1 = require("./util/logger");
+    const context_initializer_1 = require("./util/context-initializer");
+    class Config {
+        static list(program) {
+            program
+                .command("list")
+                .description("Command to list active packages that can be exported")
+                .option("-p, --profile <profile>", "Profile which you want to use to list possible variable assignments")
+                .option("--json", "Return response as json type", "")
+                .option("--flavors <flavors...>", "Lists only active packages of the given flavors")
+                .option("--withDependencies", "Include dependencies", "")
+                .option("--packageKeys <packageKeys...>", "Lists only given package keys")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().listActivePackages(cmd.json, cmd.flavors, cmd.withDependencies, cmd.packageKeys);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    exports.Config = Config;
+    process.on("unhandledRejection", (e, promise) => {
+        logger_1.logger.error(e.toString());
+    });
+    const loadAllCommands = () => {
+        Config.list(commander);
+        commander.parse(process.argv);
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadAllCommands)
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+});

package/content-cli-export.js

@@ -32,8 +32,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-p, --profile <profile>", "Profile which you want to use to list packages")
                 .requiredOption("--packageKeys <packageKeys...>", "Exports only given package keys")
                 .option("--includeDependencies", "Include variables and dependencies", "")
+                .option("--excludeActionFlows", "Don't export action flows")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_1.PackageCommand().batchExportPackages(cmd.packageKeys, cmd.includeDependencies);
+                var _a;
+                yield new package_command_1.PackageCommand().batchExportPackages(cmd.packageKeys, cmd.includeDependencies, (_a = cmd.excludeActionFlows) !== null && _a !== void 0 ? _a : false);
                 process.exit();
             }));
             return program;

package/content-cli-import.js

@@ -32,10 +32,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-p, --profile <profile>", "Profile which you want to use to list 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)")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_1.PackageCommand().batchImportPackages(cmd.spaceMappings, cmd.dataModelMappingsFile, cmd.file, cmd.overwrite);
+                yield new package_command_1.PackageCommand().batchImportPackages(cmd.spaceMappings, cmd.dataModelMappingsFile, cmd.file, cmd.overwrite, cmd.excludeActionFlows);
                 process.exit();
             }));
             return program;

package/content-cli.js

@@ -28,6 +28,7 @@
     program.command("list", "Commands to list content.").alias("ls");
     program.command("get", "Commands to get configuration properties.");
     program.command("set", "Commands to set configuration properties.");
+    program.command("config", "Commands related to config management");
     program.version(version_1.VersionUtils.getCurrentCliVersion());
     program.parse(process.argv);
     if (!process.argv.slice(2).length) {

package/interfaces/package-export-transport.js

@@ -0,0 +1,12 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/lib/api/batch-import-export-api.d.ts

@@ -0,0 +1,8 @@
+import { PackageExportTransport } from "../interfaces/package-export-transport";
+declare class BatchImportExportApi {
+    static readonly INSTANCE: BatchImportExportApi;
+    findAllActivePackages(flavors: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+    findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+}
+export declare const batchImportExportApi: BatchImportExportApi;
+export {};

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

@@ -3,13 +3,13 @@ import { ActivatePackageTransport, ContentNodeTransport, PackageHistoryTransport
 declare class PackageApi {
     static readonly INSTANCE: PackageApi;
     findAllPackages(): Promise<ContentNodeTransport[]>;
-    exportPackage(rootPackageKey: string, version?: string): Promise<Buffer>;
+    exportPackage(rootPackageKey: string, version?: string, excludeActionFlows?: boolean): Promise<Buffer>;
     findAllPackagesWithVariableAssignments(type: PackageManagerVariableType): Promise<PackageWithVariableAssignments[]>;
     findLatestVersionById(nodeId: string): Promise<PackageHistoryTransport>;
     findActiveVersionById(nodeId: string): Promise<PackageHistoryTransport>;
     findActiveVersionByIds(nodeIds: string[]): Promise<PackageHistoryTransport[]>;
     findNextVersion(nodeId: string): Promise<PackageHistoryTransport>;
-    importPackage(nodeContent: any, spaceId: string, overwrite: boolean): Promise<any>;
+    importPackage(nodeContent: any, spaceId: string, overwrite: boolean, excludeActionFlows?: boolean): Promise<any>;
     movePackageToSpace(nodeId: string, spaceId: string): Promise<void>;
     publishPackage(activatePackage: ActivatePackageTransport): Promise<void>;
 }

package/lib/commands/config.command.d.ts

@@ -0,0 +1,3 @@
+export declare class ConfigCommand {
+    listActivePackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[]): Promise<void>;
+}

package/lib/commands/package.command.d.ts

@@ -5,6 +5,6 @@ export declare class PackageCommand {
     pushPackage(profile: string, spaceKey: string, fileName: string, newKey: string, overwrite: boolean): Promise<void>;
     pushPackages(profile: string, spaceKey: string): Promise<void>;
     listPackages(jsonResponse: boolean, includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean): 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/content-cli-config.d.ts

@@ -0,0 +1,6 @@
+import commander = require("commander");
+type CommanderStatic = commander.CommanderStatic;
+export declare class Config {
+    static list(program: CommanderStatic): CommanderStatic;
+}
+export {};

package/lib/interfaces/package-export-transport.d.ts

@@ -0,0 +1,18 @@
+import { StudioComputeNodeDescriptor } from "./package-manager.interfaces";
+export interface DependencyTransport {
+    key: string;
+    version: string;
+}
+export interface PackageExportTransport {
+    id: string;
+    key: string;
+    name: string;
+    changeDate: string;
+    activatedDraftId: string;
+    workingDraftId: string;
+    flavor: string;
+    version: string;
+    dependencies: DependencyTransport[];
+    spaceId?: string;
+    datamodels?: StudioComputeNodeDescriptor[];
+}

package/lib/interfaces/package-manager.interfaces.d.ts

@@ -42,6 +42,7 @@ export interface PackageWithVariableAssignments {
     key: string;
     name: string;
     createdBy: string;
+    spaceId: string;
     variableAssignments: VariablesAssignments[];
 }
 export interface VariablesAssignments {

package/lib/services/package-manager/batch-import-export-service.d.ts

@@ -0,0 +1,7 @@
+declare class BatchImportExportService {
+    listActivePackages(flavors: string[]): Promise<void>;
+    findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
+    private exportListOfPackages;
+}
+export declare const batchImportExportService: BatchImportExportService;
+export {};

package/lib/services/package-manager/package-service.d.ts

@@ -5,7 +5,7 @@ declare class PackageService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean): Promise<void>;
+    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows: boolean): Promise<void>;
     private checkNodeForCircularDependency;
     private importPackage;
     private importPackageVersion;
@@ -16,9 +16,9 @@ declare class PackageService {
     private getTargetSpaceForExportedPackage;
     private updateDependencyVersions;
     publishPackage(packageToImport: ManifestNodeTransport): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
     getNodesWithActiveVersion(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
-    getPackagesWithDependencies(draftIdByNodeId: Map<string, string>, actionFlowPackageKeys: string[]): Promise<Map<string, PackageDependencyTransport[]>>;
+    getPackagesWithDependencies(draftIdByNodeId: Map<string, string>): Promise<Map<string, PackageDependencyTransport[]>>;
     private getDependencyPackages;
     private nodeHasBeenResolvedBefore;
     private exportListOfPackages;

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

@@ -0,0 +1,8 @@
+import { PackageExportTransport } from "../../interfaces/package-export-transport";
+declare class StudioService {
+    getExportPackagesWithStudioData(packagesToExport: PackageExportTransport[], withDependencies: boolean): Promise<PackageExportTransport[]>;
+    private setSpaceIdForStudioPackages;
+    private setDataModelsForStudioPackages;
+}
+export declare const studioService: StudioService;
+export {};

package/package.json

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

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

@@ -0,0 +1,56 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../api/batch-import-export-api", "../../util/logger", "uuid", "../file-service", "../studio/studio.service"], 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");
+    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);
+            });
+        }
+        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);
+        }
+    }
+    exports.batchImportExportService = new BatchImportExportService();
+});

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

@@ -56,8 +56,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 +67,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 +77,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 +116,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 +133,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 +144,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 +152,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;
@@ -168,7 +166,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 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);
+                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 +211,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);
                 }
             });
         }
@@ -291,12 +289,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 +302,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 +319,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 +331,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 +368,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 +382,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 +396,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/studio/studio.service.js

@@ -0,0 +1,58 @@
+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/package-api", "../../interfaces/package-manager.interfaces", "../package-manager/datamodel-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.studioService = void 0;
+    const package_api_1 = require("../../api/package-api");
+    const package_manager_interfaces_1 = require("../../interfaces/package-manager.interfaces");
+    const datamodel_service_1 = require("../package-manager/datamodel-service");
+    class StudioService {
+        getExportPackagesWithStudioData(packagesToExport, withDependencies) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const studioPackagesWithDataModels = yield package_api_1.packageApi.findAllPackagesWithVariableAssignments(package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
+                packagesToExport = exports.studioService.setSpaceIdForStudioPackages(packagesToExport, studioPackagesWithDataModels);
+                if (withDependencies) {
+                    const dataModelDetailsByNode = yield datamodel_service_1.dataModelService.getDataModelDetailsForPackages(studioPackagesWithDataModels);
+                    packagesToExport = exports.studioService.setDataModelsForStudioPackages(packagesToExport, studioPackagesWithDataModels, dataModelDetailsByNode);
+                }
+                return packagesToExport;
+            });
+        }
+        setSpaceIdForStudioPackages(packages, studioPackages) {
+            const studioPackageByKey = new Map();
+            studioPackages.forEach(pkg => studioPackageByKey.set(pkg.key, pkg));
+            return packages.map(pkg => {
+                return studioPackageByKey.has(pkg.key) ? Object.assign(Object.assign({}, pkg), { spaceId: studioPackageByKey.get(pkg.key).spaceId }) : pkg;
+            });
+        }
+        setDataModelsForStudioPackages(packages, studioPackageWithDataModels, dataModelDetailsByNode) {
+            const studioPackageByKey = new Map();
+            studioPackageWithDataModels.forEach(pkg => studioPackageByKey.set(pkg.key, pkg));
+            return packages.map(pkg => {
+                return studioPackageByKey.has(pkg.key) ? Object.assign(Object.assign({}, pkg), { datamodels: dataModelDetailsByNode.get(pkg.key)
+                        .map(dataModel => ({
+                        name: dataModel.name,
+                        poolId: dataModel.poolId,
+                        dataModelId: dataModel.dataModelId
+                    })) }) : pkg;
+            });
+        }
+    }
+    exports.studioService = new StudioService();
+});