@celonis/content-cli 0.13.6 → 1.0.3

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

@@ -13,18 +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", "../../api/data-pool-api", "../../util/logger"], factory);
+        define(["require", "exports", "../../../core/utils/logger", "../data-pool/data-pool-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.connectionService = void 0;
-    const data_pool_api_1 = require("../../api/data-pool-api");
-    const logger_1 = require("../../util/logger");
+    exports.ConnectionService = void 0;
+    const logger_1 = require("../../../core/utils/logger");
+    const data_pool_api_1 = require("../data-pool/data-pool-api");
     class ConnectionService {
+        constructor(context) {
+            this.dataPoolApi = new data_pool_api_1.DataPoolApi(context);
+        }
         findAllConnections(dataPoolId) {
             return __awaiter(this, void 0, void 0, function* () {
-                const connections = yield data_pool_api_1.dataPoolApi.listConnections(dataPoolId);
+                const connections = yield this.dataPoolApi.listConnections(dataPoolId);
                 connections.forEach(connection => {
                     logger_1.logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
                 });
@@ -33,14 +36,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listProperties(dataPoolId, connectionId) {
             return __awaiter(this, void 0, void 0, function* () {
-                const connection = yield data_pool_api_1.dataPoolApi.getConnection(dataPoolId, connectionId);
+                const connection = yield this.dataPoolApi.getConnection(dataPoolId, connectionId);
                 const type = connection.type;
-                const typedConnection = yield data_pool_api_1.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
+                const typedConnection = yield this.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
                 logger_1.logger.info(`Connection ID: ${connection.id} - Name: ${connection.name} - Type: ${connection.type}`);
-                logger_1.logger.info(`Properties:`);
-                for (let k in typedConnection) {
-                    if (typeof typedConnection[k] === 'object') {
-                        for (let o in typedConnection[k]) {
+                logger_1.logger.info("Properties:");
+                for (const k in typedConnection) {
+                    if (typeof typedConnection[k] === "object") {
+                        for (const o in typedConnection[k]) {
                             logger_1.logger.info(`  ${k}.${o} : ${typeof typedConnection[k][o]} := ${typedConnection[k][o]}`);
                         }
                     }
@@ -53,9 +56,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         updateProperty(dataPoolId, connectionId, property, value) {
             return __awaiter(this, void 0, void 0, function* () {
-                const connection = yield data_pool_api_1.dataPoolApi.getConnection(dataPoolId, connectionId);
+                const connection = yield this.dataPoolApi.getConnection(dataPoolId, connectionId);
                 const type = connection.type;
-                const typedConnection = yield data_pool_api_1.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
+                const typedConnection = yield this.dataPoolApi.getTypedConnection(dataPoolId, connectionId, type);
                 const parts = property.split(".");
                 // update the typed connection object
                 let currentObject = typedConnection;
@@ -74,10 +77,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         return;
                     }
                 }
-                yield data_pool_api_1.dataPoolApi.updateTypedConnection(dataPoolId, connectionId, type, typedConnection);
+                yield this.dataPoolApi.updateTypedConnection(dataPoolId, connectionId, type, typedConnection);
                 logger_1.logger.info(`Property ${property} updated.`);
             });
         }
     }
-    exports.connectionService = new ConnectionService();
+    exports.ConnectionService = ConnectionService;
 });

package/{api → commands/data-pipeline/data-pool}/data-pool-api.js

@@ -13,65 +13,66 @@ 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", "../util/logger"], factory);
+        define(["require", "exports", "../../../core/utils/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.dataPoolApi = void 0;
-    const http_client_service_v2_1 = require("../services/http-client-service.v2");
-    const logger_1 = require("../util/logger");
+    exports.DataPoolApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
     class DataPoolApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         findAllPagedPools(limit, page) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/paged?limit=${limit}&page=${page}`).catch(e => {
+                return this.httpClient.get(`/integration/api/pools/paged?limit=${limit}&page=${page}`).catch(e => {
                     throw new logger_1.FatalError(`Problem getting data pools: : ${e}`);
                 });
             });
         }
         executeDataPoolsBatchImport(importRequest) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.post("/integration/api/pool/batch-import", importRequest).catch(e => {
+                return this.httpClient.post("/integration/api/pool/batch-import", importRequest).catch(e => {
                     throw new logger_1.FatalError(`Data Pool batch import failed: : ${e}`);
                 });
             });
         }
         exportDataPool(poolId) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/${poolId}/v2/export`).catch(e => {
+                return this.httpClient.get(`/integration/api/pools/${poolId}/v2/export`).catch(e => {
                     throw new logger_1.FatalError(`Data Pool export failed: : ${e}`);
                 });
             });
         }
         listConnections(poolId) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/${poolId}/overviews/data-sources`).catch(e => {
+                return this.httpClient.get(`/integration/api/pools/${poolId}/overviews/data-sources`).catch(e => {
                     throw new logger_1.FatalError(`Can not list connections: : ${e}`);
                 });
             });
         }
         getConnection(poolId, connectionId) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/integration/api/pools/${poolId}/data-sources/${connectionId}`).catch(e => {
+                return this.httpClient.get(`/integration/api/pools/${poolId}/data-sources/${connectionId}`).catch(e => {
                     throw new logger_1.FatalError(`Can not get connection: : ${e}`);
                 });
             });
         }
         getTypedConnection(poolId, connectionId, type) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/integration/api/datasource/${type}/${connectionId}`).catch(e => {
+                return this.httpClient.get(`/integration/api/datasource/${type}/${connectionId}`).catch(e => {
                     throw new logger_1.FatalError(`Can get typed connection: : ${e}`);
                 });
             });
         }
         updateTypedConnection(poolId, connectionId, type, data) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.put(`/integration/api/datasource/${type}/${connectionId}`, data).catch(e => {
+                return this.httpClient.put(`/integration/api/datasource/${type}/${connectionId}`, data).catch(e => {
                     throw new logger_1.FatalError(`Can not update typed connection: ${e}`);
                 });
             });
         }
     }
-    DataPoolApi.INSTANCE = new DataPoolApi();
-    exports.dataPoolApi = DataPoolApi.INSTANCE;
+    exports.DataPoolApi = DataPoolApi;
 });

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

@@ -13,60 +13,62 @@ 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/data-pool-manager.factory", "../services/data-pool/data-pool-service"], factory);
+        define(["require", "exports", "./data-pool-manager.factory", "./data-pool-service", "../../../core/http/http-shared/base.manager.helper"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.DataPoolCommand = void 0;
-    const content_service_1 = require("../services/content.service");
-    const data_pool_manager_factory_1 = require("../content/factory/data-pool-manager.factory");
-    const data_pool_service_1 = require("../services/data-pool/data-pool-service");
-    class DataPoolCommand {
-        constructor() {
-            this.contentService = new content_service_1.ContentService();
-            this.dataPoolManagerFactory = new data_pool_manager_factory_1.DataPoolManagerFactory();
+    exports.DataPoolCommandService = void 0;
+    const data_pool_manager_factory_1 = require("./data-pool-manager.factory");
+    const data_pool_service_1 = require("./data-pool-service");
+    const base_manager_helper_1 = require("../../../core/http/http-shared/base.manager.helper");
+    class DataPoolCommandService {
+        constructor(context) {
+            this.baseManagerHelper = new base_manager_helper_1.BaseManagerHelper();
+            this.dataPoolManagerFactory = new data_pool_manager_factory_1.DataPoolManagerFactory(context);
+            this.dataPoolService = new data_pool_service_1.DataPoolService(context);
         }
-        pullDataPool(profile, id) {
+        pullDataPool(id) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.pull(profile, this.dataPoolManagerFactory.createManager(id, null));
+                yield this.dataPoolManagerFactory.createManager(id, null).pull();
             });
         }
-        pushDataPool(profile, filename) {
+        pushDataPool(filename) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.push(profile, this.dataPoolManagerFactory.createManager(null, filename));
+                yield this.dataPoolManagerFactory.createManager(null, filename).push();
             });
         }
         exportDataPool(poolId, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield data_pool_service_1.dataPoolService.exportDataPool(poolId, outputToJsonFile);
+                yield this.dataPoolService.exportDataPool(poolId, outputToJsonFile);
             });
         }
-        pushDataPools(profile) {
+        pushDataPools() {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.batchPush(profile, this.dataPoolManagerFactory.createManagers());
+                const dataPoolManagers = this.dataPoolManagerFactory.createManagers();
+                yield this.baseManagerHelper.batchPush(dataPoolManagers);
             });
         }
         batchImportDataPools(requestFile, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield data_pool_service_1.dataPoolService.batchImportDataPools(requestFile, outputToJsonFile);
+                yield this.dataPoolService.batchImportDataPools(requestFile, outputToJsonFile);
             });
         }
-        updateDataPool(profile, id, filename) {
+        updateDataPool(id, filename) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield this.contentService.update(profile, this.dataPoolManagerFactory.createManager(id, filename));
+                yield this.dataPoolManagerFactory.createManager(id, filename).update();
             });
         }
-        listDataPools(profile, jsonResponse) {
+        listDataPools(jsonResponse) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (jsonResponse) {
-                    yield data_pool_service_1.dataPoolService.findAndExportAllPools();
+                    yield this.dataPoolService.findAndExportAllPools();
                 }
                 else {
-                    yield data_pool_service_1.dataPoolService.listDataPools();
+                    yield this.dataPoolService.listDataPools();
                 }
             });
         }
     }
-    exports.DataPoolCommand = DataPoolCommand;
+    exports.DataPoolCommandService = DataPoolCommandService;
 });

package/{content/factory → commands/data-pipeline/data-pool}/data-pool-manager.factory.js

@@ -4,19 +4,22 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "fs", "path", "../../util/logger", "../manager/data-pool.manager"], factory);
+        define(["require", "exports", "path", "./data-pool.manager", "../../../core/utils/logger", "fs"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DataPoolManagerFactory = void 0;
-    const fs = require("fs");
     const path = require("path");
-    const logger_1 = require("../../util/logger");
-    const data_pool_manager_1 = require("../manager/data-pool.manager");
+    const data_pool_manager_1 = require("./data-pool.manager");
+    const logger_1 = require("../../../core/utils/logger");
+    const fs = require("fs");
     class DataPoolManagerFactory {
+        constructor(context) {
+            this.context = context;
+        }
         createManager(id, filename) {
-            const dataPoolManager = new data_pool_manager_1.DataPoolManager();
+            const dataPoolManager = new data_pool_manager_1.DataPoolManager(this.context);
             dataPoolManager.id = id;
             if (filename !== null) {
                 dataPoolManager.content = this.readFile(filename);
@@ -34,7 +37,7 @@
                 return false;
             })
                 .map(dataPool => {
-                const dataPoolManager = new data_pool_manager_1.DataPoolManager();
+                const dataPoolManager = new data_pool_manager_1.DataPoolManager(this.context);
                 dataPoolManager.content = this.readFile(dataPool);
                 return dataPoolManager;
             });

package/{services → commands/data-pipeline}/data-pool/data-pool-service.js

@@ -13,21 +13,24 @@ 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/data-pool-api", "../../util/logger", "uuid", "../file-service"], factory);
+        define(["require", "exports", "uuid", "../../../core/utils/file-service", "../../../core/utils/logger", "./data-pool-api"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.dataPoolService = void 0;
-    const data_pool_api_1 = require("../../api/data-pool-api");
-    const logger_1 = require("../../util/logger");
+    exports.DataPoolService = void 0;
     const uuid_1 = require("uuid");
-    const file_service_1 = require("../file-service");
+    const file_service_1 = require("../../../core/utils/file-service");
+    const logger_1 = require("../../../core/utils/logger");
+    const data_pool_api_1 = require("./data-pool-api");
     class DataPoolService {
+        constructor(context) {
+            this.dataPoolApi = new data_pool_api_1.DataPoolApi(context);
+        }
         batchImportDataPools(requestFilePath, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
                 const requestFileContent = file_service_1.fileService.readFile(requestFilePath);
-                const importReport = yield data_pool_api_1.dataPoolApi.executeDataPoolsBatchImport(requestFileContent);
+                const importReport = yield this.dataPoolApi.executeDataPoolsBatchImport(requestFileContent);
                 const importReportString = JSON.stringify(importReport, null, 4);
                 if (outputToJsonFile) {
                     const reportFileName = "batch_import_report_" + (0, uuid_1.v4)() + ".json";
@@ -41,7 +44,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         exportDataPool(poolId, outputToJsonFile) {
             return __awaiter(this, void 0, void 0, function* () {
-                const exportedDataPool = yield data_pool_api_1.dataPoolApi.exportDataPool(poolId);
+                const exportedDataPool = yield this.dataPoolApi.exportDataPool(poolId);
                 const exportedDataPoolString = JSON.stringify(exportedDataPool, null, 4);
                 if (outputToJsonFile) {
                     const reportFileName = (0, uuid_1.v4)() + "_data_pool_" + poolId + ".json";
@@ -71,10 +74,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 let page = 0;
                 const dataPools = [];
-                let tmpPage = yield data_pool_api_1.dataPoolApi.findAllPagedPools("100", page.toString());
+                let tmpPage = yield this.dataPoolApi.findAllPagedPools("100", page.toString());
                 while (tmpPage.pageNumber < tmpPage.totalCount) {
                     dataPools.push(...tmpPage.content);
-                    tmpPage = yield data_pool_api_1.dataPoolApi.findAllPagedPools("100", (++page).toString());
+                    tmpPage = yield this.dataPoolApi.findAllPagedPools("100", (++page).toString());
                 }
                 return dataPools;
             });
@@ -85,5 +88,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
         }
     }
-    exports.dataPoolService = new DataPoolService();
+    exports.DataPoolService = DataPoolService;
 });

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

@@ -0,0 +1,99 @@
+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", "./data-pool-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DataPoolCommands = void 0;
+    const data_pool_command_service_1 = require("./data-pool-command.service");
+    class DataPoolCommands {
+        register(context, configurator) {
+            const exportCommand = configurator.command("export");
+            exportCommand.command("data-pool")
+                .description("Command to export a data pool")
+                .requiredOption("--id <id>", "ID of the data pool you want to export")
+                .option("--outputToJsonFile", "Output the exported data pool to a JSON file")
+                .action(this.exportDataPool);
+            const importCommand = configurator.command("import");
+            importCommand.command("data-pools")
+                .description("Command to batch import multiple data pools with their objects and dependencies")
+                .requiredOption("-f, --jsonFile <file>", "The file with the JSON data pool batch import request")
+                .option("--outputToJsonFile", "Output the batch import result in a JSON file")
+                .action(this.batchImportDataPools);
+            const listCommand = configurator.command("list");
+            listCommand.command("data-pools")
+                .description("Command to list all Data Pools")
+                .option("--json", "Return response as json type", "")
+                .action(this.listDataPools);
+            const pullCommand = configurator.command("pull");
+            pullCommand.command("data-pool")
+                .description("Command to pull a data pool")
+                .requiredOption("--id <id>", "Id of the data pool you want to pull")
+                .action(this.pullDataPool);
+            const pushCommand = configurator.command("push");
+            pushCommand.command("data-pool")
+                .description("Command to push a data pool")
+                .requiredOption("-f, --file <file>", "The file you want to push")
+                .action(this.pushDataPool);
+            pushCommand.command("data-pools")
+                .description("Command to push data pools")
+                .action(this.pushDataPools);
+            const updateCommand = configurator.command("update");
+            updateCommand.command("data-pool")
+                .description("Command to update a data pool using a data pool configuration file")
+                .requiredOption("--id <id>", "Id of the data pool you want to update")
+                .requiredOption("-f, --file <file>", "The file you want to push")
+                .action(this.updateDataPool);
+        }
+        exportDataPool(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).exportDataPool(options.id, options.outputToJsonFile);
+            });
+        }
+        batchImportDataPools(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).batchImportDataPools(options.jsonFile, options.outputToJsonFile);
+            });
+        }
+        listDataPools(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).listDataPools(options.json);
+            });
+        }
+        pullDataPool(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).pullDataPool(options.id);
+            });
+        }
+        pushDataPool(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).pushDataPool(options.file);
+            });
+        }
+        pushDataPools(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).pushDataPools();
+            });
+        }
+        updateDataPool(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new data_pool_command_service_1.DataPoolCommandService(context).updateDataPool(options.id, options.file);
+            });
+        }
+    }
+    exports.DataPoolCommands = DataPoolCommands;
+});

package/{content/manager → commands/data-pipeline/data-pool}/data-pool.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.DataPoolManager = void 0;
-    const base_manager_1 = require("./base.manager");
+    const base_manager_1 = require("../../../core/http/http-shared/base.manager");
     class DataPoolManager extends base_manager_1.BaseManager {
+        constructor(context) {
+            super(context);
+        }
         get content() {
             return this._content;
         }
@@ -26,13 +29,9 @@
         }
         getConfig() {
             return {
-                pushUrl: this.profile.team.replace(/\/?$/, `${DataPoolManager.DATA_POOL_PUSH_URL}`),
-                pullUrl: this.profile.team
-                    .replace(/\/?$/, `${DataPoolManager.DATA_POOL_PULL_URL}`)
-                    .replace("{id}", this.id),
-                updateUrl: this.profile.team
-                    .replace(/\/?$/, DataPoolManager.DATA_POOL_ACTIONS_URL)
-                    .replace("{id}", this.id),
+                pushUrl: DataPoolManager.DATA_POOL_PUSH_URL,
+                pullUrl: DataPoolManager.DATA_POOL_PULL_URL.replace("{id}", this.id),
+                updateUrl: DataPoolManager.DATA_POOL_ACTIONS_URL.replace("{id}", this.id),
                 exportFileName: DataPoolManager.DATA_POOL_FILE_NAME_PREFIX + this.id + ".json",
                 onPushSuccessMessage: (data) => {
                     return "Data Pool was pushed successfully. New ID: " + data.id;

package/commands/data-pipeline/module.js

@@ -0,0 +1,24 @@
+/**
+ * Commands related to the Data Pipeline area.
+ */
+(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", "./connection/connection.commands", "./data-pool/data-pool.commands"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const connection_commands_1 = require("./connection/connection.commands");
+    const data_pool_commands_1 = require("./data-pool/data-pool.commands");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            new data_pool_commands_1.DataPoolCommands().register(context, configurator);
+            new connection_commands_1.ConnectionCommands().register(context, configurator);
+        }
+    }
+    return Module;
+});

package/commands/profile/module.js

@@ -0,0 +1,60 @@
+/**
+ * Commands to create and list access profiles.
+ */
+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", "../../core/utils/logger", "./profile-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const logger_1 = require("../../core/utils/logger");
+    const profile_command_service_1 = require("./profile-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const command = configurator.command("profile")
+                .description("Manage profiles required to access a system.");
+            command.command("list")
+                .description("Command to list all stored profiles")
+                .action(this.listProfiles);
+            command.command("create")
+                .description("Command to create a new profile")
+                .option("--setAsDefault", "Set this profile as default")
+                .action(this.createProfile);
+            command.command("default <profile>")
+                .description("Command to set a profile as default")
+                .action(this.defaultProfile);
+        }
+        defaultProfile(context, command) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profile = command.args[0];
+                yield new profile_command_service_1.ProfileCommandService().makeDefaultProfile(profile);
+            });
+        }
+        createProfile(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new profile_command_service_1.ProfileCommandService().createProfile(options.setAsDefault);
+            });
+        }
+        listProfiles(context, command) {
+            return __awaiter(this, void 0, void 0, function* () {
+                logger_1.logger.debug("List profiles");
+                yield new profile_command_service_1.ProfileCommandService().listProfiles();
+            });
+        }
+    }
+    return Module;
+});