@celonis/content-cli 0.2.10 → 0.3.0

package/api/compute-pool-api.js

@@ -0,0 +1,35 @@
+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/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class ComputePoolApi {
+        findAssignedDatamodels(packageKey) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/compute-pools/data-models/assigned?packageKey=${packageKey}`)
+                    .catch(e => {
+                    throw new logger_1.FatalError(`Problem getting datamodels of package: ${e}`);
+                });
+            });
+        }
+    }
+    ComputePoolApi.INSTANCE = new ComputePoolApi();
+    exports.computePoolApi = ComputePoolApi.INSTANCE;
+});

package/api/node-api.js

@@ -0,0 +1,35 @@
+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/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class NodeApi {
+        findAllNodesOfType(assetType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/nodes?assetType=${assetType}`)
+                    .catch(e => {
+                    throw new logger_1.FatalError(`Problem getting nodes of type ${assetType}: ${e}`);
+                });
+            });
+        }
+    }
+    NodeApi.INSTANCE = new NodeApi();
+    exports.nodeApi = NodeApi.INSTANCE;
+});

package/api/package-api.js

@@ -0,0 +1,48 @@
+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/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class PackageApi {
+        findAllPackages() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get("/package-manager/api/packages").catch(e => {
+                    throw new logger_1.FatalError(`Problem getting packages: ${e}`);
+                });
+            });
+        }
+        findAllPackagesWithVariableAssignments() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get("/package-manager/api/packages/with-variable-assignments").catch(e => {
+                    throw new logger_1.FatalError(`Problem getting variables of packages: : ${e}`);
+                });
+            });
+        }
+        findLatestVersionById(nodeId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/packages/${nodeId}/latest-version`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting latest version of package: ${e}`);
+                });
+            });
+        }
+    }
+    PackageApi.INSTANCE = new PackageApi();
+    exports.packageApi = PackageApi.INSTANCE;
+});

package/api/package-dependencies-api.js

