@celonis/content-cli 0.13.6 → 1.0.3

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

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

@@ -13,35 +13,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../api/package-api", "../../api/variables-api", "uuid", "../../util/logger", "../file-service", "url", "../studio/studio.service", "../../api/batch-import-export-api"], factory);
+        define(["require", "exports", "uuid", "../../core/utils/logger", "./studio.service", "../../core/utils/file-service", "./api/batch-import-export-api", "url", "./api/variable-assignment-candidates-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.variableService = void 0;
-    const package_api_1 = require("../../api/package-api");
-    const variables_api_1 = require("../../api/variables-api");
+    exports.VariableService = void 0;
     const uuid_1 = require("uuid");
-    const logger_1 = require("../../util/logger");
-    const file_service_1 = require("../file-service");
+    const logger_1 = require("../../core/utils/logger");
+    const studio_service_1 = require("./studio.service");
+    const file_service_1 = require("../../core/utils/file-service");
+    const batch_import_export_api_1 = require("./api/batch-import-export-api");
     const url_1 = require("url");
-    const studio_service_1 = require("../studio/studio.service");
-    const batch_import_export_api_1 = require("../../api/batch-import-export-api");
+    const variable_assignment_candidates_api_1 = require("./api/variable-assignment-candidates-api");
     class VariableService {
-        getVariableAssignmentsForNodes(type) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield package_api_1.packageApi.findAllPackagesWithVariableAssignments(type);
-            });
+        constructor(context) {
+            this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
+            this.variableAssignmentCandidatesApi = new variable_assignment_candidates_api_1.VariableAssignmentCandidatesApi(context);
+            this.studioService = new studio_service_1.StudioService(context);
         }
-        assignVariableValues(packageKey, variablesAssignments) {
+        listVariables(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield variables_api_1.variablesApi.assignVariableValues(packageKey, variablesAssignments);
+                const variableManifests = yield this.getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile);
+                variableManifests.forEach(variableManifest => {
+                    logger_1.logger.info(JSON.stringify(variableManifest));
+                });
             });
         }
         listCandidateAssignments(type, params) {
             return __awaiter(this, void 0, void 0, function* () {
                 const parsedParams = this.parseParams(params);
-                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                const assignments = yield this.variableAssignmentCandidatesApi.getCandidateAssignments(type, parsedParams);
                 assignments.forEach(assignment => {
                     logger_1.logger.info(JSON.stringify(assignment));
                 });
@@ -50,44 +52,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         findAndExportCandidateAssignments(type, params) {
             return __awaiter(this, void 0, void 0, function* () {
                 const parsedParams = this.parseParams(params);
-                const assignments = yield variables_api_1.variablesApi.getCandidateAssignments(type, parsedParams);
+                const assignments = yield this.variableAssignmentCandidatesApi.getCandidateAssignments(type, parsedParams);
                 this.exportToJson(assignments);
             });
         }
-        listVariables(keysByVersion, keysByVersionFile) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const variableManifests = yield this.getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile);
-                variableManifests.forEach(variableManifest => {
-                    logger_1.logger.info(JSON.stringify(variableManifest));
-                });
-            });
-        }
         exportVariables(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 const variableManifests = yield this.getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile);
                 this.exportToJson(variableManifests);
             });
         }
-        parseParams(params) {
-            const queryParams = new url_1.URLSearchParams();
-            if (params) {
-                try {
-                    params.split(",").forEach((param) => {
-                        const paramKeyValuePair = param.split("=");
-                        queryParams.set(paramKeyValuePair[0], paramKeyValuePair[1]);
-                    });
-                }
-                catch (e) {
-                    throw new logger_1.FatalError(`Problem parsing query params: ${e}`);
-                }
-            }
-            return queryParams;
-        }
         getVersionedVariablesByKeyVersionPairs(keysByVersion, keysByVersionFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 const variablesExportRequest = yield this.buildKeyVersionPairs(keysByVersion, keysByVersionFile);
-                const variableManifests = yield batch_import_export_api_1.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variablesExportRequest);
-                return studio_service_1.studioService.fixConnectionVariables(variableManifests);
+                const variableManifests = yield this.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variablesExportRequest);
+                return this.studioService.fixConnectionVariables(variableManifests);
             });
         }
         buildKeyVersionPairs(keysByVersion, keysByVersionFile) {
@@ -119,6 +98,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(data), filename);
             logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
         }
