@celonis/content-cli 0.13.4 → 1.0.0

package/core/command/module-handler.js

@@ -0,0 +1,200 @@
+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", "path", "fs", "../utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CommandConfig = exports.Configurator = exports.ModuleHandler = exports.IModule = void 0;
+    const path = require("path");
+    const fs = require("fs");
+    const logger_1 = require("../utils/logger");
+    class IModule {
+    }
+    exports.IModule = IModule;
+    class ModuleHandler {
+        constructor(program, context) {
+            this.program = program;
+            this.context = context;
+            // Store registered module instances if needed later
+            this.registeredModules = [];
+            this.configurator = new Configurator(this.program, this.context);
+        }
+        /**
+         * Discovers modules in the specified directory, imports them,
+         * instantiates the default exported class, and calls its register method.
+         *
+         * @param {any} rootPath - __dirname when invoked from the main entry file
+         * @param devMode        - Use uncompiled modules for development debug mode
+         */
+        discoverAndRegisterModules(rootPath, devMode = false) {
+            const modulesDirPath = path.resolve(rootPath, "commands");
+            try {
+                const moduleFolders = fs.readdirSync(modulesDirPath, { withFileTypes: true });
+                for (const dirent of moduleFolders) {
+                    if (dirent.isDirectory()) {
+                        const moduleFolderName = dirent.name;
+                        const moduleFileName = devMode ? "module.ts" : "module.js";
+                        // Calculate path relative to *this file's location in dist*
+                        let potentialModuleJsPath;
+                        potentialModuleJsPath = path.resolve(rootPath, "commands", moduleFolderName, moduleFileName // Look for the compiled JS file
+                        );
+                        try {
+                            fs.accessSync(potentialModuleJsPath);
+                        }
+                        catch (err) {
+                            // apparently the file does not exist of is not accessible
+                            potentialModuleJsPath = null;
+                        }
+                        if (!potentialModuleJsPath) {
+                            logger_1.logger.debug(`Module folder ${moduleFolderName} does not contain a valid entry point and is skipped.`);
+                        }
+                        else {
+                            // Check if the compiled JS file exists
+                            try {
+                                logger_1.logger.debug(`Found potential module definition: ${potentialModuleJsPath}`);
+                                // Dynamically require the module
+                                const requiredModule = require(potentialModuleJsPath);
+                                // With 'export =' or 'module.exports =', the required value *is* the class
+                                const ModuleClass = requiredModule; // Cast for TS check
+                                // Basic check: Is it a class (function)?
+                                if (typeof ModuleClass === "function" && ModuleClass.prototype) {
+                                    const moduleInstance = new ModuleClass(); // Instantiate
+                                    // Check if the instance has the register method
+                                    if (typeof moduleInstance.register === "function") {
+                                        logger_1.logger.debug(`Registering module: ${moduleFolderName}`);
+                                        // Call register - can still be async even if require() is sync
+                                        moduleInstance.register(this.context, this.configurator);
+                                        this.registeredModules.push(moduleInstance);
+                                    }
+                                    else {
+                                        logger_1.logger.warn(`Module ${moduleFolderName} export does not have a 'register' method.`);
+                                    }
+                                }
+                                else {
+                                    logger_1.logger.warn(`Module ${moduleFolderName} export is not a class/constructor function.`);
+                                }
+                            }
+                            catch (error) {
+                                if (error.code === "ENOENT") {
+                                    // Compiled module.js not found, maybe folder doesn't contain a valid module
+                                    logger_1.logger.warn(`Directory ${moduleFolderName} does not contain a compiled module.js file.`);
+                                }
+                                else if (error.code === "MODULE_NOT_FOUND") {
+                                    logger_1.logger.debug("Error details", error);
+                                    logger_1.logger.warn(`Could not require module ${moduleFolderName}. Check dependencies or compilation. Path: ${potentialModuleJsPath}`);
+                                }
+                                else {
+                                    logger_1.logger.error(`Error processing module in ${moduleFolderName}:`, error);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    logger_1.logger.error(`Modules directory not found relative to JS output: ${path.resolve(path.dirname(__filename), "commands")}`);
+                }
+                else {
+                    logger_1.logger.error("Failed to read modules directory:", error);
+                }
+            }
+            logger_1.logger.debug(`Module discovery complete. ${this.registeredModules.length} modules registered.`);
+        }
+    }
+    exports.ModuleHandler = ModuleHandler;
+    /**
+     * Allows the creation of root level commands.
+     */
+    class Configurator {
+        constructor(program, ctx) {
+            this.program = program;
+            this.ctx = ctx;
+            this.rootCommandMap = new Map();
+        }
+        /**
+         * Get or create a root level command.
+         * @param name
+         * @returns
+         */
+        command(name) {
+            if (this.rootCommandMap.has(name)) {
+                return this.rootCommandMap.get(name);
+            }
+            const cmd = this.program.command(name);
+            const cmdConfig = new CommandConfig(cmd, this.ctx);
+            this.rootCommandMap.set(name, cmdConfig);
+            return cmdConfig;
+        }
+    }
+    exports.Configurator = Configurator;
+    /**
+     * Delegate wrapper around the Command object, to simply change the way the program is
+     * executed.
+     */
+    class CommandConfig {
+        constructor(cmd, ctx) {
+            this.cmd = cmd;
+            this.ctx = ctx;
+        }
+        command(nameAndArgs, opts) {
+            return new CommandConfig(this.cmd.command(nameAndArgs, opts), this.ctx)
+                .option("-p, --profile <profile>", "Profile which you want to use");
+        }
+        alias(alias) {
+            this.cmd.alias(alias);
+            return this;
+        }
+        description(description) {
+            this.cmd.description(description);
+            return this;
+        }
+        argument(name, description, defaultValue) {
+            this.cmd.argument(name, description, defaultValue);
+            return this;
+        }
+        option(flags, description, defaultValue) {
+            this.cmd.option(flags, description, defaultValue);
+            return this;
+        }
+        requiredOption(flags, description, defaultValue) {
+            this.cmd.requiredOption(flags, description, defaultValue);
+            return this;
+        }
+        deprecationNotice(deprecationMessage) {
+            this.deprecationMessage = deprecationMessage;
+            return this;
+        }
+        action(handler) {
+            this.cmd.action(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.printDeprecationNoticeIfDeprecated();
+                    yield handler(this.ctx, this.cmd, this.cmd.opts());
+                }
+                catch (error) {
+                    logger_1.logger.error(`An unexpected error occured executing a command: ${error}`);
+                }
+            }));
+        }
+        printDeprecationNoticeIfDeprecated() {
+            if (this.deprecationMessage) {
+                logger_1.logger.warn("⚠️  [DEPRECATION NOTICE] \n" + this.deprecationMessage);
+            }
+        }
+    }
+    exports.CommandConfig = CommandConfig;
+});

