@celonis/content-cli 0.13.5 → 1.0.0

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

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