+        parseParams(params) {
+            const queryParams = new url_1.URLSearchParams();
+            if (params) {
+                try {
+                    params.split(",").forEach((param) => {
+                        const paramKeyValuePair = param.split("=");
+                        queryParams.set(paramKeyValuePair[0], paramKeyValuePair[1]);
+                    });
+                }
+                catch (e) {
+                    throw new logger_1.FatalError(`Problem parsing query params: ${e}`);
+                }
+            }
+            return queryParams;
+        }
     }
-    exports.variableService = new VariableService();
+    exports.VariableService = VariableService;
 });

package/commands/{ctp.command.js → cpm4/ctp-command.service.js}

@@ -13,28 +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/content.service", "../content/factory/ctp-manager.factory", "../util/logger"], factory);
+        define(["require", "exports", "../../core/utils/logger", "./ctp.manager-factory"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.CTPCommand = void 0;
-    const content_service_1 = require("../services/content.service");
-    const ctp_manager_factory_1 = require("../content/factory/ctp-manager.factory");
-    const logger_1 = require("../util/logger");
-    class CTPCommand {
-        constructor() {
-            this.contentService = new content_service_1.ContentService();
-            this.ctpManagerFactory = new ctp_manager_factory_1.CTPManagerFactory();
+    exports.CTPCommandService = void 0;
+    const logger_1 = require("../../core/utils/logger");
+    const ctp_manager_factory_1 = require("./ctp.manager-factory");
+    class CTPCommandService {
+        constructor(context) {
+            this.ctpManagerFactory = new ctp_manager_factory_1.CTPManagerFactory(context);
         }
-        pushCTPFile(profile, filename, password, pushAnalysis, pushDataModels, existingPoolId, globalPoolName, spaceKey) {
+        pushCTPFile(filename, password, pushAnalysis, pushDataModels, existingPoolId, globalPoolName, spaceKey) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (pushAnalysis) {
-                    yield this.contentService.push(profile, this.ctpManagerFactory.createCtpAnalysisManager(filename, password, spaceKey));
+                    yield this.ctpManagerFactory.createCtpAnalysisManager(filename, password, spaceKey).push();
                 }
                 if (pushDataModels) {
                     this.validateParamsForDataModelPush(existingPoolId, globalPoolName);
-                    yield this.contentService.push(profile, this.ctpManagerFactory.createCtpDataModelManager(filename, password, existingPoolId, globalPoolName));
+                    yield this.ctpManagerFactory.createCtpDataModelManager(filename, password, existingPoolId, globalPoolName).push();
                 }
             });
         }
@@ -44,5 +42,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
         }
     }
-    exports.CTPCommand = CTPCommand;
+    exports.CTPCommandService = CTPCommandService;
 });

package/{content/manager → commands/cpm4}/ctp.analysis.manager.js

