@celonis/content-cli 0.13.4 → 1.0.0

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,16 +91,31 @@ 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);
             });
         }
+        findAndExportListOfActivePackagesByVariableValue(flavors, variableValue, variableType) {
+            return __awaiter(this, void 0, void 0, function* () {
+                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 this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType);
+                packagesByVariableValue.forEach(pkg => {
+                    logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
+                });
+            });
+        }
         exportListOfPackages(packages) {
             const filename = (0, uuid_1.v4)() + ".json";
             file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(packages), filename);
@@ -118,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();
@@ -147,5 +167,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return null;
         }
     }
-    exports.batchImportExportService = new BatchImportExportService();
+    exports.BatchImportExportService = BatchImportExportService;
 });

package/commands/configuration-management/config-command.service.js

@@ -0,0 +1,76 @@
+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", "./batch-import-export.service", "./variable.service", "./diff.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    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) {
+                    yield this.listPackagesByVariableValue(jsonResponse, flavors, variableValue, variableType);
+                    return;
+                }
+                if (jsonResponse) {
+                    yield this.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
+                }
+                else {
+                    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 this.variableService.exportVariables(keysByVersion, keysByVersionFile);
+                }
+                else {
+                    yield this.variableService.listVariables(keysByVersion, keysByVersionFile);
+                }
+            });
+        }
+        batchExportPackages(packageKeys, withDependencies = false) {
+            return this.batchImportExportService.batchExportPackages(packageKeys, withDependencies);
+        }
+        batchImportPackages(file, overwrite) {
+            return this.batchImportExportService.batchImportPackages(file, overwrite);
+        }
+        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 this.batchImportExportService.findAndExportListOfActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
+                }
+                else {
+                    yield this.batchImportExportService.listActivePackagesByVariableValue(flavors !== null && flavors !== void 0 ? flavors : [], variableValue, variableType);
+                }
+            });
+        }
+    }
+    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;
+});

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