package/core/http/base-api.js

@@ -0,0 +1,115 @@
+/**
+ * Base API implementation, which provides basic error handling for common problems.
+ */
+(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", "../utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BaseApi = exports.NetworkError = exports.NotFoundError = exports.ServerError = exports.ForbiddenError = void 0;
+    const logger_1 = require("../utils/logger");
+    class ForbiddenError extends Error {
+        constructor(message = "Access Forbidden") {
+            super(message);
+            this.name = "ForbiddenError";
+            // Maintains proper stack trace in V8 environments (Node, Chrome)
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, ForbiddenError);
+            }
+        }
+    }
+    exports.ForbiddenError = ForbiddenError;
+    // Custom error for Server (5xx) responses.
+    class ServerError extends Error {
+        constructor(message = "Internal Server Error") {
+            super(message);
+            this.name = "ServerError";
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, ServerError);
+            }
+        }
+    }
+    exports.ServerError = ServerError;
+    // Custom error for Not Found (404) responses.
+    class NotFoundError extends Error {
+        constructor(message = "Resource Not Found") {
+            super(message);
+            this.name = "NotFoundError";
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, NotFoundError);
+            }
+        }
+    }
+    exports.NotFoundError = NotFoundError;
+    // Custom error for general network or unexpected issues.
+    class NetworkError extends Error {
+        constructor(message = "Network or unexpected error occurred") {
+            super(message);
+            this.name = "NetworkError";
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(this, NetworkError);
+            }
+        }
+    }
+    exports.NetworkError = NetworkError;
+    class BaseApi {
+        /**
+         * Constructor for BaseApiService.
+         * @param httpClient - An instance of HttpClient to be used for requests.
+         */
+        constructor(httpClient) {
+            this.httpClient = httpClient;
+        }
+        /**
+         * Handles errors from HttpClient requests.
+         * Logs the error and throws specific custom errors based on HTTP status codes.
+         * Subclasses can override this for more specific error handling.
+         * @param error - The error object caught from the HttpClient promise.
+         * @returns Never, as this method always throws an error.
+         */
+        handleError(error) {
+            logger_1.logger.debug("API Error:", error); // Basic logging
+            // Check if it looks like an HTTP error with a status code
+            if (error && typeof error.status === "number") {
+                const httpError = error;
+                switch (httpError.status) {
+                    case 401:
+                        // Handle Unauthorized (e.g., redirect to login)
+                        // Depending on the app, might not throw, but trigger auth flow
+                        // Example: throw new AuthenticationError('Authentication required');
+                        throw new Error(`Unauthorized (401): ${httpError.message || "Authentication required"}`); // Placeholder
+                    case 403:
+                        throw new ForbiddenError(`Forbidden (403): ${httpError.message || "Access denied"}`);
+                    case 404:
+                        throw new NotFoundError(`Not Found (404): ${httpError.message || "Resource not found"}`);
+                    case 500:
+                    case 501:
+                    case 502:
+                    case 503:
+                    case 504:
+                        throw new ServerError(`Server Error (${httpError.status}): ${httpError.message || "Server issue"}`);
+                    default:
+                        // Handle other HTTP errors (e.g., 400 Bad Request)
+                        throw new Error(`HTTP Error (${httpError.status}): ${httpError.message || "An HTTP error occurred"}`);
+                }
+            }
+            else if (error instanceof Error) {
+                // Handle non-HTTP errors (e.g., network issues, client-side errors)
+                console.debug("Non-HTTP Error:", error.message);
+                throw new NetworkError(`Network or client-side error: ${error.message}`);
+            }
+            else {
+                // Handle cases where the caught object is not an Error instance
+                console.debug("Unknown error structure:", error);
+                throw new Error("An unknown error occurred");
+            }
+        }
+    }
+    exports.BaseApi = BaseApi;
+});