@@ -13,6 +13,9 @@
     const ctp_manager_1 = require("./ctp.manager");
     const FormData = require("form-data");
     class CtpAnalysisManager extends ctp_manager_1.CtpManager {
+        constructor(context) {
+            super(context);
+        }
         getUrl() {
             return CtpAnalysisManager.BASE_URL;
         }

package/{content/manager → commands/cpm4}/ctp.datamodel.manager.js

@@ -13,8 +13,8 @@
     const ctp_manager_1 = require("./ctp.manager");
     const FormData = require("form-data");
     class CtpDataModelManager extends ctp_manager_1.CtpManager {
-        constructor(existingPoolId, globalPoolName) {
-            super();
+        constructor(context, existingPoolId, globalPoolName) {
+            super(context);
             this.existingPoolId = existingPoolId;
             this.globalPoolName = globalPoolName;
         }

package/{content/factory/ctp-manager.factory.js → commands/cpm4/ctp.manager-factory.js}

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "fs", "path", "../../util/logger", "../manager/ctp.analysis.manager", "../manager/ctp.datamodel.manager"], factory);
+        define(["require", "exports", "fs", "path", "./ctp.analysis.manager", "./ctp.datamodel.manager", "../../core/utils/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -12,16 +12,19 @@
     exports.CTPManagerFactory = void 0;
     const fs = require("fs");
     const path = require("path");
-    const logger_1 = require("../../util/logger");
-    const ctp_analysis_manager_1 = require("../manager/ctp.analysis.manager");
-    const ctp_datamodel_manager_1 = require("../manager/ctp.datamodel.manager");
+    const ctp_analysis_manager_1 = require("./ctp.analysis.manager");
+    const ctp_datamodel_manager_1 = require("./ctp.datamodel.manager");
+    const logger_1 = require("../../core/utils/logger");
     class CTPManagerFactory {
+        constructor(context) {
+            this.context = context;
+        }
         createCtpAnalysisManager(filename, password, spaceKey) {
-            const ctpManager = new ctp_analysis_manager_1.CtpAnalysisManager();
+            const ctpManager = new ctp_analysis_manager_1.CtpAnalysisManager(this.context);
             return this.initManager(ctpManager, filename, password, spaceKey);
         }
         createCtpDataModelManager(filename, password, existingPoolId, globalPoolName) {
-            const ctpManager = new ctp_datamodel_manager_1.CtpDataModelManager(existingPoolId, globalPoolName);
+            const ctpManager = new ctp_datamodel_manager_1.CtpDataModelManager(this.context, existingPoolId, globalPoolName);
             return this.initManager(ctpManager, filename, password);
         }
         initManager(ctpManager, filename, password, spaceKey) {

package/{content/manager → commands/cpm4}/ctp.manager.js

@@ -4,14 +4,17 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./base.manager"], factory);
+        define(["require", "exports", "../../core/http/http-shared/base.manager"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.CtpManager = void 0;
-    const base_manager_1 = require("./base.manager");
+    const base_manager_1 = require("../../core/http/http-shared/base.manager");
     class CtpManager extends base_manager_1.BaseManager {
+        constructor(context) {
+            super(context);
+        }
         get content() {
             return this._content;
         }
@@ -31,9 +34,8 @@
             this._spaceKey = value;
         }
         getConfig() {
-            const baseUrl = this.getUrl();
             return {
-                pushUrl: this.profile.team.replace(/\/?$/, `${baseUrl}`),
+                pushUrl: this.getUrl(),
                 onPushSuccessMessage: () => {
                     return "CTP File was pushed successfully";
                 },

package/commands/cpm4/module.js

@@ -0,0 +1,46 @@
+/**
+ * Commands related to the CPM4 area.
+ */
+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", "./ctp-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const ctp_command_service_1 = require("./ctp-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const pushCommand = configurator.command("push");
+            pushCommand.command("ctp")
+                .description("Command to push a .ctp (Celonis 4 transport file) to create a package")
+                .option("-a, --pushAnalysis", "Specify this option if you want to push analysis from the CTP file")
+                .option("-d, --pushDataModels", "Specify this option if you want to push data models from the CTP file")
+                .option("--globalPoolName <globalPoolName>", "Specify this option if you want to push all Data models into one newly created pool along with value to set the name of the pool to be created", null)
+                .option("--existingPoolId <existingPoolId>", "Specify this option if you want to push all Data models into one already existing pool with provided ID", null)
+                .option("-s, --spaceKey <spaceKey>", "The key of the destination space where the analyses from .ctp file will be created.", "")
+                .requiredOption("-f, --file <file>", "The .ctp file you want to push")
+                .requiredOption("--password <password>", "The password used for extracting the .ctp file")
+                .action(this.pushCTPFile);
+        }
+        pushCTPFile(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new ctp_command_service_1.CTPCommandService(context).pushCTPFile(options.file, options.password, options.pushAnalysis, options.pushDataModels, options.existingPoolId, options.globalPoolName, options.spaceKey);
+            });
+        }
+    }
+    return Module;
+});

package/commands/{connection.command.js → data-pipeline/connection/connection-command.service.js}

@@ -13,29 +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", "../services/connection/connection.service"], factory);
+        define(["require", "exports", "./connection.service"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ConnectionCommand = void 0;
-    const connection_service_1 = require("../services/connection/connection.service");
-    class ConnectionCommand {
-        updateProperty(profile, dataPoolId, connectionId, property, value) {
+    exports.ConnectionCommandService = void 0;
+    const connection_service_1 = require("./connection.service");
+    class ConnectionCommandService {
+        constructor(context) {
+            this.connectionService = new connection_service_1.ConnectionService(context);
+        }
+        updateProperty(dataPoolId, connectionId, property, value) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield connection_service_1.connectionService.updateProperty(dataPoolId, connectionId, property, value);
+                yield this.connectionService.updateProperty(dataPoolId, connectionId, property, value);
             });
         }
-        getProperties(profile, dataPoolId, connectionId) {
+        getProperties(dataPoolId, connectionId) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield connection_service_1.connectionService.listProperties(dataPoolId, connectionId);
+                yield this.connectionService.listProperties(dataPoolId, connectionId);
             });
         }
-        listConnections(profile, dataPoolId) {
+        listConnections(dataPoolId) {
             return __awaiter(this, void 0, void 0, function* () {
-                return yield connection_service_1.connectionService.findAllConnections(dataPoolId);
+                yield this.connectionService.findAllConnections(dataPoolId);
             });
         }
     }
-    exports.ConnectionCommand = ConnectionCommand;
+    exports.ConnectionCommandService = ConnectionCommandService;
 });

package/commands/data-pipeline/connection/connection.commands.js

@@ -0,0 +1,65 @@
+/**
+ * Commands related to the Data Pool Connections.
+ */
+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", "./connection-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConnectionCommands = void 0;
+    const connection_command_service_1 = require("./connection-command.service");
+    class ConnectionCommands {
+        register(context, configurator) {
+            const listCommand = configurator.command("list");
+            listCommand.command("connection")
+                .description("Command to list all connections in a Data Pool")
+                .requiredOption("--dataPoolId <dataPoolId>", "ID of the data pool")
+                .action(this.listConnections);
+            const getCommand = configurator.command("get");
+            getCommand.command("connection")
+                .description("Programmatically read properties of your connections")
+                .requiredOption("--dataPoolId <dataPoolId>", "Id of the data pool you want to update")
+                .requiredOption("--connectionId <connectionId>", "Id of the connection you want to update")
+                .action(this.getCommandProperties);
+            const setCommand = configurator.command("set");
+            setCommand.command("connection")
+                .description("Programmatically update properties of your connections")
+                .requiredOption("--dataPoolId <dataPoolId>", "Id of the data pool you want to update")
+                .requiredOption("--connectionId <connectionId>", "Id of the connection you want to update")
+                .requiredOption("--property <property>", "The property you want to update")
+                .requiredOption("--value <value>", "The value you want to update")
+                .action(this.updateConnectionProperty);
+        }
+        getCommandProperties(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_service_1.ConnectionCommandService(context).getProperties(options.dataPoolId, options.connectionId);
+            });
+        }
+        listConnections(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_service_1.ConnectionCommandService(context).listConnections(options.dataPoolId);
+            });
+        }
+        updateConnectionProperty(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new connection_command_service_1.ConnectionCommandService(context).updateProperty(options.dataPoolId, options.connectionId, options.property, options.value);
+            });
+        }
+    }
+    exports.ConnectionCommands = ConnectionCommands;
+});