@celonis/content-cli 0.13.5 → 1.0.0

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

package/commands/profile/profile-command.service.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/utils/question.service", "../../core/profile/profile.service", "../../core/utils/logger", "../../core/profile/profile.interface", "../../core/profile/profile.validator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ProfileCommandService = void 0;
+    const question_service_1 = require("../../core/utils/question.service");
+    const profile_service_1 = require("../../core/profile/profile.service");
+    const logger_1 = require("../../core/utils/logger");
+    const profile_interface_1 = require("../../core/profile/profile.interface");
+    const profile_validator_1 = require("../../core/profile/profile.validator");
+    class ProfileCommandService {
+        constructor() {
+            this.profileService = new profile_service_1.ProfileService();
+        }
+        createProfile(setAsDefault) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const profile = {};
+                const questions = new question_service_1.QuestionService();
+                try {
+                    profile.name = yield questions.ask("Name of the profile: ");
+                    profile.team = yield questions.ask("Your team (please provide the full url): ");
+                    const type = yield questions.ask("Profile type: OAuth Device Code (1), OAuth Client Credentials (2) or Application Key / API Key (3): ");
+                    switch (type) {
+                        case "1":
+                            profile.type = profile_interface_1.ProfileType.DEVICE_CODE;
+                            break;
+                        case "2":
+                            profile.type = profile_interface_1.ProfileType.CLIENT_CREDENTIALS;
+                            profile.clientId = yield questions.ask("Your client id: ");
+                            profile.clientSecret = yield questions.ask("Your client secret: ");
+                            break;
+                        case "3":
+                            profile.type = profile_interface_1.ProfileType.KEY;
+                            profile.apiToken = yield questions.ask("Your api token: ");
+                            break;
+                        default:
+                            logger_1.logger.error(new logger_1.FatalError("Invalid type"));
+                            break;
+                    }
+                    profile.authenticationType = yield profile_validator_1.ProfileValidator.validateProfile(profile);
+                    yield this.profileService.authorizeProfile(profile);
+                    this.profileService.storeProfile(profile);
+                    if (setAsDefault) {
+                        yield this.makeDefaultProfile(profile.name);
+                    }
+                }
+                finally {
+                    questions.close();
+                }
+                logger_1.logger.info("Profile created successfully!");
+            });
+        }
+        listProfiles() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.profileService.readAllProfiles().then((profiles) => {
+                    const defaultProfile = this.profileService.getDefaultProfile();
+                    if (profiles) {
+                        profiles.forEach(profile => {
+                            if (defaultProfile && defaultProfile === profile) {
+                                logger_1.logger.info(profile + " (default)");
+                            }
+                            else {
+                                logger_1.logger.info(profile);
+                            }
+                        });
+                    }
+                });
+            });
+        }
+        makeDefaultProfile(profile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.profileService.makeDefaultProfile(profile);
+                logger_1.logger.info("Default profile: " + profile);
+            });
+        }
+    }
+    exports.ProfileCommandService = ProfileCommandService;
+});

package/{api → commands/studio/api}/asset-api.js

@@ -13,18 +13,20 @@ 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.assetApi = void 0;
-    const http_client_service_v2_1 = require("../services/http-client-service.v2");
-    const logger_1 = require("../util/logger");
+    exports.AssetApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
     class AssetApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         findAllAssets(assetType) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(this.getFindAllAssetsUrl(assetType)).catch(e => {
+                return this.httpClient.get(this.getFindAllAssetsUrl(assetType)).catch(e => {
                     throw new logger_1.FatalError(`Problem getting assets: ${e}`);
                 });
             });
@@ -37,6 +39,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return findAllAssetsUrl;
         }
     }
-    AssetApi.INSTANCE = new AssetApi();
-    exports.assetApi = AssetApi.INSTANCE;
+    exports.AssetApi = AssetApi;
 });

package/{api → commands/studio/api}/compute-pool-api.js

@@ -13,23 +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", "../services/http-client-service.v2"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.computePoolApi = void 0;
-    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    exports.ComputePoolApi = void 0;
     class ComputePoolApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         findAllDataModelsDetails() {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get("/package-manager/api/compute-pools/data-models/details")
+                return this.httpClient.get("/package-manager/api/compute-pools/data-models/details")
                     .catch(e => {
                     return null;
                 });
             });
         }
     }
-    ComputePoolApi.INSTANCE = new ComputePoolApi();
-    exports.computePoolApi = ComputePoolApi.INSTANCE;
+    exports.ComputePoolApi = ComputePoolApi;
 });

package/{api → commands/studio/api}/node-api.js

@@ -13,18 +13,20 @@ 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.nodeApi = void 0;
-    const http_client_service_v2_1 = require("../services/http-client-service.v2");
-    const logger_1 = require("../util/logger");
+    exports.NodeApi = void 0;
+    const logger_1 = require("../../../core/utils/logger");
     class NodeApi {
+        constructor(context) {
+            this.httpClient = context.httpClient;
+        }
         findAllNodesOfType(assetType) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/nodes?assetType=${assetType}`)
+                return this.httpClient.get(`/package-manager/api/nodes?assetType=${assetType}`)
                     .catch(e => {
                     throw new logger_1.FatalError(`Problem getting nodes of type ${assetType}: ${e}`);
                 });
@@ -32,12 +34,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         findOneByKeyAndRootNodeKey(packageKey, nodeKey) {
             return __awaiter(this, void 0, void 0, function* () {
-                return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/nodes/${packageKey}/${nodeKey}`).catch(e => {
+                return this.httpClient.get(`/package-manager/api/nodes/${packageKey}/${nodeKey}`).catch(e => {
                     return null;
                 });
             });
         }
     }
-    NodeApi.INSTANCE = new NodeApi();
-    exports.nodeApi = NodeApi.INSTANCE;
+    exports.NodeApi = NodeApi;
 });