@celonis/content-cli 0.13.6 → 1.0.3

package/commands/configuration-management/api/batch-import-export-api.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", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BatchImportExportApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    class BatchImportExportApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
+        findAllActivePackages(flavors, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("withDependencies", withDependencies.toString());
+                flavors.forEach(flavor => queryParams.append("flavors", flavor));
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages: ${e}`);
+                });
+            });
+        }
+        findActivePackagesByVariableValue(flavors, variableValue, variableType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                queryParams.set("variableValue", variableValue);
+                if (variableType) {
+                    queryParams.set("variableType", variableType);
+                }
+                flavors.forEach(flavor => queryParams.append("flavors", flavor));
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list-by-variable-value?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages by variable value: ${e}`);
+                });
+            });
+        }
+        findActivePackagesByKeys(packageKeys, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                packageKeys.forEach(key => queryParams.append("packageKeys", key));
+                queryParams.set("withDependencies", withDependencies.toString());
+                return this.httpClient.get(`/package-manager/api/core/packages/export/list-by-keys?${queryParams.toString()}`).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting active packages by keys: ${e}`);
+                });
+            });
+        }
+        exportPackages(packageKeys, withDependencies = false) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const queryParams = new URLSearchParams();
+                packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
+                queryParams.set("withDependencies", withDependencies.toString());
+                return this.httpClient.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 __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient.postFile("/package-manager/api/core/packages/import/batch", data, { overwrite });
+            });
+        }
+        findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.httpClient.post("/package-manager/api/core/packages/export/batch/variables-with-assignments", packagesByKeyAndVersion).catch(e => {
+                    throw new logger_1.FatalError(`Problem exporting package variables: ${e}`);
+                });
+            });
+        }
+    }
+    exports.BatchImportExportApi = BatchImportExportApi;
+});

package/{api → commands/configuration-management/api}/diff-api.js

@@ -13,25 +13,26 @@ 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"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.diffApi = void 0;
-    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    exports.DiffApi = void 0;
     class DiffApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         diffPackages(data) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/core/packages/diff/configuration", data);
+                return this.httpClient.postFile("/package-manager/api/core/packages/diff/configuration", data);
             });
         }
         hasChanges(data) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/core/packages/diff/configuration/has-changes", data);
+                return this.httpClient.postFile("/package-manager/api/core/packages/diff/configuration/has-changes", data);
             });
         }
     }
-    DiffApi.INSTANCE = new DiffApi();
-    exports.diffApi = DiffApi.INSTANCE;
+    exports.DiffApi = DiffApi;
 });

package/commands/configuration-management/api/variable-assignment-candidates-api.js

@@ -0,0 +1,41 @@
+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/variable-assignment-apis.constants", "../../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VariableAssignmentCandidatesApi = void 0;
+    const variable_assignment_apis_constants_1 = require("../interfaces/variable-assignment-apis.constants");
+    const logger_1 = require("../../../core/utils/logger");
+    class VariableAssignmentCandidatesApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
+        getCandidateAssignments(type, params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!variable_assignment_apis_constants_1.variableAssignmentApis[type]) {
+                    throw new logger_1.FatalError(`Variable type ${type} not supported.`);
+                }
+                const apiUrl = variable_assignment_apis_constants_1.variableAssignmentApis[type].url + (params.toString().length ? `?${params.toString()}` : "");
+                return this.httpClient.get(apiUrl).catch(e => {
+                    throw new logger_1.FatalError(`Problem getting variables assignment values for type ${type}: ${e}`);
+                });
+            });
+        }
+    }
+    exports.VariableAssignmentCandidatesApi = VariableAssignmentCandidatesApi;
+});

package/{services/package-manager/batch-import-export-service.js → commands/configuration-management/batch-import-export.service.js}

@@ -13,27 +13,32 @@ 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", "../../util/json", "form-data", "../../interfaces/batch-export-import-constants", "../../api/package-api", "stream", "adm-zip"], factory);
+        define(["require", "exports", "uuid", "form-data", "stream", "adm-zip", "./interfaces/batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/batch-import-export-api", "./studio.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.batchImportExportService = void 0;
-    const batch_import_export_api_1 = require("../../api/batch-import-export-api");
-    const logger_1 = require("../../util/logger");
+    exports.BatchImportExportService = void 0;
     const uuid_1 = require("uuid");
-    const file_service_1 = require("../file-service");
-    const studio_service_1 = require("../studio/studio.service");
-    const json_1 = require("../../util/json");
     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");
+    const batch_export_import_constants_1 = require("./interfaces/batch-export-import.constants");
+    const file_service_1 = require("../../core/utils/file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const json_1 = require("../../core/utils/json");
+    const package_api_1 = require("../studio/api/package-api");
+    const batch_import_export_api_1 = require("./api/batch-import-export-api");
+    const studio_service_1 = require("./studio.service");
     class BatchImportExportService {
+        constructor(context) {
+            this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
+            this.studioPackageApi = new package_api_1.PackageApi(context);
+            this.studioService = new studio_service_1.StudioService(context);
+        }
         listActivePackages(flavors) {
             return __awaiter(this, void 0, void 0, function* () {
-                const activePackages = yield batch_import_export_api_1.batchImportExportApi.findAllActivePackages(flavors);
+                const activePackages = yield this.batchImportExportApi.findAllActivePackages(flavors);
                 activePackages.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -43,34 +48,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 let packagesToExport;
                 if (packageKeys.length) {
-                    packagesToExport = yield batch_import_export_api_1.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
+                    packagesToExport = yield this.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
                 }
                 else {
-                    packagesToExport = yield batch_import_export_api_1.batchImportExportApi.findAllActivePackages(flavors, withDependencies);
+                    packagesToExport = yield this.batchImportExportApi.findAllActivePackages(flavors, withDependencies);
                 }
-                packagesToExport = yield studio_service_1.studioService.getExportPackagesWithStudioData(packagesToExport, withDependencies);
+                packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, withDependencies);
                 this.exportListOfPackages(packagesToExport);
             });
         }
         batchExportPackages(packageKeys, withDependencies = false) {
             return __awaiter(this, void 0, void 0, function* () {
-                const exportedPackagesData = yield batch_import_export_api_1.batchImportExportApi.exportPackages(packageKeys, withDependencies);
+                const exportedPackagesData = yield this.batchImportExportApi.exportPackages(packageKeys, withDependencies);
                 const exportedPackagesZip = new AdmZip(exportedPackagesData);
                 const manifest = (0, json_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);
+                exportedVariables = this.studioService.fixConnectionVariables(exportedVariables);
                 exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME, Buffer.from((0, json_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);
+                const studioData = yield this.studioService.getStudioPackageManifests(studioPackageKeys);
                 exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.STUDIO_FILE_NAME, Buffer.from((0, json_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);
+                            const updatedPackage = this.studioService.processPackageForExport(entry, exportedVariables);
                             exportedPackagesZip.updateFile(entry, updatedPackage.toBuffer());
                         }
                     }
@@ -86,11 +91,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 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();
+                configs = yield this.studioService.mapSpaces(configs, studioManifests);
+                const existingStudioPackages = yield this.studioPackageApi.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 postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite);
+                yield this.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);
@@ -98,14 +103,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         findAndExportListOfActivePackagesByVariableValue(flavors, variableValue, variableType) {
             return __awaiter(this, void 0, void 0, function* () {
-                let packagesToExport = yield batch_import_export_api_1.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType);
-                packagesToExport = yield studio_service_1.studioService.getExportPackagesWithStudioData(packagesToExport, false);
+                let packagesToExport = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType);
+                packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, false);
                 this.exportListOfPackages(packagesToExport);
             });
         }
         listActivePackagesByVariableValue(flavors, variableValue, variableType) {
             return __awaiter(this, void 0, void 0, function* () {
-                const packagesByVariableValue = yield batch_import_export_api_1.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType);
+                const packagesByVariableValue = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType);
                 packagesByVariableValue.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -133,7 +138,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     });
                 });
             });
-            return batch_import_export_api_1.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
+            return this.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
         }
         buildBodyForImport(configs, variablesManifests) {
             const formData = new FormData();
@@ -162,5 +167,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return null;
         }
     }
-    exports.batchImportExportService = new BatchImportExportService();
+    exports.BatchImportExportService = BatchImportExportService;
 });

package/commands/{config.command.js → configuration-management/config-command.service.js}

@@ -13,16 +13,21 @@ 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", "../services/package-manager/variable-service", "../services/package-manager/diff-service"], factory);
+        define(["require", "exports", "./batch-import-export.service", "./variable.service", "./diff.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");
-    const diff_service_1 = require("../services/package-manager/diff-service");
-    class ConfigCommand {
+    exports.ConfigCommandService = void 0;
+    const batch_import_export_service_1 = require("./batch-import-export.service");
+    const variable_service_1 = require("./variable.service");
+    const diff_service_1 = require("./diff.service");
+    class ConfigCommandService {
+        constructor(context) {
+            this.batchImportExportService = new batch_import_export_service_1.BatchImportExportService(context);
+            this.variableService = new variable_service_1.VariableService(context);
+            this.diffService = new diff_service_1.DiffService(context);
+        }
         listActivePackages(jsonResponse, flavors, withDependencies, packageKeys, variableValue, variableType) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (variableValue) {
@@ -30,42 +35,42 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     return;
                 }
                 if (jsonResponse) {
-                    yield batch_import_export_service_1.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
+                    yield this.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
                 }
                 else {
-                    yield batch_import_export_service_1.batchImportExportService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : []);
+                    yield this.batchImportExportService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : []);
                 }
             });
         }
         listVariables(jsonResponse, keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (jsonResponse) {
-                    yield variable_service_1.variableService.exportVariables(keysByVersion, keysByVersionFile);
+                    yield this.variableService.exportVariables(keysByVersion, keysByVersionFile);
                 }
                 else {
-                    yield variable_service_1.variableService.listVariables(keysByVersion, keysByVersionFile);
+                    yield this.variableService.listVariables(keysByVersion, keysByVersionFile);
                 }
             });
         }
         batchExportPackages(packageKeys, withDependencies = false) {
-            return batch_import_export_service_1.batchImportExportService.batchExportPackages(packageKeys, withDependencies);
+            return this.batchImportExportService.batchExportPackages(packageKeys, withDependencies);
         }
         batchImportPackages(file, overwrite) {
-            return batch_import_export_service_1.batchImportExportService.batchImportPackages(file, overwrite);
+            return this.batchImportExportService.batchImportPackages(file, overwrite);
         }
         diffPackages(file, hasChanges, jsonResponse) {
-            return diff_service_1.diffService.diffPackages(file, hasChanges, jsonResponse);
+            return this.diffService.diffPackages(file, hasChanges, jsonResponse);
         }
         listPackagesByVariableValue(jsonResponse, flavors, variableValue, variableType) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (jsonResponse) {
-                    yield batch_import_export_service_1.batchImportExportService.findAndExportListOfActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
+                    yield this.batchImportExportService.findAndExportListOfActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
                 }
                 else {
-                    yield batch_import_export_service_1.batchImportExportService.listActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
+                    yield this.batchImportExportService.listActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
                 }
             });
         }
     }
-    exports.ConfigCommand = ConfigCommand;
+    exports.ConfigCommandService = ConfigCommandService;
 });

package/{services/package-manager/diff-service.js → commands/configuration-management/diff.service.js}

@@ -13,20 +13,23 @@ 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", "adm-zip", "stream", "form-data", "../../api/diff-api", "../file-service", "../../util/logger", "uuid"], factory);
+        define(["require", "exports", "adm-zip", "stream", "form-data", "uuid", "../../core/utils/logger", "../../core/utils/file-service", "./api/diff-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.diffService = void 0;
+    exports.DiffService = void 0;
     const AdmZip = require("adm-zip");
     const stream_1 = require("stream");
     const FormData = require("form-data");
-    const diff_api_1 = require("../../api/diff-api");
-    const file_service_1 = require("../file-service");
-    const logger_1 = require("../../util/logger");
     const uuid_1 = require("uuid");
+    const logger_1 = require("../../core/utils/logger");
+    const file_service_1 = require("../../core/utils/file-service");
+    const diff_api_1 = require("./api/diff-api");
     class DiffService {
+        constructor(context) {
+            this.diffApi = new diff_api_1.DiffApi(context);
+        }
         diffPackages(file, hasChanges, jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (hasChanges) {
@@ -41,7 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 const packages = new AdmZip(file);
                 const formData = this.buildBodyForDiff(packages);
-                const returnedHasChangesData = yield diff_api_1.diffApi.hasChanges(formData);
+                const returnedHasChangesData = yield this.diffApi.hasChanges(formData);
                 if (jsonResponse) {
                     this.exportListOfPackageDiffMetadata(returnedHasChangesData);
                 }
@@ -54,7 +57,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 const packages = new AdmZip(file);
                 const formData = this.buildBodyForDiff(packages);
-                const returnedHasChangesData = yield diff_api_1.diffApi.diffPackages(formData);
+                const returnedHasChangesData = yield this.diffApi.diffPackages(formData);
                 if (jsonResponse) {
                     this.exportListOfPackageDiffs(returnedHasChangesData);
                 }
@@ -94,5 +97,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return "\n" + JSON.stringify(packageDiffMetadata, null, 2);
         }
     }
-    exports.diffService = new DiffService();
+    exports.DiffService = DiffService;
 });

package/commands/configuration-management/module.js

@@ -0,0 +1,102 @@
+/**
+ * Commands related to Celonis configuration management.
+ */
+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", "../../core/command/module-handler", "./config-command.service", "./variable-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const config_command_service_1 = require("./config-command.service");
+    const variable_command_service_1 = require("./variable-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const configCommand = configurator.command("config");
+            configCommand.command("list")
+                .description("Command to list active packages that can be exported")
+                .option("--json", "Return response as json type", "")
+                .option("--flavors <flavors...>", "Lists only active packages of the given flavors")
+                .option("--withDependencies", "Include dependencies", "")
+                .option("--packageKeys <packageKeys...>", "Lists only given package keys")
+                .option("--variableValue <variableValue>", "Variable value for filtering packages by.")
+                .option("--variableType <variableType>", "Variable type for filtering packages by.")
+                .action(this.listActivePackages);
+            configCommand.command("export")
+                .description("Command to export package configs")
+                .requiredOption("--packageKeys <packageKeys...>", "Keys of packages to export")
+                .option("--withDependencies", "Include variables and dependencies", "")
+                .action(this.batchExportPackages);
+            configCommand.command("import")
+                .description("Command to import package configs")
+                .option("--overwrite", "Flag to allow overwriting of packages")
+                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
+                .action(this.batchImportPackages);
+            configCommand.command("diff")
+                .description("Command to diff configs of packages")
+                .option("--hasChanges", "Flag to return only the information if the package has changes without the actual changes")
+                .option("--json", "Return the response as a JSON file")
+                .requiredOption("-f, --file <file>", "Exported packages file (relative or absolute path)")
+                .action(this.diffPackages);
+            const variablesCommand = configCommand.command("variables")
+                .description("Commands related to variable configs");
+            variablesCommand.command("list")
+                .description("Command to list versioned variables of 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(this.listVariables);
+            const listCommand = configurator.command("list");
+            listCommand.command("assignments")
+                .description("Command to list possible variable assignments for a type")
+                .option("--json", "Return response as json type", "")
+                .requiredOption("--type <type>", "Type of variable")
+                .option("--params <params>", "Variable query params")
+                .action(this.listAssignments);
+        }
+        listActivePackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_service_1.ConfigCommandService(context).listActivePackages(options.json, options.flavors, options.withDependencies, options.packageKeys, options.variableValue, options.variableType);
+            });
+        }
+        batchExportPackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_service_1.ConfigCommandService(context).batchExportPackages(options.packageKeys, options.withDependencies);
+            });
+        }
+        batchImportPackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_service_1.ConfigCommandService(context).batchImportPackages(options.file, options.overwrite);
+            });
+        }
+        diffPackages(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_service_1.ConfigCommandService(context).diffPackages(options.file, options.hasChanges, options.json);
+            });
+        }
+        listVariables(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_service_1.ConfigCommandService(context).listVariables(options.json, options.keysByVersion, options.keysByVersionFile);
+            });
+        }
+        listAssignments(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new variable_command_service_1.VariableCommandService(context).listAssignments(options.type, options.json, options.params);
+            });
+        }
+    }
+    return Module;
+});