@@ -0,0 +1,35 @@
+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/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class PackageDependenciesApi {
+        findDependenciesOfPackage(nodeId, draftId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/package-dependencies/${nodeId}/by-root-draft-id/${draftId}`)
+                    .catch(e => {
+                    throw new logger_1.FatalError(`Problem getting dependencies of package: ${e}`);
+                });
+            });
+        }
+    }
+    PackageDependenciesApi.INSTANCE = new PackageDependenciesApi();
+    exports.packageDependenciesApi = PackageDependenciesApi.INSTANCE;
+});

package/commands/package.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/content.service", "../content/factory/package-manager.factory"], factory);
+        define(["require", "exports", "../services/content.service", "../content/factory/package-manager.factory", "../services/package-manager/package-service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     const content_service_1 = require("../services/content.service");
     const package_manager_factory_1 = require("../content/factory/package-manager.factory");
+    const package_service_1 = require("../services/package-manager/package-service");
     class PackageCommand {
         constructor() {
             this.contentService = new content_service_1.ContentService();
@@ -40,9 +41,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 yield this.contentService.batchPush(profile, this.packageManagerFactory.createPushManagers(spaceKey));
             });
         }
-        listPackages(profile, jsonResponse) {
+        listPackages(jsonResponse, includeDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.findAll(profile, this.packageManagerFactory.createListManager(jsonResponse));
+                if (jsonResponse) {
+                    yield package_service_1.packageService.findAndExportAllPackages(includeDependencies);
+                }
+                else {
+                    yield package_service_1.packageService.listPackages();
+                }
             });
         }
     }

package/content/factory/package-manager.factory.js

@@ -15,13 +15,10 @@
     const package_manager_1 = require("../manager/package.manager");
     class PackageManagerFactory {
         createPullManager(key, store, newKey, draft) {
-            return this.createManager(key, null, null, store, newKey, false, draft, null);
+            return this.createManager(key, null, null, store, newKey, false, draft);
         }
         createPushManager(spaceKey, fileName, newKey, overwrite) {
-            return this.createManager(null, spaceKey, fileName, false, newKey, overwrite, false, null);
-        }
-        createListManager(jsonResponse) {
-            return this.createManager(null, null, null, false, null, false, false, jsonResponse);
+            return this.createManager(null, spaceKey, fileName, false, newKey, overwrite, false);
         }
         createPushManagers(spaceKey) {
             const filePaths = fs.readdirSync(process.cwd());
@@ -37,7 +34,7 @@
                 return this.createPushManager(spaceKey, filePath);
             });
         }
-        createManager(key, spaceKey, fileName, store, newKey, overwrite, draft, jsonResponse) {
+        createManager(key, spaceKey, fileName, store, newKey, overwrite, draft) {
             const packageManager = new package_manager_1.PackageManager();
             if (fileName) {
                 packageManager.fileName = this.resolvePackageFilePath(fileName);
@@ -48,7 +45,6 @@
             packageManager.newKey = newKey;
             packageManager.overwrite = overwrite;
             packageManager.draft = draft;
-            packageManager.jsonResponse = jsonResponse;
             return packageManager;
         }
         isPackageFilePath(filePath) {

package/content/manager/package.manager.js

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./base.manager", "fs", "../../util/logger", "uuid"], factory);
+        define(["require", "exports", "./base.manager", "fs", "../../util/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,7 +12,6 @@
     const base_manager_1 = require("./base.manager");
     const fs = require("fs");
     const logger_1 = require("../../util/logger");
-    const uuid_1 = require("uuid");
     class PackageManager extends base_manager_1.BaseManager {
         get key() {
             return this._key;
@@ -56,12 +55,6 @@
         set draft(value) {
             this._draft = value;
         }
-        get jsonResponse() {
-            return this._jsonResponse;
-        }
-        set jsonResponse(value) {
-            this._jsonResponse = value;
-        }
         getConfig() {
             return {
                 pushUrl: this.profile.team.replace(/\/?$/, this.buildPushUrl()),
@@ -90,16 +83,9 @@
             return this.getPushUrlWithParams(pushUrl);
         }
         listPackages(nodes) {
-            if (this.jsonResponse) {
-                const filename = uuid_1.v4() + ".json";
-                this.writeToFileWithGivenName(JSON.stringify(nodes, ["key", "name", "changeDate", "activatedDraftId", "spaceId"]), filename);
-                logger_1.logger.info(this.fileDownloadedMessage + filename);
-            }
-            else {
-                nodes.forEach(node => {
-                    logger_1.logger.info(`${node.name} - Key: "${node.key}"`);
-                });
-            }
+            nodes.forEach(node => {
+                logger_1.logger.info(`${node.name} - Key: "${node.key}"`);
+            });
         }
         validateOptions() {
             if (this.newKey && this.overwrite) {

package/content-cli-list.js

@@ -13,14 +13,17 @@ 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", "./commands/package.command", "./commands/space.command", "commander"], factory);
+        define(["require", "exports", "./commands/package.command", "./commands/space.command", "commander", "./services/context.service", "./util/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
+    var _a;
     Object.defineProperty(exports, "__esModule", { value: true });
     const package_command_1 = require("./commands/package.command");
     const space_command_1 = require("./commands/space.command");
     const commander = require("commander");
+    const context_service_1 = require("./services/context.service");
+    const logger_1 = require("./util/logger");
     class List {
         static packages(program) {
             program
@@ -28,8 +31,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .description("Command to list all packages")
                 .option("-p, --profile <profile>", "Profile which you want to use to list packages")
                 .option("--json", "Return response as json type", "")
+                .option("--includeDependencies", "Include variables and dependencies", "")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_1.PackageCommand().listPackages(cmd.profile, cmd.json);
+                yield new package_command_1.PackageCommand().listPackages(cmd.json, cmd.includeDependencies);
                 process.exit();
             }));
             return program;
@@ -47,9 +51,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return program;
         }
     }
-    List.packages(commander);
-    List.spaces(commander);
-    commander.parse(process.argv);
+    exports.List = List;
+    const options = commander.parseOptions(process.argv);
+    const indexOfProfileOption = (_a = options.unknown.indexOf('-p')) !== null && _a !== void 0 ? _a : options.unknown.indexOf('--profile');
+    process.on("unhandledRejection", (e, promise) => {
+        logger_1.logger.error(e.toString());
+    });
+    context_service_1.contextService.resolveProfile(options.unknown[indexOfProfileOption + 1]).then(() => {
+        List.packages(commander);
+        List.spaces(commander);
+        commander.parse(process.argv);
+    }).catch(e => {
+        console.log(e);
+    });
     if (!process.argv.slice(2).length) {
         commander.outputHelp();
         process.exit(1);

package/interfaces/batch-export-node-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/interfaces/package-manager.interfaces.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/interfaces/save-content-node.interface.js

@@ -9,7 +9,4 @@
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    class AssetMetadataTransport {
-    }
-    exports.AssetMetadataTransport = AssetMetadataTransport;
 });

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

@@ -0,0 +1,7 @@
+import { StudioDataModelTransport } from "../interfaces/package-manager.interfaces";
+declare class ComputePoolApi {
+    static readonly INSTANCE: ComputePoolApi;
+    findAssignedDatamodels(packageKey: string): Promise<StudioDataModelTransport[]>;
+}
+export declare const computePoolApi: ComputePoolApi;
+export {};

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

@@ -0,0 +1,7 @@
+import { ContentNodeTransport } from "../interfaces/package-manager.interfaces";
+declare class NodeApi {
+    static readonly INSTANCE: NodeApi;
+    findAllNodesOfType(assetType?: string): Promise<ContentNodeTransport[]>;
+}
+export declare const nodeApi: NodeApi;
+export {};

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

@@ -0,0 +1,9 @@
+import { ContentNodeTransport, PackageHistoryTransport, PackageWithVariableAssignments } from "../interfaces/package-manager.interfaces";
+declare class PackageApi {
+    static readonly INSTANCE: PackageApi;
+    findAllPackages(): Promise<ContentNodeTransport[]>;
+    findAllPackagesWithVariableAssignments(): Promise<PackageWithVariableAssignments[]>;
+    findLatestVersionById(nodeId: string): Promise<PackageHistoryTransport>;
+}
+export declare const packageApi: PackageApi;
+export {};

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

@@ -0,0 +1,7 @@
+import { PackageDependencyTransport } from "../interfaces/package-manager.interfaces";
+declare class PackageDependenciesApi {
+    static readonly INSTANCE: PackageDependenciesApi;
+    findDependenciesOfPackage(nodeId: string, draftId: string): Promise<PackageDependencyTransport[]>;
+}
+export declare const packageDependenciesApi: PackageDependenciesApi;
+export {};

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

@@ -4,5 +4,5 @@ export declare class PackageCommand {
     pullPackage(profile: string, key: string, store: boolean, newKey: string, draft: boolean): Promise<void>;
     pushPackage(profile: string, spaceKey: string, fileName: string, newKey: string, overwrite: boolean): Promise<void>;
     pushPackages(profile: string, spaceKey: string): Promise<void>;
-    listPackages(profile: string, jsonResponse: boolean): Promise<void>;
+    listPackages(jsonResponse: boolean, includeDependencies: boolean): Promise<void>;
 }

package/lib/content/factory/package-manager.factory.d.ts

@@ -2,9 +2,8 @@ import { PackageManager } from "../manager/package.manager";
 export declare class PackageManagerFactory {
     createPullManager(key: string, store?: boolean, newKey?: string, draft?: boolean): PackageManager;
     createPushManager(spaceKey: string, fileName: string, newKey?: string, overwrite?: boolean): PackageManager;
-    createListManager(jsonResponse: boolean): PackageManager;
     createPushManagers(spaceKey: string): PackageManager[];
-    createManager(key?: string, spaceKey?: string, fileName?: string, store?: boolean, newKey?: string, overwrite?: boolean, draft?: boolean, jsonResponse?: boolean): PackageManager;
+    createManager(key?: string, spaceKey?: string, fileName?: string, store?: boolean, newKey?: string, overwrite?: boolean, draft?: boolean): PackageManager;
     private isPackageFilePath;
     private resolvePackageFilePath;
 }

package/lib/content/manager/package.manager.d.ts

@@ -13,7 +13,6 @@ export declare class PackageManager extends BaseManager {
     private _newKey;
     private _overwrite;
     private _draft;
-    private _jsonResponse;
     get key(): string;
     set key(value: string);
     get spaceKey(): string;
@@ -28,8 +27,6 @@ export declare class PackageManager extends BaseManager {
     set overwrite(value: boolean);
     get draft(): boolean;
     set draft(value: boolean);
-    get jsonResponse(): boolean;
-    set jsonResponse(value: boolean);
     getConfig(): ManagerConfig;
     getBody(): any;
     protected getSerializedFileContent(data: any): string;

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

@@ -1 +1,7 @@
+import commander = require("commander");
+declare type CommanderStatic = commander.CommanderStatic;
+export declare class List {
+    static packages(program: CommanderStatic): CommanderStatic;
+    static spaces(program: CommanderStatic): CommanderStatic;
+}
 export {};

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

@@ -0,0 +1,9 @@
+import { ContentNodeTransport, PackageDependencyTransport, PackageHistoryTransport, StudioDataModelTransport, VariablesAssignments } from "./package-manager.interfaces";
+export interface BatchExportNodeTransport extends ContentNodeTransport {
+    workingDraftId: string;
+    activatedDraftId: string;
+    version?: PackageHistoryTransport;
+    dependencies?: PackageDependencyTransport[];
+    datamodels?: StudioDataModelTransport[];
+    variables?: VariablesAssignments[];
+}

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

@@ -7,4 +7,5 @@ export interface ManagerConfig {
     onPushSuccessMessage?: (data: any) => string;
     onUpdateSuccessMessage?: () => string;
     onFindAll?: (data: any) => void;
+    onFindAllAndExport?: (data: any) => void;
 }

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

@@ -0,0 +1,59 @@
+export interface AssetMetadataTransport {
+    hidden: boolean;
+}
+export interface ContentNodeTransport {
+    id: string;
+    key: string;
+    name: string;
+    rootNodeKey: string;
+    workingDraftId: string;
+    activatedDraftId: string;
+    rootNodeId: string;
+    assetMetadataTransport: AssetMetadataTransport;
+    spaceId: string;
+}
+export interface DataModelTransport {
+    id: string;
+    name: string;
+    poolId: string;
+}
+export interface PackageDependencyTransport {
+    id: string;
+    key: string;
+    name: string;
+    version: string;
+    rootNodeId: string;
+}
+export interface AssetMetadataTransport {
+    hidden: boolean;
+}
+export interface PackageWithVariableAssignments {
+    id: string;
+    key: string;
+    name: string;
+    createdBy: string;
+    variableAssignments: VariablesAssignments[];
+}
+export interface VariablesAssignments {
+    key: string;
+    value: object;
+    type: string;
+}
+export interface PackageHistoryTransport {
+    id: string;
+    key: string;
+    name: string;
+    version: string;
+}
+export interface StudioDataModelTransport {
+    node: StudioComputeNodeDescriptor;
+    dataPool: ComputePoolTransport;
+}
+export interface StudioComputeNodeDescriptor {
+    name: string;
+    dataModelId: string;
+}
+export interface ComputePoolTransport {
+    id: string;
+    name: string;
+}

package/lib/interfaces/save-content-node.interface.d.ts

@@ -1,3 +1,4 @@
+import { AssetMetadataTransport } from "./package-manager.interfaces";
 export interface SaveContentNode {
     key: string;
     rootNodeKey: string;
@@ -7,6 +8,3 @@ export interface SaveContentNode {
     serializedContent: string;
     assetMetadataTransport: AssetMetadataTransport;
 }
-export declare class AssetMetadataTransport {
-    hidden: boolean;
-}

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

@@ -0,0 +1,13 @@
+import { Profile } from "../interfaces/profile.interface";
+interface Context {
+    profile: Profile;
+}
+declare class ContextService {
+    static readonly INSTANCE: ContextService;
+    private context;
+    getContext(): Context;
+    resolveProfile(profile: string): Promise<void>;
+    setContext(context: Context): void;
+}
+export declare const contextService: ContextService;
+export {};

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

@@ -0,0 +1,6 @@
+export declare class FileService {
+    static readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
+    writeToFileWithGivenName(data: any, filename: string): void;
+    private getSerializedFileContent;
+}
+export declare const fileService: FileService;

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

@@ -0,0 +1,11 @@
+declare class HttpClientServiceV2 {
+    get(url: string): Promise<any>;
+    private resolveUrl;
+    private handleResponse;
+    private checkBadRequest;
+    private handleBadRequest;
+    private makeOptions;
+    private buildAuthorizationHeaders;
+}
+export declare const httpClientV2: HttpClientServiceV2;
+export {};

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

@@ -0,0 +1,7 @@
+import { BatchExportNodeTransport } from "../../interfaces/batch-export-node-transport";
+declare class DatamodelService {
+    static readonly INSTANCE: DatamodelService;
+    getDatamodelsForNodes(nodesListToExport: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
+}
+export declare const dataModelService: DatamodelService;
+export {};

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

@@ -0,0 +1,13 @@
+import { BatchExportNodeTransport } from "../../interfaces/batch-export-node-transport";
+import { PackageDependencyTransport } from "../../interfaces/package-manager.interfaces";
+declare class PackageService {
+    protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
+    listPackages(): Promise<void>;
+    findAndExportAllPackages(includeDependencies: boolean): Promise<void>;
+    getPackagesDependenciesByPackageId(nodeIds: string[], draftIdByNodeId: Map<string, string>): Promise<Map<string, PackageDependencyTransport[]>>;
+    getVersionOfPackages(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
+    getPackagesWithDependencies(nodeIds: string[], draftIdByNodeId: Map<string, string>): Promise<PackageDependencyTransport[]>;
+    private exportListOfPackages;
+}
+export declare const packageService: PackageService;
+export {};

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

@@ -0,0 +1,6 @@
+import { VariablesAssignments } from "../../interfaces/package-manager.interfaces";
+declare class VariableService {
+    getVariablesByNodeKey(): Promise<Map<string, VariablesAssignments[]>>;
+}
+export declare const variableService: VariableService;
+export {};

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

@@ -18,3 +18,4 @@ export declare class ProfileService {
     private getProfileEnvVariables;
     private getBaseTeamUrl;
 }
+export declare const profileService: ProfileService;

package/package.json

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

package/services/context.service.js

@@ -0,0 +1,39 @@
+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", "./profile.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const profile_service_1 = require("./profile.service");
+    class ContextService {
+        getContext() {
+            return this.context;
+        }
+        resolveProfile(profile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const resolvedProfile = yield profile_service_1.profileService.findProfile(profile);
+                this.setContext({ profile: resolvedProfile });
+            });
+        }
+        ;
+        setContext(context) {
+            this.context = context;
+        }
+    }
+    ContextService.INSTANCE = new ContextService();
+    exports.contextService = ContextService.INSTANCE;
+});

package/services/file-service.js

@@ -0,0 +1,27 @@
+(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", "fs", "path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const fs = require("fs");
+    const path = require("path");
+    class FileService {
+        writeToFileWithGivenName(data, filename) {
+            fs.writeFileSync(path.resolve(process.cwd(), filename), this.getSerializedFileContent(data), {
+                encoding: "utf-8",
+            });
+        }
+        getSerializedFileContent(data) {
+            return data;
+        }
+    }
+    exports.FileService = FileService;
+    FileService.fileDownloadedMessage = "File downloaded successfully. New filename: ";
+    exports.fileService = new FileService();
+});

package/services/http-client-service.v2.js

@@ -0,0 +1,84 @@
+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", "../interfaces/profile.interface", "request", "./context.service", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const profile_interface_1 = require("../interfaces/profile.interface");
+    const request = require("request");
+    const context_service_1 = require("./context.service");
+    const logger_1 = require("../util/logger");
+    class HttpClientServiceV2 {
+        get(url) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return new Promise((resolve, reject) => {
+                    request.get(this.resolveUrl(url), this.makeOptions(context_service_1.contextService.getContext().profile, null), (err, res) => {
+                        this.handleResponse(res, resolve, reject);
+                    });
+                }).catch(e => {
+                    throw new logger_1.FatalError(e);
+                });
+            });
+        }
+        resolveUrl(url) {
+            return context_service_1.contextService.getContext().profile.team.replace(/\/?$/, url);
+        }
+        handleResponse(res, resolve, reject) {
+            if (this.checkBadRequest(res.statusCode)) {
+                this.handleBadRequest(res.statusCode, res.body, reject);
+                return;
+            }
+            let body = {};
+            try {
+                if (res.body) {
+                    body = JSON.parse(res.body);
+                }
+            }
+            catch (e) {
+                reject("Something went wrong. Please check that you have the right url and api key.");
+                return;
+            }
+            resolve(body);
+        }
+        checkBadRequest(statusCode) {
+            return statusCode >= 400;
+        }
+        // tslint:disable-next-line:typedef
+        handleBadRequest(statusCode, data, reject) {
+            if (data) {
+                reject(data);
+            }
+            else {
+                reject("Backend responded with status code " + statusCode);
+            }
+        }
+        makeOptions(profile, body = {}) {
+            const options = {
+                headers: this.buildAuthorizationHeaders(profile),
+            };
+            return Object.assign(options, body);
+        }
+        buildAuthorizationHeaders(profile) {
+            const authenticationType = profile.authenticationType || profile_interface_1.AuthenticationType.BEARER;
+            return {
+                authorization: `${authenticationType} ${profile.apiToken}`,
+                "content-type": "application/json",
+            };
+        }
+    }
+    exports.httpClientV2 = new HttpClientServiceV2();
+});

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

@@ -0,0 +1,38 @@
+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/compute-pool-api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const compute_pool_api_1 = require("../../api/compute-pool-api");
+    class DatamodelService {
+        getDatamodelsForNodes(nodesListToExport) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const promises = [];
+                nodesListToExport.forEach(node => {
+                    promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                        node.datamodels = yield compute_pool_api_1.computePoolApi.findAssignedDatamodels(node.key);
+                        resolve(node);
+                    })));
+                });
+                return Promise.all(promises);
+            });
+        }
+    }
+    DatamodelService.INSTANCE = new DatamodelService();
+    exports.dataModelService = DatamodelService.INSTANCE;
+});

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

@@ -0,0 +1,106 @@
+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", "../../util/logger", "../../api/package-api", "uuid", "../file-service", "./datamodel-service", "../../api/node-api", "../../api/package-dependencies-api"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const logger_1 = require("../../util/logger");
+    const package_api_1 = require("../../api/package-api");
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../file-service");
+    const datamodel_service_1 = require("./datamodel-service");
+    const node_api_1 = require("../../api/node-api");
+    const package_dependencies_api_1 = require("../../api/package-dependencies-api");
+    class PackageService {
+        constructor() {
+            this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
+        }
+        listPackages() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodes = yield package_api_1.packageApi.findAllPackages();
+                nodes.forEach(node => {
+                    logger_1.logger.info(`${node.name} - Key: "${node.key}"`);
+                });
+            });
+        }
+        findAndExportAllPackages(includeDependencies) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const fieldsToInclude = ["key", "name", "changeDate", "activatedDraftId", "spaceId"];
+                let nodesListToExport = yield package_api_1.packageApi.findAllPackages();
+                if (includeDependencies) {
+                    fieldsToInclude.push("type", "value", "dependencies", "id", "version", "poolId", "node", "dataModelId", "dataPool", "datamodels");
+                    const packagesKeyWithActionFlows = (yield node_api_1.nodeApi.findAllNodesOfType("SCENARIO")).map(node => node.rootNodeKey);
+                    nodesListToExport = nodesListToExport.filter(node => {
+                        return !packagesKeyWithActionFlows.includes(node.rootNodeKey);
+                    });
+                    //TODO need to replace all these individual calls with a single api call that gets all the required data.
+                    nodesListToExport = yield this.getVersionOfPackages(nodesListToExport);
+                    nodesListToExport = yield datamodel_service_1.dataModelService.getDatamodelsForNodes(nodesListToExport);
+                    const draftIdByNodeId = new Map();
+                    const nodeIds = nodesListToExport.map(node => {
+                        draftIdByNodeId.set(node.id, node.workingDraftId);
+                        return node.id;
+                    });
+                    const dependenciesByPackageId = yield this.getPackagesDependenciesByPackageId(nodeIds, draftIdByNodeId);
+                    nodesListToExport = nodesListToExport.map(nodeToExport => {
+                        nodeToExport.dependencies = dependenciesByPackageId.get(nodeToExport.id);
+                        return nodeToExport;
+                    });
+                }
+                this.exportListOfPackages(nodesListToExport, fieldsToInclude);
+            });
+        }
+        getPackagesDependenciesByPackageId(nodeIds, draftIdByNodeId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dependenciesByPackageKey = new Map();
+                const packageWithDependencies = yield this.getPackagesWithDependencies(nodeIds, draftIdByNodeId);
+                packageWithDependencies.forEach(packageWithDependency => {
+                    var _a;
+                    const dependenciesOfPackage = (_a = dependenciesByPackageKey.get(packageWithDependency.rootNodeId)) !== null && _a !== void 0 ? _a : [];
+                    dependenciesOfPackage.push(packageWithDependency);
+                    dependenciesByPackageKey.set(packageWithDependency.rootNodeId, dependenciesOfPackage);
+                });
+                return dependenciesByPackageKey;
+            });
+        }
+        getVersionOfPackages(nodes) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const promises = [];
+                nodes.forEach(node => {
+                    promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                        node.version = yield package_api_1.packageApi.findLatestVersionById(node.id);
+                        resolve(node);
+                    })));
+                });
+                return Promise.all(promises);
+            });
+        }
+        getPackagesWithDependencies(nodeIds, draftIdByNodeId) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const promises = [];
+                nodeIds.forEach((nodeId) => __awaiter(this, void 0, void 0, function* () { return promises.push(package_dependencies_api_1.packageDependenciesApi.findDependenciesOfPackage(nodeId, draftIdByNodeId.get(nodeId))); }));
+                return yield Promise.all(promises);
+            });
+        }
+        exportListOfPackages(nodes, fieldsToInclude) {
+            const filename = uuid_1.v4() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes, fieldsToInclude), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+    }
+    exports.packageService = new PackageService();
+});

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

@@ -0,0 +1,35 @@
+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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const package_api_1 = require("../../api/package-api");
+    class VariableService {
+        getVariablesByNodeKey() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const nodeWithVariablesAssignments = yield package_api_1.packageApi.findAllPackagesWithVariableAssignments();
+                const variablesByNodeKey = new Map();
+                nodeWithVariablesAssignments.forEach(nodeWithVariablesAssignment => {
+                    variablesByNodeKey.set(nodeWithVariablesAssignment.key, nodeWithVariablesAssignment.variableAssignments);
+                });
+                return variablesByNodeKey;
+            });
+        }
+    }
+    exports.variableService = new VariableService();
+});

package/services/profile.service.js

@@ -142,4 +142,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
     }
     exports.ProfileService = ProfileService;
+    exports.profileService = new ProfileService();
 });