@celonis/content-cli 0.7.0 → 0.8.0

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

@@ -29,6 +29,22 @@
                 throw new logger_1.FatalError(`Problem getting active packages by keys: ${e}`);
             });
         }
+        exportPackages(packageKeys, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
+            queryParams.set("withDependencies", withDependencies.toString());
+            return http_client_service_v2_1.httpClientV2.getFile(`/package-manager/api/core/packages/export/batch?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem exporting packages: ${e}`);
+            });
+        }
+        importPackages(data, overwrite) {
+            return http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/core/packages/import/batch", data, { overwrite });
+        }
+        findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {
+            return http_client_service_v2_1.httpClientV2.post("/package-manager/api/core/packages/export/batch/variables-with-assignments", packagesByKeyAndVersion).catch(e => {
+                throw new logger_1.FatalError(`Problem exporting package variables: ${e}`);
+            });
+        }
     }
     BatchImportExportApi.INSTANCE = new BatchImportExportApi();
     exports.batchImportExportApi = BatchImportExportApi.INSTANCE;

package/api/variables-api.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", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis"], factory);
+        define(["require", "exports", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis", "url"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const http_client_service_v2_1 = require("../services/http-client-service.v2");
     const logger_1 = require("../util/logger");
     const variable_assignment_apis_1 = require("./variable-assignment-apis");
+    const url_1 = require("url");
     class VariablesApi {
         assignVariableValues(packageKey, variablesAssignments) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -41,6 +42,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        getRuntimeVariableValues(packageKey, appMode) {
+            const queryParams = new url_1.URLSearchParams();
+            queryParams.set("appMode", appMode);
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/nodes/by-package-key/${packageKey}/variables/runtime-values?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting runtime variables of package ${packageKey}: ${e}`);
+            });
+        }
     }
     VariablesApi.INSTANCE = new VariablesApi();
     VariablesApi.ASSIGNMENT_APIS = variable_assignment_apis_1.variableAssignmentApis;

package/commands/config.command.js

@@ -13,13 +13,14 @@ 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", "../services/package-manager/batch-import-export-service"], factory);
+        define(["require", "exports", "../services/package-manager/batch-import-export-service", "../services/package-manager/variable-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");
+    const variable_service_1 = require("../services/package-manager/variable-service");
     class ConfigCommand {
         listActivePackages(jsonResponse, flavors, withDependencies, packageKeys) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -31,6 +32,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
+        listVariables(jsonResponse, keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield variable_service_1.variableService.exportVariables(keysByVersion, keysByVersionFile);
+                }
+                else {
+                    yield variable_service_1.variableService.listVariables(keysByVersion, keysByVersionFile);
+                }
+            });
+        }
+        batchExportPackages(packageKeys, withDependencies = false) {
+            return batch_import_export_service_1.batchImportExportService.batchExportPackages(packageKeys, withDependencies);
+        }
+        batchImportPackages(file, overwrite) {
+            return batch_import_export_service_1.batchImportExportService.batchImportPackages(file, overwrite);
+        }
     }
     exports.ConfigCommand = ConfigCommand;
 });

package/content-cli-config.js

@@ -39,17 +39,59 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }));
             return program;
         }
+        static listVariables(program) {
+            program
+                .command("variables")
+                .description("Commands related to variable configs")
+                .command("list")
+                .description("Command to list versioned variables of packages")
+                .option("-p, --profile <profile>", "Profile which you want to use to list packages")
+                .option("--json", "Return response as json type", "")
+                .option("--keysByVersion <keysByVersion...>", "Mapping of package keys and versions", "")
+                .option("--keysByVersionFile <keysByVersionFile>", "Package keys by version mappings file path.", "")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().listVariables(cmd.json, cmd.keysByVersion, cmd.keysByVersionFile);
+                process.exit();
+            }));
+            return program;
+        }
+        static export(program) {
+            program
+                .command("export")
+                .description("Command to export package configs")
+                .option("-p, --profile <profile>", "Profile which you want to use to export packages")
+                .requiredOption("--packageKeys <packageKeys...>", "Keys of packages to export")
+                .option("--withDependencies", "Include variables and dependencies", "")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().batchExportPackages(cmd.packageKeys, cmd.withDependencies);
+                process.exit();
+            }));
+            return program;
+        }
+        static import(program) {
+            program
+                .command("import")
+                .description("Command to import package configs")
+                .option("-p, --profile <profile>", "Profile which you want to use to import packages")
+                .option("--overwrite", "Flag to allow overwriting of packages")
+                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().batchImportPackages(cmd.file, cmd.overwrite);
+                process.exit();
+            }));
+            return program;
+        }
     }
     exports.Config = Config;
-    process.on("unhandledRejection", (e, promise) => {
-        logger_1.logger.error(e.toString());
-    });
     const loadAllCommands = () => {
         Config.list(commander);
+        Config.listVariables(commander);
+        Config.export(commander);
+        Config.import(commander);
         commander.parse(process.argv);
     };
     context_initializer_1.ContextInitializer.initContext()
-        .then(loadAllCommands)
+        .then(loadAllCommands, loadAllCommands)
         .catch(e => {
         logger_1.logger.error(e);
     });

package/content-cli-list.js

@@ -108,9 +108,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
     }
     exports.List = List;
-    process.on("unhandledRejection", (e, promise) => {
-        logger_1.logger.error(e.toString());
-    });
     const loadAllCommands = () => {
         List.packages(commander);
         List.spaces(commander);
@@ -121,7 +118,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         commander.parse(process.argv);
     };
     context_initializer_1.ContextInitializer.initContext()
-        .then(loadAllCommands)
+        .then(loadAllCommands, loadAllCommands)
         .catch(e => {
         logger_1.logger.error(e);
     });

package/content-cli-set.js

@@ -39,11 +39,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return program;
         }
     }
-    context_initializer_1.ContextInitializer.initContext()
-        .then(() => {
+    const loadAllCommands = () => {
         Set.connection(commander);
         commander.parse(process.argv);
-    })
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadAllCommands, loadAllCommands)
         .catch(e => {
         logger_1.logger.error(e);
     });

package/content-cli.js

@@ -28,7 +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.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/batch-export-import-constants.js

@@ -0,0 +1,25 @@
+(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 });
+    exports.BatchExportImportConstants = void 0;
+    var BatchExportImportConstants;
+    (function (BatchExportImportConstants) {
+        BatchExportImportConstants["STUDIO_FILE_NAME"] = "studio.yml";
+        BatchExportImportConstants["VARIABLES_FILE_NAME"] = "variables.yml";
+        BatchExportImportConstants["MANIFEST_FILE_NAME"] = "manifest.yml";
+        BatchExportImportConstants["STUDIO"] = "STUDIO";
+        BatchExportImportConstants["APP_MODE_VIEWER"] = "VIEWER";
+        BatchExportImportConstants["ZIP_EXTENSION"] = ".zip";
+        BatchExportImportConstants["YAML_EXTENSION"] = ".yml";
+        BatchExportImportConstants["NODES_FOLDER_NAME"] = "nodes/";
+        BatchExportImportConstants["SCENARIO_NODE"] = "SCENARIO";
+    })(BatchExportImportConstants || (exports.BatchExportImportConstants = BatchExportImportConstants = {}));
+});

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

@@ -1,8 +1,13 @@
-import { PackageExportTransport } from "../interfaces/package-export-transport";
+/// <reference types="node" />
+import { PackageExportTransport, PackageKeyAndVersionPair, PostPackageImportData, VariableManifestTransport } from "../interfaces/package-export-transport";
+import * as FormData from "form-data";
 declare class BatchImportExportApi {
     static readonly INSTANCE: BatchImportExportApi;
     findAllActivePackages(flavors: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+    exportPackages(packageKeys: string[], withDependencies?: boolean): Promise<Buffer>;
+    importPackages(data: FormData, overwrite: boolean): Promise<PostPackageImportData[]>;
+    findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
 }
 export declare const batchImportExportApi: BatchImportExportApi;
 export {};

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

@@ -8,6 +8,7 @@ declare class VariablesApi {
     };
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<ContentNodeTransport[]>;
     getCandidateAssignments(type: string, params: URLSearchParams): Promise<object[]>;
+    getRuntimeVariableValues(packageKey: string, appMode: string): Promise<VariablesAssignments[]>;
 }
 export declare const variablesApi: VariablesApi;
 export {};

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

@@ -1,3 +1,6 @@
 export declare class ConfigCommand {
     listActivePackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[]): Promise<void>;
+    listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;
+    batchImportPackages(file: string, overwrite: boolean): Promise<void>;
 }

package/lib/content-cli-config.d.ts

@@ -2,5 +2,8 @@ import commander = require("commander");
 type CommanderStatic = commander.CommanderStatic;
 export declare class Config {
     static list(program: CommanderStatic): CommanderStatic;
+    static listVariables(program: CommanderStatic): CommanderStatic;
+    static export(program: CommanderStatic): CommanderStatic;
+    static import(program: CommanderStatic): CommanderStatic;
 }
 export {};

package/lib/interfaces/batch-export-import-constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum BatchExportImportConstants {
+    STUDIO_FILE_NAME = "studio.yml",
+    VARIABLES_FILE_NAME = "variables.yml",
+    MANIFEST_FILE_NAME = "manifest.yml",
+    STUDIO = "STUDIO",
+    APP_MODE_VIEWER = "VIEWER",
+    ZIP_EXTENSION = ".zip",
+    YAML_EXTENSION = ".yml",
+    NODES_FOLDER_NAME = "nodes/",
+    SCENARIO_NODE = "SCENARIO"
+}

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

@@ -1,4 +1,6 @@
-import { StudioComputeNodeDescriptor } from "./package-manager.interfaces";
+/// <reference types="node" />
+import { StudioComputeNodeDescriptor, VariableDefinition, VariablesAssignments } from "./package-manager.interfaces";
+import { SpaceTransport } from "./save-space.interface";
 export interface DependencyTransport {
     key: string;
     version: string;
@@ -16,3 +18,54 @@ export interface PackageExportTransport {
     spaceId?: string;
     datamodels?: StudioComputeNodeDescriptor[];
 }
+export interface PackageManifestTransport {
+    packageKey: string;
+    flavor: string;
+    activeVersion: string;
+    dependenciesByVersion: Map<string, DependencyTransport[]>;
+}
+export interface VariableExportTransport {
+    key: string;
+    value: any;
+    type: string;
+    metadata: object;
+}
+export interface VariableManifestTransport {
+    packageKey: string;
+    version: string;
+    variables?: VariableExportTransport[];
+}
+export interface PackageKeyAndVersionPair {
+    packageKey: string;
+    version: string;
+}
+export interface NodeExportTransport {
+    key: string;
+    parentNodeKey: string;
+    packageNodeKey: string;
+    name: string;
+    type: string;
+    exportSerializationType: string;
+    serializedContent: string;
+    schemaVersion: number;
+    unversionedMetadata: any;
+    versionedMetdata: object;
+    invalidContent?: boolean;
+    serializedDocument: Buffer;
+}
+export interface NodeSerializedContent {
+    variables: VariableDefinition[];
+}
+export interface StudioPackageManifest {
+    packageKey: string;
+    space: Partial<SpaceTransport>;
+    runtimeVariableAssignments: VariablesAssignments[];
+}
+export interface PackageVersionImport {
+    oldVersion: string;
+    newVersion: string;
+}
+export interface PostPackageImportData {
+    packageKey: string;
+    importedVersions: PackageVersionImport[];
+}

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

@@ -50,7 +50,7 @@ export interface VariablesAssignments {
     value: object;
     type: string;
 }
-export interface VariableDefinitionWithValue {
+export interface VariableDefinition {
     key: string;
     type: PackageManagerVariableType;
     description?: string;

package/lib/services/http-client-service.v2.d.ts

@@ -1,6 +1,8 @@
+import * as FormData from "form-data";
 declare class HttpClientServiceV2 {
     get(url: string): Promise<any>;
-    postFile(url: string, body: any, parameters?: {}): Promise<any>;
+    getFile(url: string): Promise<any>;
+    postFile(url: string, formData: FormData, parameters?: {}): Promise<any>;
     post(url: string, body: any): Promise<any>;
     put(url: string, body: object): Promise<any>;
     delete(url: string): Promise<any>;

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

@@ -1,7 +1,14 @@
 declare class BatchImportExportService {
     listActivePackages(flavors: string[]): Promise<void>;
     findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;
+    batchImportPackages(file: string, overwrite: boolean): Promise<void>;
     private exportListOfPackages;
+    private getVersionsByPackageKey;
+    private getVersionedVariablesForPackagesWithKeys;
+    private buildBodyForImport;
+    private getReadableStream;
+    private parseEntryData;
 }
 export declare const batchImportExportService: BatchImportExportService;
 export {};

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

@@ -4,7 +4,13 @@ declare class VariableService {
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;
     findAndExportCandidateAssignments(type: string, params: string): Promise<void>;
+    listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    exportVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     private parseParams;
+    private getVersionedVariablesByKeyVersionPairs;
+    private buildKeyVersionPairs;
+    private buildKeyAndVersionPairsFromArrayInput;
+    private exportToJson;
 }
 export declare const variableService: VariableService;
 export {};

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

@@ -1,8 +1,25 @@
-import { PackageExportTransport } from "../../interfaces/package-export-transport";
+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.7.0",
+  "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

@@ -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/batch-import-export-api", "../../util/logger", "uuid", "../file-service", "../studio/studio.service"], factory);
+        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";
@@ -24,6 +24,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     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* () {
@@ -46,11 +52,100 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 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: ";
@@ -165,7 +166,7 @@ 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);
+                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);
@@ -228,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* () {

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();
 });

package/services/studio/studio.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", "../../interfaces/package-manager.interfaces", "../package-manager/datamodel-service"], factory);
+        define(["require", "exports", "../../api/package-api", "../../interfaces/package-manager.interfaces", "../package-manager/datamodel-service", "../../util/yaml", "../../api/node-api", "../../api/variables-api", "../../api/space-api", "../package-manager/space-service", "../package-manager/variable-service", "../../interfaces/batch-export-import-constants", "adm-zip"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     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");
+    const yaml_1 = require("../../util/yaml");
+    const node_api_1 = require("../../api/node-api");
+    const variables_api_1 = require("../../api/variables-api");
+    const space_api_1 = require("../../api/space-api");
+    const space_service_1 = require("../package-manager/space-service");
+    const variable_service_1 = require("../package-manager/variable-service");
+    const batch_export_import_constants_1 = require("../../interfaces/batch-export-import-constants");
+    const AdmZip = require("adm-zip");
     class StudioService {
         getExportPackagesWithStudioData(packagesToExport, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -34,6 +42,51 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 return packagesToExport;
             });
         }
+        fixConnectionVariables(variables) {
+            return variables.map(variableManifest => (Object.assign(Object.assign({}, variableManifest), { variables: variableManifest.variables.map(variable => {
+                    if (variable.type !== package_manager_interfaces_1.PackageManagerVariableType.CONNECTION) {
+                        return variable;
+                    }
+                    return this.fixConnectionVariable(variable);
+                }) })));
+        }
+        getStudioPackageManifests(studioPackageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return Promise.all(studioPackageKeys.map((packageKey) => __awaiter(this, void 0, void 0, function* () {
+                    const node = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageKey, packageKey);
+                    const nodeSpace = yield space_api_1.spaceApi.findOne(node.spaceId);
+                    const variableAssignments = yield variables_api_1.variablesApi.getRuntimeVariableValues(packageKey, batch_export_import_constants_1.BatchExportImportConstants.APP_MODE_VIEWER);
+                    return {
+                        packageKey: packageKey,
+                        space: {
+                            name: nodeSpace.name,
+                            iconReference: nodeSpace.iconReference
+                        },
+                        runtimeVariableAssignments: variableAssignments
+                    };
+                })));
+            });
+        }
+        processPackageForExport(exportedPackage, exportedVariables) {
+            const packageZip = new AdmZip(exportedPackage.getData());
+            this.deleteScenarioAssets(packageZip);
+            this.fixConnectionVariablesForRootNodeFiles(packageZip, exportedPackage.name, exportedVariables);
+            return packageZip;
+        }
+        processImportedPackages(configs, existingStudioPackages, studioManifests) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (studioManifests == null) {
+                    return;
+                }
+                for (const manifest of studioManifests) {
+                    const existingPackage = existingStudioPackages.find(existingPackage => existingPackage.key === manifest.packageKey);
+                    if (existingPackage) {
+                        yield package_api_1.packageApi.movePackageToSpace(existingPackage.id, manifest.space.id);
+                    }
+                    yield this.assignRuntimeVariables(manifest);
+                }
+            });
+        }
         setSpaceIdForStudioPackages(packages, studioPackages) {
             const studioPackageByKey = new Map();
             studioPackages.forEach(pkg => studioPackageByKey.set(pkg.key, pkg));
@@ -53,6 +106,115 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     })) }) : pkg;
             });
         }
+        fixConnectionVariable(variable) {
+            if (!variable.value.appName) {
+                return variable;
+            }
+            return Object.assign(Object.assign({}, variable), { metadata: Object.assign(Object.assign({}, variable.metadata), { appName: variable.value.appName }) });
+        }
+        deleteScenarioAssets(packageZip) {
+            packageZip.getEntries().filter(entry => entry.entryName.startsWith(batch_export_import_constants_1.BatchExportImportConstants.NODES_FOLDER_NAME) && entry.entryName.endsWith(batch_export_import_constants_1.BatchExportImportConstants.YAML_EXTENSION))
+                .forEach(entry => {
+                const node = (0, yaml_1.parse)(entry.getData().toString());
+                if (node.type === batch_export_import_constants_1.BatchExportImportConstants.SCENARIO_NODE) {
+                    packageZip.deleteFile(entry);
+                }
+            });
+        }
+        fixConnectionVariablesForRootNodeFiles(packageZip, zipName, exportedVariables) {
+            const packageKeyAndVersion = this.getPackageKeyAndVersion(zipName);
+            const connectionVariablesByKey = this.getConnectionVariablesByKeyForPackage(packageKeyAndVersion.packageKey, packageKeyAndVersion.version, exportedVariables);
+            if (connectionVariablesByKey.size === 0) {
+                return;
+            }
+            const packageEntry = packageZip.getEntry("package.yml");
+            const exportedNode = (0, yaml_1.parse)(packageEntry.getData().toString());
+            const nodeContent = (0, yaml_1.parse)(exportedNode.serializedContent);
+            nodeContent.variables = nodeContent.variables.map(variable => (Object.assign(Object.assign({}, variable), { metadata: variable.type === package_manager_interfaces_1.PackageManagerVariableType.CONNECTION ?
+                    connectionVariablesByKey.get(variable.key).metadata : variable.metadata })));
+            exportedNode.serializedContent = (0, yaml_1.stringify)(nodeContent);
+            packageZip.updateFile(packageEntry, Buffer.from((0, yaml_1.stringify)(exportedNode)));
+        }
+        getPackageKeyAndVersion(zipName) {
+            const lastUnderscoreIndex = zipName.lastIndexOf("_");
+            const packageKey = zipName.replace(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION, "").substring(0, lastUnderscoreIndex);
+            const packageVersion = zipName.replace(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION, "").substring(lastUnderscoreIndex + 1);
+            return {
+                packageKey: packageKey,
+                version: packageVersion
+            };
+        }
+        getConnectionVariablesByKeyForPackage(packageKey, packageVersion, variables) {
+            const variablesByKey = new Map();
+            const packageVariables = variables.find(exportedVariable => exportedVariable.packageKey === packageKey && exportedVariable.version === packageVersion);
+            if (packageVariables && packageVariables.variables.length) {
+                packageVariables.variables.filter(variable => variable.type === package_manager_interfaces_1.PackageManagerVariableType.CONNECTION)
+                    .forEach(variable => variablesByKey.set(variable.key, variable));
+            }
+            return variablesByKey;
+        }
+        mapSpaces(exportedFiles, studioManifests) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (studioManifests == null) {
+                    return exportedFiles;
+                }
+                for (const file of exportedFiles.getEntries()) {
+                    if (file.name.endsWith(batch_export_import_constants_1.BatchExportImportConstants.ZIP_EXTENSION)) {
+                        const packageKey = this.getPackageKeyAndVersion(file.name).packageKey;
+                        if (this.isStudioPackage(studioManifests, packageKey)) {
+                            const studioManifest = studioManifests.find(manifest => manifest.packageKey === packageKey);
+                            if (studioManifest) {
+                                const spaceId = yield this.findDesiredSpaceIdForPackage(studioManifest);
+                                studioManifest.space.id = spaceId;
+                                const packageZip = new AdmZip(file.getData());
+                                packageZip.getEntries().forEach(nodeFile => {
+                                    if (nodeFile.entryName.endsWith(batch_export_import_constants_1.BatchExportImportConstants.YAML_EXTENSION)) {
+                                        const updatedNodeFile = this.updateSpaceIdForNode(nodeFile.getData().toString(), spaceId);
+                                        packageZip.updateFile(nodeFile, Buffer.from(updatedNodeFile));
+                                    }
+                                });
+                                exportedFiles.updateFile(file, packageZip.toBuffer());
+                            }
+                        }
+                    }
+                }
+                return exportedFiles;
+            });
+        }
+        isStudioPackage(studioManifests, packageKey) {
+            return studioManifests.some(manifest => manifest.packageKey === packageKey);
+        }
+        findDesiredSpaceIdForPackage(studioPackageManifest) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const allSpaces = yield space_service_1.spaceService.refreshAndGetAllSpaces();
+                if (studioPackageManifest.space.id) {
+                    const targetSpace = allSpaces.find(space => space.id === studioPackageManifest.space.id);
+                    if (!targetSpace) {
+                        throw Error("Provided space ID does not exist.");
+                    }
+                    return targetSpace.id;
+                }
+                const targetSpaceByName = allSpaces.find(space => space.name === studioPackageManifest.space.name);
+                if (targetSpaceByName) {
+                    return targetSpaceByName.id;
+                }
+                const spaceTransport = yield space_service_1.spaceService.createSpace(studioPackageManifest.space.name, studioPackageManifest.space.iconReference);
+                return spaceTransport.id;
+            });
+        }
+        assignRuntimeVariables(manifest) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (manifest.runtimeVariableAssignments.length) {
+                    yield variable_service_1.variableService.assignVariableValues(manifest.packageKey, manifest.runtimeVariableAssignments);
+                }
+            });
+        }
+        updateSpaceIdForNode(nodeContent, spaceId) {
+            const exportedNode = (0, yaml_1.parse)(nodeContent);
+            const oldSpaceId = exportedNode.unversionedMetadata.spaceId;
+            nodeContent = nodeContent.replace(new RegExp(oldSpaceId, "g"), spaceId);
+            return nodeContent;
+        }
     }
     exports.studioService = new StudioService();
 });