@celonis/content-cli 0.3.3 → 0.4.0

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

@@ -12,6 +12,12 @@ export interface ContentNodeTransport {
     assetMetadataTransport: AssetMetadataTransport;
     spaceId: string;
 }
+export interface ActivatePackageTransport {
+    packageKey: string;
+    version: string;
+    publishMessage: string;
+    nodeIdsToExclude: string[];
+}
 export interface DataModelTransport {
     id: string;
     name: string;
@@ -23,6 +29,10 @@ export interface PackageDependencyTransport {
     name: string;
     version: string;
     rootNodeId: string;
+    external: boolean;
+    draftId: string;
+    updateAvailable: boolean;
+    deleted: boolean;
 }
 export interface AssetMetadataTransport {
     hidden: boolean;

package/lib/interfaces/save-space.interface.d.ts

@@ -1,4 +1,5 @@
-export interface SaveSpace {
+export interface SpaceTransport {
     id: string;
     name: string;
+    iconReference: string;
 }

package/lib/services/data-pool/data-pool-service.d.ts

@@ -0,0 +1,8 @@
+declare class DataPoolService {
+    listDataPools(): Promise<void>;
+    findAndExportAllPools(): Promise<void>;
+    private findAllPools;
+    private exportListOfPools;
+}
+export declare const dataPoolService: DataPoolService;
+export {};

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

@@ -1,6 +1,9 @@
+import { ManifestNodeTransport } from "../interfaces/manifest-transport";
 export declare class FileService {
     static readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     writeToFileWithGivenName(data: any, filename: string): void;
+    createDirectoryWithGivenName(dirName: string): void;
+    readManifestFile(importedFileName: string): Promise<ManifestNodeTransport[]>;
     private getSerializedFileContent;
 }
 export declare const fileService: FileService;

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

@@ -1,10 +1,18 @@
 declare class HttpClientServiceV2 {
     get(url: string): Promise<any>;
+    postFile(url: string, body: any, parameters?: {}): Promise<any>;
+    post(url: string, body: any): Promise<any>;
+    put(url: string, body: object): Promise<any>;
+    delete(url: string): Promise<any>;
+    downloadFile(url: string): Promise<any>;
+    private handleResponseStreamData;
     private resolveUrl;
+    private makeFileDownloadOptions;
     private handleResponse;
     private checkBadRequest;
     private handleBadRequest;
     private makeOptions;
+    private makeOptionsJson;
     private buildAuthorizationHeaders;
 }
 export declare const httpClientV2: HttpClientServiceV2;

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

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

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

@@ -1,13 +1,30 @@
 import { BatchExportNodeTransport } from "../../interfaces/batch-export-node-transport";
 import { PackageDependencyTransport } from "../../interfaces/package-manager.interfaces";
+import { ManifestNodeTransport } from "../../interfaces/manifest-transport";
 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[]>;
+    findAndExportListOfAllPackages(includeDependencies: boolean): Promise<void>;
+    batchImportPackages(spaceMappings: string[], exportedPackagesFile: string): Promise<void>;
+    private checkNodeForCircularDependency;
+    private importPackage;
+    private compareVersions;
+    private importPackageVersion;
+    private importDependencyPackages;
+    private checkIfPackageVersionHasBeenImported;
+    private createBodyForImport;
+    private getTargetSpaceForExportedPackage;
+    private updateDependencyVersions;
+    publishPackage(packageToImport: ManifestNodeTransport): Promise<void>;
+    batchExportPackages(packageKeys: string[], includeDependencies: boolean): Promise<void>;
+    getNodesWithActiveVersion(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
+    getPackagesWithDependencies(draftIdByNodeId: Map<string, string>, actionFlowPackageKeys: string[]): Promise<Map<string, PackageDependencyTransport[]>>;
+    private getDependencyPackages;
+    private nodeHasBeenResolvedBefore;
     private exportListOfPackages;
+    private exportPackagesAndAssets;
+    private exportToZip;
+    private exportManifestOfPackages;
 }
 export declare const packageService: PackageService;
 export {};

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

@@ -0,0 +1,11 @@
+import { BatchExportNodeTransport } from "../../interfaces/batch-export-node-transport";
+import { SpaceTransport } from "../../interfaces/save-space.interface";
+declare class SpaceService {
+    static readonly INSTANCE: SpaceService;
+    private allSpaces;
+    getParentSpaces(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
+    createSpace(spaceName: string, spaceIcon: string): Promise<SpaceTransport>;
+    getAllSpaces(): Promise<SpaceTransport[]>;
+}
+export declare const spaceService: SpaceService;
+export {};

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

@@ -1,6 +1,7 @@
-import { VariablesAssignments } from "../../interfaces/package-manager.interfaces";
+import { PackageWithVariableAssignments } from "../../interfaces/package-manager.interfaces";
+import { BatchExportNodeTransport } from "../../interfaces/batch-export-node-transport";
 declare class VariableService {
-    getVariablesByNodeKey(): Promise<Map<string, VariablesAssignments[]>>;
+    getVariableAssignmentsForNodes(nodes: BatchExportNodeTransport[]): Promise<PackageWithVariableAssignments[]>;
 }
 export declare const variableService: VariableService;
 export {};

package/package.json

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

package/services/data-pool/data-pool-service.js

@@ -0,0 +1,59 @@
+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/data-pool-api", "../../util/logger", "uuid", "../file-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const data_pool_api_1 = require("../../api/data-pool-api");
+    const logger_1 = require("../../util/logger");
+    const uuid_1 = require("uuid");
+    const file_service_1 = require("../file-service");
+    class DataPoolService {
+        listDataPools() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dataPools = yield this.findAllPools();
+                dataPools.forEach(pool => {
+                    logger_1.logger.info(`Pool Id: ${pool.id} - Pool Name: ${pool.name}`);
+                });
+            });
+        }
+        findAndExportAllPools() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dataPools = yield this.findAllPools();
+                this.exportListOfPools(dataPools);
+            });
+        }
+        findAllPools() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let page = 0;
+                const dataPools = [];
+                let tmpPage = yield data_pool_api_1.dataPoolApi.findAllPagedPools("100", page.toString());
+                while (tmpPage.pageNumber < tmpPage.totalCount) {
+                    dataPools.push(...tmpPage.content);
+                    tmpPage = yield data_pool_api_1.dataPoolApi.findAllPagedPools("100", (++page).toString());
+                }
+                return dataPools;
+            });
+        }
+        exportListOfPools(nodes) {
+            const filename = uuid_1.v4() + ".json";
+            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(nodes), filename);
+            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+        }
+    }
+    exports.dataPoolService = new DataPoolService();
+});

package/services/file-service.js

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

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

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

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

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