package/{services/http-client-service.v2.js → core/http/http-client.js}

@@ -13,30 +13,39 @@ 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", "../interfaces/profile.interface", "./context.service", "../util/logger", "../util/tracing", "../util/version", "../util/axios-initializer"], factory);
+        define(["require", "exports", "form-data", "./axios-initializer", "../utils/logger", "./tracing", "../profile/profile.interface", "../utils/version"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.httpClientV2 = void 0;
-    const profile_interface_1 = require("../interfaces/profile.interface");
-    const context_service_1 = require("./context.service");
-    const logger_1 = require("../util/logger");
-    const tracing_1 = require("../util/tracing");
-    const version_1 = require("../util/version");
-    const axios_initializer_1 = require("../util/axios-initializer");
-    class HttpClientServiceV2 {
-        constructor() {
+    exports.HttpClient = void 0;
+    const FormData = require("form-data");
+    const axios_initializer_1 = require("./axios-initializer");
+    const logger_1 = require("../utils/logger");
+    const tracing_1 = require("./tracing");
+    const profile_interface_1 = require("../profile/profile.interface");
+    const version_1 = require("../utils/version");
+    /**
+     * Http client configured based upon the CLI context. It will authenticate
+     * based on the profile in the context and also use the base URL accordingly.
+     */
+    class HttpClient {
+        constructor(context) {
+            this.context = context;
             this.axios = axios_initializer_1.AxiosInitializer.initializeAxios();
         }
         get(url) {
             return __awaiter(this, void 0, void 0, function* () {
+                const fullUrl = this.resolveUrl(url);
+                logger_1.logger.debug(`HttpClient - GET ${fullUrl}`);
                 return new Promise((resolve, reject) => {
-                    this.axios.get(this.resolveUrl(url), {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile)
+                    this.axios.get(fullUrl, {
+                        headers: this.buildHeaders()
                     }).then(response => {
+                        logger_1.logger.debug(`Response ${response.status}`);
                         this.handleResponse(response, resolve, reject);
                     }).catch(err => {
+                        logger_1.logger.debug("HTTP GET resulted in error", err);
                         this.handleError(err, resolve, reject);
                     });
                 }).catch(e => {
@@ -48,7 +57,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
                     this.axios.get(this.resolveUrl(url), {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile),
+                        headers: this.buildHeaders(),
                         responseType: "stream",
                         validateStatus: status => status >= 200
                     }).then(response => {
@@ -73,7 +82,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
                     this.axios.post(this.resolveUrl(url), formData, {
-                        headers: Object.assign(Object.assign({}, this.buildHeaders(context_service_1.contextService.getContext().profile, "multipart/form-data")), formData.getHeaders()),
+                        headers: Object.assign(Object.assign({}, this.buildHeaders("multipart/form-data")), formData.getHeaders()),
                         params: parameters
                     }).then(response => {
                         this.handleResponse(response, resolve, reject);
@@ -87,9 +96,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         post(url, body) {
             return __awaiter(this, void 0, void 0, function* () {
+                const contentType = body instanceof FormData
+                    ? "multipart/form-data"
+                    : "application/json;charset=utf-8";
+                const requestBody = typeof body === "string" || body instanceof String || body instanceof FormData
+                    ? body
+                    : JSON.stringify(body);
                 return new Promise((resolve, reject) => {
-                    this.axios.post(this.resolveUrl(url), typeof body === "string" || body instanceof String ? body : JSON.stringify(body), {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile, "application/json;charset=utf-8")
+                    this.axios.post(this.resolveUrl(url), requestBody, {
+                        headers: this.buildHeaders(contentType)
                     }).then(response => {
                         this.handleResponse(response, resolve, reject);
                     }).catch(err => {
@@ -104,7 +119,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
                     this.axios.put(this.resolveUrl(url), JSON.stringify(body), {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile, "application/json;charset=utf-8")
+                        headers: this.buildHeaders("application/json;charset=utf-8")
                     }).then(response => {
                         this.handleResponse(response, resolve, reject);
                     }).catch(err => {
@@ -119,7 +134,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
                     this.axios.delete(this.resolveUrl(url), {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile, "application/json;charset=utf-8")
+                        headers: this.buildHeaders("application/json;charset=utf-8")
                     }).then(response => {
                         this.handleResponse(response, resolve, reject);
                     }).catch(err => {
@@ -134,7 +149,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
                     this.axios.post(this.resolveUrl(url), null, {
-                        headers: this.buildHeaders(context_service_1.contextService.getContext().profile),
+                        headers: this.buildHeaders(),
                         responseType: "stream"
                     }).then(response => {
                         const data = [];
@@ -164,7 +179,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             reject();
         }
         resolveUrl(url) {
-            return context_service_1.contextService.getContext().profile.team.replace(/\/?$/, url);
+            return this.context.profile.team.replace(/\/?$/, url);
         }
         handleResponse(res, resolve, reject) {
             if (this.checkBadRequest(res.status)) {
@@ -178,7 +193,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 this.handleResponse(err.response, resolve, reject);
             }
             else {
-                reject(err.message);
+                reject(err);
             }
         }
         checkBadRequest(statusCode) {
@@ -193,8 +208,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 reject("Backend responded with status code " + statusCode);
             }
         }
-        buildHeaders(profile, contentType) {
-            return Object.assign(Object.assign(Object.assign({}, this.buildAuthorizationHeaders(profile, contentType)), tracing_1.TracingUtils.getTracingHeaders()), { "User-Agent": "content-cli v" + version_1.VersionUtils.getCurrentCliVersion() });
+        buildHeaders(contentType) {
+            return Object.assign(Object.assign(Object.assign({}, this.buildAuthorizationHeaders(this.context.profile, contentType)), tracing_1.TracingUtils.getTracingHeaders()), { "User-Agent": "content-cli v" + version_1.VersionUtils.getCurrentCliVersion() });
         }
         buildAuthorizationHeaders(profile, contentType) {
             const authenticationType = profile.authenticationType || profile_interface_1.AuthenticationType.BEARER;
@@ -204,5 +219,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             };
         }
     }
-    exports.httpClientV2 = new HttpClientServiceV2();
+    exports.HttpClient = HttpClient;
 });

package/{services/context.service.js → core/http/http-shared/base.manager.helper.js}

@@ -13,28 +13,18 @@ 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", "./profile.service"], factory);
+        define(["require", "exports"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.contextService = void 0;
-    const profile_service_1 = require("./profile.service");
-    class ContextService {
-        getContext() {
-            return this.context;
-        }
-        resolveProfile(profile) {
+    exports.BaseManagerHelper = void 0;
+    class BaseManagerHelper {
+        batchPush(baseManagers) {
             return __awaiter(this, void 0, void 0, function* () {
-                const resolvedProfile = yield profile_service_1.profileService.findProfile(profile);
-                this.setContext({ profile: resolvedProfile });
+                return Promise.all(baseManagers.map(baseManager => baseManager.push()));
             });
         }
-        ;
-        setContext(context) {
-            this.context = context;
-        }
     }
-    ContextService.INSTANCE = new ContextService();
-    exports.contextService = ContextService.INSTANCE;
+    exports.BaseManagerHelper = BaseManagerHelper;
 });

package/{content/manager → core/http/http-shared}/base.manager.js

@@ -13,32 +13,25 @@ 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", "../../util/logger", "../../services/http-client.service", "fs", "path"], factory);
+        define(["require", "exports", "fs", "path", "../../utils/logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.BaseManager = void 0;
-    const logger_1 = require("../../util/logger");
-    const http_client_service_1 = require("../../services/http-client.service");
     const fs = require("fs");
     const path = require("path");
+    const logger_1 = require("../../utils/logger");
     class BaseManager {
-        constructor() {
-            this.httpClientService = new http_client_service_1.HttpClientService();
+        constructor(context) {
             this.fileDownloadedMessage = "File downloaded successfully. New filename: ";
-        }
-        get profile() {
-            return this._profile;
-        }
-        set profile(value) {
-            this._profile = value;
+            this.httpClient = context.httpClient;
         }
         pull() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.httpClientService
-                        .pullData(this.getConfig().pullUrl, this._profile)
+                    this.httpClient
+                        .get(this.getConfig().pullUrl)
                         .then(data => {
                         try {
                             const filename = this.writeToFile(data);
@@ -60,8 +53,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         pullFile() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.httpClientService
-                        .pullFileData(this.getConfig().pullUrl, this._profile)
+                    this.httpClient
+                        .downloadFile(this.getConfig().pullUrl)
                         .then(data => {
                         const filename = this.writeStreamToFile(data);
                         logger_1.logger.info(this.fileDownloadedMessage + filename);
@@ -77,8 +70,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         push() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.httpClientService
-                        .pushData(this.getConfig().pushUrl, this._profile, this.getBody())
+                    this.httpClient
+                        .post(this.getConfig().pushUrl, this.getBody())
                         .then(data => {
                         logger_1.logger.info(this.getConfig().onPushSuccessMessage(data));
                         resolve(data);
@@ -93,8 +86,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         update() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.httpClientService
-                        .updateData(this.getConfig().updateUrl, this._profile, this.getBody())
+                    this.httpClient
+                        .put(this.getConfig().updateUrl, this.getBody())
                         .then(data => {
                         logger_1.logger.info(this.getConfig().onUpdateSuccessMessage());
                         resolve(data);
@@ -109,8 +102,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         findAll() {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
-                    this.httpClientService
-                        .findAll(this.getConfig().findAllUrl, this._profile)
+                    this.httpClient
+                        .get(this.getConfig().findAllUrl)
                         .then(data => {
                         this.getConfig().onFindAll(data);
                         resolve(data);

package/{services → core/profile}/profile.service.js

@@ -13,17 +13,17 @@ 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", "../interfaces/profile.interface", "../validators/profile.validator", "path", "fs", "../util/logger", "openid-client", "axios", "os"], factory);
+        define(["require", "exports", "./profile.interface", "./profile.validator", "path", "fs", "../utils/logger", "openid-client", "axios", "os"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.profileService = exports.ProfileService = void 0;
-    const profile_interface_1 = require("../interfaces/profile.interface");
-    const profile_validator_1 = require("../validators/profile.validator");
+    const profile_interface_1 = require("./profile.interface");
+    const profile_validator_1 = require("./profile.validator");
     const path = require("path");
     const fs = require("fs");
-    const logger_1 = require("../util/logger");
+    const logger_1 = require("../utils/logger");
     const openid_client_1 = require("openid-client");
     const axios_1 = require("axios");
     const os = require("os");
@@ -40,6 +40,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         findProfile(profileName) {
             return __awaiter(this, void 0, void 0, function* () {
                 return new Promise((resolve, reject) => {
+                    this.checkIfMissingProfile(profileName, reject);
                     try {
                         if (process.env.TEAM_URL && process.env.API_TOKEN) {
                             resolve(this.buildProfileFromEnvVariables());
@@ -52,7 +53,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                         }
                     }
                     catch (e) {
-                        reject("No profile provided. Please provide a profile or an TEAM_URL and API_TOKEN through env variables");
+                        reject(`The profile ${profileName} couldn't be resolved.`);
                     }
                 });
             });
@@ -305,6 +306,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        checkIfMissingProfile(profileName, reject) {
+            if (!profileName && (!process.env.TEAM_URL || !process.env.API_TOKEN)) {
+                reject("No profile provided. Please provide a profile or an TEAM_URL and API_TOKEN through env variables");
+            }
+        }
     }
     exports.ProfileService = ProfileService;
     exports.profileService = new ProfileService();

package/{validators → core/profile}/profile.validator.js

@@ -13,15 +13,15 @@ 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", "../interfaces/profile.interface", "../util/logger", "valid-url"], factory);
+        define(["require", "exports", "../utils/logger", "valid-url", "./profile.interface"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.ProfileValidator = void 0;
-    const profile_interface_1 = require("../interfaces/profile.interface");
-    const logger_1 = require("../util/logger");
+    const logger_1 = require("../utils/logger");
     const validUrl = require("valid-url");
+    const profile_interface_1 = require("./profile.interface");
     class ProfileValidator {
         static validateProfile(profile) {
             return __awaiter(this, void 0, void 0, function* () {