@@ -13,31 +13,40 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../api/package-api", "../../interfaces/package-manager.interfaces", "../package-manager/datamodel-service", "../../util/json", "../../api/node-api", "../../api/variables-api", "../../api/space-api", "../package-manager/space-service", "../package-manager/variable-service", "../../interfaces/batch-export-import-constants", "adm-zip"], factory);
+        define(["require", "exports", "adm-zip", "../studio/interfaces/package-manager.interfaces", "./interfaces/batch-export-import.constants", "../../core/utils/json", "../studio/api/package-api", "../studio/service/data-model.service", "../studio/api/node-api", "../studio/api/space-api", "../studio/api/studio-variables-api", "../studio/service/space.service", "../studio/service/studio-variable.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.studioService = void 0;
-    const package_api_1 = require("../../api/package-api");
-    const package_manager_interfaces_1 = require("../../interfaces/package-manager.interfaces");
-    const datamodel_service_1 = require("../package-manager/datamodel-service");
-    const json_1 = require("../../util/json");
-    const node_api_1 = require("../../api/node-api");
-    const variables_api_1 = require("../../api/variables-api");
-    const space_api_1 = require("../../api/space-api");
-    const space_service_1 = require("../package-manager/space-service");
-    const variable_service_1 = require("../package-manager/variable-service");
-    const batch_export_import_constants_1 = require("../../interfaces/batch-export-import-constants");
+    exports.StudioService = void 0;
     const AdmZip = require("adm-zip");
+    const package_manager_interfaces_1 = require("../studio/interfaces/package-manager.interfaces");
+    const batch_export_import_constants_1 = require("./interfaces/batch-export-import.constants");
+    const json_1 = require("../../core/utils/json");
+    const package_api_1 = require("../studio/api/package-api");
+    const data_model_service_1 = require("../studio/service/data-model.service");
+    const node_api_1 = require("../studio/api/node-api");
+    const space_api_1 = require("../studio/api/space-api");
+    const studio_variables_api_1 = require("../studio/api/studio-variables-api");
+    const space_service_1 = require("../studio/service/space.service");
+    const studio_variable_service_1 = require("../studio/service/studio-variable.service");
     class StudioService {
+        constructor(context) {
+            this.studioPackageApi = new package_api_1.PackageApi(context);
+            this.studioNodeApi = new node_api_1.NodeApi(context);
+            this.studioSpaceApi = new space_api_1.SpaceApi(context);
+            this.studioVariablesApi = new studio_variables_api_1.StudioVariablesApi(context);
+            this.studioDataModelService = new data_model_service_1.DataModelService(context);
+            this.studioSpaceService = new space_service_1.SpaceService(context);
+            this.studioVariableService = new studio_variable_service_1.StudioVariableService(context);
+        }
         getExportPackagesWithStudioData(packagesToExport, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
-                const studioPackagesWithDataModels = yield package_api_1.packageApi.findAllPackagesWithVariableAssignments(package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
-                packagesToExport = exports.studioService.setSpaceIdForStudioPackages(packagesToExport, studioPackagesWithDataModels);
+                const studioPackagesWithDataModels = yield this.studioPackageApi.findAllPackagesWithVariableAssignments(package_manager_interfaces_1.PackageManagerVariableType.DATA_MODEL);
+                packagesToExport = this.setSpaceIdForStudioPackages(packagesToExport, studioPackagesWithDataModels);
                 if (withDependencies) {
-                    const dataModelDetailsByNode = yield datamodel_service_1.dataModelService.getDataModelDetailsForPackages(studioPackagesWithDataModels);
-                    packagesToExport = exports.studioService.setDataModelsForStudioPackages(packagesToExport, studioPackagesWithDataModels, dataModelDetailsByNode);
+                    const dataModelDetailsByNode = yield this.studioDataModelService.getDataModelDetailsForPackages(studioPackagesWithDataModels);
+                    packagesToExport = this.setDataModelsForStudioPackages(packagesToExport, studioPackagesWithDataModels, dataModelDetailsByNode);
                 }
                 return packagesToExport;
             });
@@ -53,9 +62,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         getStudioPackageManifests(studioPackageKeys) {
             return __awaiter(this, void 0, void 0, function* () {
                 return Promise.all(studioPackageKeys.map((packageKey) => __awaiter(this, void 0, void 0, function* () {
-                    const node = yield node_api_1.nodeApi.findOneByKeyAndRootNodeKey(packageKey, packageKey);
-                    const nodeSpace = yield space_api_1.spaceApi.findOne(node.spaceId);
-                    const variableAssignments = yield variables_api_1.variablesApi.getRuntimeVariableValues(packageKey, batch_export_import_constants_1.BatchExportImportConstants.APP_MODE_VIEWER);
+                    const node = yield this.studioNodeApi.findOneByKeyAndRootNodeKey(packageKey, packageKey);
+                    const nodeSpace = yield this.studioSpaceApi.findOne(node.spaceId);
+                    const variableAssignments = yield this.studioVariablesApi.getRuntimeVariableValues(packageKey, batch_export_import_constants_1.BatchExportImportConstants.APP_MODE_VIEWER);
                     return {
                         packageKey: packageKey,
                         space: {
@@ -81,7 +90,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 for (const manifest of studioManifests) {
                     const existingPackage = existingStudioPackages.find(existingPackage => existingPackage.key === manifest.packageKey);
                     if (existingPackage) {
-                        yield package_api_1.packageApi.movePackageToSpace(existingPackage.id, manifest.space.id);
+                        yield this.studioPackageApi.movePackageToSpace(existingPackage.id, manifest.space.id);
                     }
                     yield this.assignRuntimeVariables(manifest);
                 }
@@ -185,7 +194,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         findDesiredSpaceIdForPackage(studioPackageManifest) {
             return __awaiter(this, void 0, void 0, function* () {
-                const allSpaces = yield space_service_1.spaceService.refreshAndGetAllSpaces();
+                const allSpaces = yield this.studioSpaceService.refreshAndGetAllSpaces();
                 if (studioPackageManifest.space.id) {
                     const targetSpace = allSpaces.find(space => space.id === studioPackageManifest.space.id);
                     if (!targetSpace) {
@@ -197,14 +206,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 if (targetSpaceByName) {
                     return targetSpaceByName.id;
                 }
-                const spaceTransport = yield space_service_1.spaceService.createSpace(studioPackageManifest.space.name, studioPackageManifest.space.iconReference);
+                const spaceTransport = yield this.studioSpaceService.createSpace(studioPackageManifest.space.name, studioPackageManifest.space.iconReference);
                 return spaceTransport.id;
             });
         }
         assignRuntimeVariables(manifest) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (manifest.runtimeVariableAssignments.length) {
-                    yield variable_service_1.variableService.assignVariableValues(manifest.packageKey, manifest.runtimeVariableAssignments);
+                    yield this.studioVariableService.assignVariableValues(manifest.packageKey, manifest.runtimeVariableAssignments);
                 }
             });
         }
@@ -215,5 +224,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return nodeContent;
         }
     }
-    exports.studioService = new StudioService();
+    exports.StudioService = StudioService;
 });

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

@@ -13,24 +13,27 @@ 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/variable-service"], factory);
+        define(["require", "exports", "./variable.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.VariableCommand = void 0;
-    const variable_service_1 = require("../services/package-manager/variable-service");
-    class VariableCommand {
+    exports.VariableCommandService = void 0;
+    const variable_service_1 = require("./variable.service");
+    class VariableCommandService {
+        constructor(context) {
+            this.variableService = new variable_service_1.VariableService(context);
+        }
         listAssignments(variableType, jsonResponse, params) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (jsonResponse) {
-                    yield variable_service_1.variableService.findAndExportCandidateAssignments(variableType, params);
+                    yield this.variableService.findAndExportCandidateAssignments(variableType, params);
                 }
                 else {
-                    yield variable_service_1.variableService.listCandidateAssignments(variableType, params);
+                    yield this.variableService.listCandidateAssignments(variableType, params);
                 }
             });
         }
     }
-    exports.VariableCommand = VariableCommand;
+    exports.VariableCommandService = VariableCommandService;
 });