@sap/cli-core 2023.12.0

package/commands/handler/authentication/technicalJWT/exec.js

@@ -0,0 +1,196 @@
+"use strict";
+/* eslint-disable */
+var fs = require("fs-extra");
+var http = require("https");
+var path = require("path");
+var childProcess = require("child_process");
+process.on("message", (m) => {
+    if (m.kill) {
+        module.exports.kill().then(() => {
+            process.send({ killed: true });
+        });
+    }
+});
+// Define exec
+var processes = {};
+var killCallbacks = {};
+var exec = function (cmd, args, options) {
+    options = options || {};
+    options.stdio = options.stdio || [0, 1, 2];
+    options.cwd = options.cwd || path.resolve(__dirname);
+    console.log("Executing command: " + cmd + " " + args.join(" "));
+    return new Promise((resolve, reject) => {
+        var output = [];
+        var proc = childProcess.spawn(cmd, args, options);
+        processes[proc.pid] = proc;
+        if (proc.stdout) {
+            proc.stdout.on("data", (chunk) => {
+                output.push(`${chunk}`);
+            });
+        }
+        proc.on("error", reject);
+        proc.on("exit", (code, signal) => {
+            if (processes[proc.pid] === proc) {
+                delete processes[proc.pid];
+            }
+            if (typeof killCallbacks[proc.pid] === "function") {
+                console.log("Killed process: " + proc.spawnargs.join(" "));
+                return killCallbacks[proc.pid]();
+            }
+            if (code !== 0) {
+                return reject(new Error("Failed command: " +
+                    cmd +
+                    " " +
+                    args.join(" ") +
+                    ` (exited ${code})`));
+            }
+            return resolve(output.join(""));
+        });
+    });
+};
+var kill = function () {
+    var pids = Object.keys(processes);
+    var proms = [];
+    for (const pid of pids) {
+        var curProc = processes[pid];
+        if (!curProc.iskilled) {
+            proms.push(
+            // NOSONAR
+            new Promise((resolve) => {
+                setTimeout(resolve, 30 * 1000);
+                killCallbacks[curProc.pid] = resolve;
+                console.log("Killing process: " + curProc.spawnargs.join(" "));
+                curProc.kill();
+            }));
+        }
+    }
+    return Promise.all(proms);
+};
+module.exports.exec = exec;
+module.exports.kill = kill;
+module.exports.getResults = { stdio: [0, "pipe", 2] };
+// Define cf
+var cfReady;
+var cfCmd = "cf";
+process.env.CF_DEBUG = "1";
+var internalMessaging = process.env.CF_DEBUG === "1" ? "inherit" : "ignore";
+var checkCF = function () {
+    var win = process.platform === "win32";
+    var mac = process.platform === "darwin";
+    var plat = win ? "windows64-exe" : mac ? "macosx64-binary" : "linux64-binary";
+    var tmpFolder = path.resolve(__dirname, "../.tmp/cf");
+    var cfZipFile = path.resolve(tmpFolder, "client.zip");
+    var cfExeFile = path.resolve(tmpFolder, "cf.exe");
+    var cfBinFile = path.resolve(tmpFolder, "cf");
+    var downloadLink = `https://packages.cloudfoundry.org/stable?release=${plat}&source=github`;
+    if (cfReady) {
+        return cfReady;
+    }
+    cfReady = exec("cf", ["version"], { stdio: internalMessaging })
+        .then(() => {
+        console.log("Using global cf client");
+        cfCmd = "cf";
+    })
+        .catch(() => {
+        // TODO: enable local cf client after downloading
+        return (fs
+            .ensureDir(tmpFolder)
+            .then(() => fs.exists(cfZipFile))
+            .then((exists) => {
+            if (exists) {
+                return;
+            }
+            return new Promise((resolve, reject) => {
+                console.log(`Downloading cf client for platform ${plat}`);
+                console.log(downloadLink);
+                var file = fs.createWriteStream(cfZipFile, { mode: 777 });
+                var fnDownload = function (url) {
+                    http.get(url, (res, err) => {
+                        if (err) {
+                            return reject(err);
+                        }
+                        if (res.statusCode === 302 &&
+                            res.headers &&
+                            res.headers.location) {
+                            return fnDownload(res.headers.location);
+                        }
+                        res.pipe(file).on("finish", resolve);
+                    });
+                };
+                fnDownload(downloadLink);
+            }).then(() => console.log("Downloading cf client Finished ..."));
+        })
+            // Unzip
+            .then(() => {
+            if (win) {
+                console.log("Unzipping cf client");
+                return fs
+                    .readFile(cfZipFile)
+                    .then((data) => {
+                    var jsZip = require("jszip");
+                    // NOSONAR we're dealing with cf and we're pretty sure nobody messes it up
+                    return jsZip.loadAsync(data);
+                })
+                    .then((zip) => {
+                    var prom = [];
+                    Object.keys(zip.files).forEach((filename) => {
+                        if (zip.files[filename].dir) {
+                            return;
+                        }
+                        prom.push(zip.files[filename]
+                            .async("nodebuffer")
+                            .then((fileData) => {
+                            let dest = path.resolve(tmpFolder, filename);
+                            return fs.outputFile(dest, fileData);
+                        }));
+                    });
+                    return Promise.all(prom)
+                        .then(() => console.log("Unzipping cf client finished"))
+                        .then(() => {
+                        cfCmd = cfExeFile;
+                    });
+                });
+            }
+            else {
+                // Could be done with node as well
+                // TODO: test for linux and mac os
+                console.log("Unzipping cf client");
+                console.log(cfZipFile);
+                return exec("tar", ["-xf", cfZipFile, "-C", tmpFolder])
+                    .then(() => console.log("Unzipping cf client finished"))
+                    .then(() => {
+                    cfCmd = cfBinFile;
+                });
+            }
+        }));
+    })
+        .then(() => {
+        // This is expected
+    });
+    return cfReady;
+};
+var execCF = function (args, options) {
+    return checkCF().then(() => exec(cfCmd, args, options));
+};
+module.exports.cf = execCF;
+// Define npm
+var execNpm = function (args, options) {
+    if (typeof args === "string") {
+        return execNpmRun(args);
+    }
+    var cmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    options = options || {};
+    options.cwd = options.cwd || path.resolve(__dirname, "..");
+    return exec(cmd, args, options);
+};
+var execNpmRun = function (script) {
+    return execNpm(["run", script], { cwd: path.resolve(__dirname, "..") });
+};
+module.exports.npm = execNpm;
+// Define git
+var execGit = function (args, options) {
+    options = options || {};
+    options.stdio = options.stdio || ["pipe", 1, 2];
+    return exec("git", args, options);
+};
+module.exports.git = execGit;

package/commands/handler/authentication/technicalJWT/index.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../../../types";
+export declare const create: () => Handler;

package/commands/handler/authentication/technicalJWT/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const config_1 = require("../../../../config");
+const commands_1 = require("../../../../utils/commands");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const create = () => (command) => {
+    command.addOption((0, commands_1.buildOption)(types_1.OPTION_SECRET));
+    return async () => {
+        const token = await (0, utils_1.getTechnicalJwt)();
+        (0, config_1.set)({ authorization: { Authorization: `Bearer ${token}` } });
+    };
+};
+exports.create = create;

package/commands/handler/authentication/technicalJWT/types.d.ts

@@ -0,0 +1,2 @@
+import { Option } from "../../../../types";
+export declare const OPTION_SECRET: Option;

package/commands/handler/authentication/technicalJWT/types.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTION_SECRET = void 0;
+exports.OPTION_SECRET = {
+    longName: "secret",
+    description: "specifies the path to the secret file",
+    args: [{ name: "secret" }],
+};

package/commands/handler/authentication/technicalJWT/utils.d.ts

@@ -0,0 +1 @@
+export declare const getTechnicalJwt: () => Promise<string>;

package/commands/handler/authentication/technicalJWT/utils.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTechnicalJwt = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const config_1 = require("../../../../config");
+const logger_1 = require("../../../../logger");
+const http_1 = require("../../../../utils/http");
+const types_1 = require("./types");
+const getLogger = () => (0, logger_1.get)("commands.handler.authentication.technicalJWT.utils");
+// eslint-disable-next-line
+const cf = require("./cf.js");
+const APPNAME_GLOBAL = "dwaas-core";
+const getSecret = async () => {
+    const { trace } = getLogger();
+    const config = (0, config_1.get)();
+    const secretsFile = config.options[types_1.OPTION_SECRET.longName] ||
+        path_1.default.join(process.cwd(), ".secret.json");
+    trace("reading secret from", secretsFile);
+    if (fs_extra_1.default.existsSync(secretsFile)) {
+        const content = await fs_extra_1.default.readFile(secretsFile, "utf8");
+        return JSON.parse(content);
+    }
+    const currentTarget = await cf.getCurrentTarget();
+    let [env] = await cf.getEnv(APPNAME_GLOBAL, currentTarget.org, currentTarget.space);
+    env = JSON.parse(env);
+    const vcap = Object.keys(env)
+        .map((k) => env[k].VCAP_SERVICES)
+        .find((v) => v);
+    const url = Object.keys(env)
+        .map((k) => env[k].VCAP_APPLICATION)
+        .find((v) => v && v.uris && v.uris[0]).uris[0];
+    if (!vcap || !vcap.xsuaa) {
+        throw new Error("The target application is missing a uaa binding.");
+    }
+    const uaa = vcap.xsuaa.find((v) => v.credentials);
+    if (!uaa) {
+        throw new Error("The target application is missing a uaa binding with credentials.");
+    }
+    return {
+        url: `https://${url}`,
+        uaaUrl: uaa.credentials.url,
+        clientid: uaa.credentials.clientid,
+        clientsecret: uaa.credentials.clientsecret,
+        tenantid: uaa.credentials.tenantid,
+    };
+};
+const getTechnicalJwt = async () => {
+    const secret = await getSecret();
+    const { data } = await (0, http_1.fetch)({
+        method: "POST",
+        url: `${secret.uaaUrl}/oauth/token`,
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        data: new url_1.URLSearchParams({
+            grant_type: "client_credentials",
+            response_type: "token",
+            client_id: secret.clientid,
+            client_secret: secret.clientsecret,
+        }).toString(),
+    });
+    if (!data.access_token) {
+        throw new Error("No token could be retrieved from the application.");
+    }
+    return data.access_token;
+};
+exports.getTechnicalJwt = getTechnicalJwt;

package/commands/handler/authentication/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const setAuthorization: (authorization: {
+    [key: string]: string;
+}) => void;

package/commands/handler/authentication/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAuthorization = void 0;
+const config_1 = require("../../../config");
+const setAuthorization = (authorization) => {
+    (0, config_1.set)({ authorization: { ...authorization } });
+};
+exports.setAuthorization = setAuthorization;

package/commands/handler/checkOptionsExistence.d.ts

@@ -0,0 +1,2 @@
+import { Handler, Option } from "../../types";
+export declare const create: (option: Option, throwIfExists?: boolean) => Handler;

package/commands/handler/checkOptionsExistence.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const config_1 = require("../../config");
+const logger_1 = require("../../logger");
+const create = (option, throwIfExists = true) => () => async () => {
+    const config = (0, config_1.get)();
+    const { trace } = (0, logger_1.get)("commands.handler.checkOptionsExistence");
+    trace(`checking options existence ${option.longName} in config, value in config is ${config.options[option.longName]}, throw error if option exists ${throwIfExists}`);
+    if (config.options[option.longName] && throwIfExists) {
+        throw new Error(`option ${option.longName} already set`);
+    }
+    else if (!config.options[option.longName] && !throwIfExists) {
+        throw new Error(`option ${option.longName} is not set`);
+    }
+};
+exports.create = create;

package/commands/handler/error.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: (errorMessage: string, handler: Handler) => Handler;

package/commands/handler/error.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../logger");
+const stackTrace_1 = require("./stackTrace");
+const errorHandler = (errorMessage, handler) => (command) => {
+    const commandHandler = handler(command);
+    return async (...args) => {
+        try {
+            await commandHandler(...args);
+        }
+        catch (err) {
+            const { error } = (0, logger_1.get)("commands.handler.error");
+            error(errorMessage, err);
+            throw new Error(`handler failed: ${errorMessage}`);
+        }
+    };
+};
+const create = (errorMessage, handler) => (0, stackTrace_1.create)(errorHandler(errorMessage, handler));
+exports.create = create;
+/* jscpd:ignore-end */

package/commands/handler/fail.d.ts

@@ -0,0 +1,2 @@
+import { Handler } from "../../types";
+export declare const create: () => Handler;

package/commands/handler/fail.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const logger_1 = require("../../logger");
+const create = () => () => async () => {
+    const { debug } = (0, logger_1.get)("commands.handler.fail");
+    debug(`running fail handler`);
+    throw new Error("Fail I must");
+};
+exports.create = create;

package/commands/handler/fetch/fetch.d.ts

@@ -0,0 +1,2 @@
+import { Handler, HTTPMethod, ParameterMappings, ResponsePostProcessor } from "../../../types";
+export declare const create: (method: HTTPMethod, path: string, parameterMappings?: ParameterMappings, responsePostProcessor?: ResponsePostProcessor) => Handler;

package/commands/handler/fetch/fetch.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const config_1 = require("../../../config");
+const http_1 = require("../../../utils/http");
+const utils_1 = require("./utils");
+const utils_2 = require("../authentication/oauth/tokenProvider/utils");
+const logger_1 = require("../../../logger");
+const constants_1 = require("../../../constants");
+const getLogger = () => (0, logger_1.get)("commands.handler.fetch");
+const removeCsrfTokenFromConfig = () => {
+    const config = (0, config_1.get)();
+    delete config[constants_1.X_CSRF_TOKEN];
+};
+// developer.mozilla.org/en-US/docs/Web/HTTP/Redirections
+const REDIRECT_STATUS_CODES = [301, 302, 303, 307, 308];
+const REDIRECT_WITHOUT_CHANGE = [307, 308];
+const fetchData = async (method, path, parameterMappings, responsePostProcessor) => {
+    const config = (0, config_1.get)();
+    (0, utils_1.checkConfiguration)(config);
+    const conf = (0, utils_1.buildHttpConfig)(method, path, parameterMappings);
+    const response = await (0, http_1.fetch)(conf);
+    removeCsrfTokenFromConfig();
+    await (0, utils_1.handleResponse)(response.data, response.headers);
+    if (responsePostProcessor) {
+        await responsePostProcessor(response);
+    }
+};
+const handle401 = async (method, path, parameterMappings) => {
+    const { debug, error } = getLogger();
+    debug("response status is 401, trying to refresh access_token");
+    try {
+        await (0, utils_2.refreshToken)(true);
+        await fetchData(method, path, parameterMappings);
+        debug("refreshing token and fetching data succeeded");
+    }
+    catch (errRefresh) {
+        error("refreshing token and fetching data again failed", errRefresh);
+        throw errRefresh;
+    }
+};
+const handleRedirect = async (error, method, redirect) => {
+    const location = error.response?.headers.location;
+    if (!location) {
+        throw new Error("location header is not present for redirect");
+    }
+    let newMethod = method;
+    if (!REDIRECT_WITHOUT_CHANGE.includes(error.response?.status)) {
+        newMethod = "GET";
+    }
+    await redirect(newMethod, location);
+};
+const handleError = async (error, method, redirect, path, parameterMappings) => {
+    const { error: logError } = getLogger();
+    logError("failed to fetch data", error);
+    if (error.response?.data && (0, config_1.get)().verbose) {
+        await (0, utils_1.handleResponseData)(error.response?.data);
+    }
+    if (error.response?.status === 401) {
+        await handle401(method, path, parameterMappings);
+    }
+    else if (REDIRECT_STATUS_CODES.includes(error.response?.status)) {
+        await handleRedirect(error, method, redirect);
+    }
+    else {
+        throw error;
+    }
+};
+const runRequest = (method, path, parameterMappings, responsePostProcessor) => async () => {
+    try {
+        await fetchData(method, path, parameterMappings, responsePostProcessor);
+    }
+    catch (errFetch) {
+        const redirect = (newMethod, location) => runRequest(newMethod, location, parameterMappings, responsePostProcessor)();
+        await handleError(errFetch, method, redirect, path, parameterMappings);
+    }
+};
+/* jscpd:ignore-start */
+const create = (method, path, parameterMappings, responsePostProcessor) => {
+    /* jscpd:ignore-end */
+    return () => runRequest(method, path, parameterMappings, responsePostProcessor);
+};
+exports.create = create;

package/commands/handler/fetch/index.d.ts

@@ -0,0 +1,2 @@
+import { Handler, HTTPMethod, ParameterMappings, ResponsePostProcessor } from "../../../types";
+export declare const create: (method: HTTPMethod, path: string, parameterMappings?: ParameterMappings, responsePostProcessor?: ResponsePostProcessor) => Handler;

package/commands/handler/fetch/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const constants_1 = require("../../../constants");
+const fetch_1 = require("./fetch");
+const next_1 = require("../next");
+const requiresCsrfToken = (parameterMappings) => !!parameterMappings?.find((param) => param.name === constants_1.X_CSRF_TOKEN);
+const createCsrfTokenFetchHandler = (path, parameterMappings) => (0, fetch_1.create)("GET", path, parameterMappings
+    ?.filter((param) => param.name !== constants_1.X_CSRF_TOKEN)
+    .concat([
+    {
+        name: constants_1.X_CSRF_TOKEN,
+        in: "header",
+        source: { type: "value", value: "fetch" },
+    },
+]));
+/* jscpd:ignore-start */
+const create = (method, path, parameterMappings, responsePostProcessor) => {
+    /* jscpd:ignore-end */
+    if (requiresCsrfToken(parameterMappings)) {
+        return (0, next_1.create)(createCsrfTokenFetchHandler(path, parameterMappings), (0, fetch_1.create)(method, path, parameterMappings, responsePostProcessor));
+    }
+    return (0, fetch_1.create)(method, path, parameterMappings, responsePostProcessor);
+};
+exports.create = create;

package/commands/handler/fetch/utils.d.ts

@@ -0,0 +1,14 @@
+import { URL } from "url";
+import { AxiosResponseHeaders, RawAxiosResponseHeaders } from "axios";
+import { HTTPConfig, HTTPMethod, KeyValuePair, ParameterMappings } from "../../../types";
+export declare const checkConfiguration: (config: KeyValuePair) => void;
+export declare const removeLeadingPathSegmentForPasscode: (path: string) => string;
+export declare const buildParameters: (path: string, parameterMappings?: ParameterMappings) => {
+    url: URL;
+    headers: KeyValuePair;
+    body: any;
+};
+export declare const handleResponseData: (data: any) => Promise<void>;
+export declare const handleResponse: (data: any, headers?: RawAxiosResponseHeaders | AxiosResponseHeaders) => Promise<void>;
+export declare const configRequiresBody: (method: HTTPMethod) => boolean;
+export declare const buildHttpConfig: (method: HTTPMethod, path: string, parameterMappings?: ParameterMappings) => HTTPConfig;

package/commands/handler/fetch/utils.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHttpConfig = exports.configRequiresBody = exports.handleResponse = exports.handleResponseData = exports.buildParameters = exports.removeLeadingPathSegmentForPasscode = exports.checkConfiguration = void 0;
+const url_1 = require("url");
+const lodash_1 = __importDefault(require("lodash"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constants_1 = require("../../../constants");
+const logger_1 = require("../../../logger");
+const config_1 = require("../../../config");
+const utils_1 = require("../utils");
+const ResultHandlerFactory_1 = require("../../../result/ResultHandlerFactory");
+const CURLY_OPEN_ENCODED = encodeURIComponent("{");
+const CURLY_CLOSED_ENCODED = encodeURIComponent("}");
+const checkConfiguration = (config) => {
+    if (!config.authorization) {
+        throw new Error("no authorization header");
+    }
+    if (!config.host) {
+        throw new Error("no host");
+    }
+    if (!config.publicfqdn) {
+        throw new Error("no publicfqdn");
+    }
+};
+exports.checkConfiguration = checkConfiguration;
+const removeLeadingPathSegmentForPasscode = (path) => {
+    const authenticationMethod = (0, utils_1.getAuthenticationMethod)();
+    if (authenticationMethod === constants_1.AuthenticationMethod.passcode) {
+        const segments = path.split("/");
+        if (constants_1.SEGMENTS_TO_REMOVE_FOR_PASSCODE_AUTH.includes(segments[1])) {
+            segments.splice(1, 1);
+            return segments.join("/");
+        }
+    }
+    return path;
+};
+exports.removeLeadingPathSegmentForPasscode = removeLeadingPathSegmentForPasscode;
+const getUrl = (path) => {
+    if (path.startsWith("http")) {
+        return new url_1.URL(path);
+    }
+    const pathInt = (0, exports.removeLeadingPathSegmentForPasscode)(path);
+    const targetHost = (0, utils_1.getTargetHost)();
+    return new url_1.URL(`${targetHost}${pathInt}`);
+};
+const handleMappingIn = (mapping, url, value, headers, bodyWrapper) => {
+    if (mapping.in === "query") {
+        url.searchParams.append(mapping.name, value);
+    }
+    else if (mapping.in === "header") {
+        // eslint-disable-next-line no-param-reassign
+        headers[mapping.name] = value;
+    }
+    else if (mapping.in === "path") {
+        // eslint-disable-next-line no-param-reassign
+        url.pathname = url.pathname.replace(new RegExp(`${CURLY_OPEN_ENCODED}${mapping.name}${CURLY_CLOSED_ENCODED}`, "g"), value);
+    }
+    else {
+        // NOSONAR
+        // if (mapping.in === "body") {
+        if (!bodyWrapper.body) {
+            // eslint-disable-next-line no-param-reassign
+            bodyWrapper.body = {};
+        }
+        lodash_1.default.set(bodyWrapper.body, mapping.name, value);
+    }
+};
+const getValueFromMappping = (mapping, config) => {
+    if (mapping.source.type === "value") {
+        return mapping.source.value;
+    }
+    if (
+    // mapping.source.type === "option"
+    config.options[mapping.source.name] === undefined &&
+        mapping.source.dataType === "boolean") {
+        return false;
+    }
+    // mapping.source.type === "option"
+    return config.options[mapping.source.name];
+};
+const handleParameterMapping = (config, url, headers, bodyWrapper) => (mapping) => {
+    const value = getValueFromMappping(mapping, config);
+    if (value === undefined || value === null) {
+        return;
+    }
+    handleMappingIn(mapping, url, value, headers, bodyWrapper);
+};
+const buildParameters = (path, parameterMappings) => {
+    const config = (0, config_1.get)();
+    const headers = {};
+    const bodyWrapper = {
+        body: config.data,
+    };
+    const url = getUrl(path);
+    parameterMappings?.forEach(handleParameterMapping(config, url, headers, bodyWrapper));
+    return {
+        url,
+        headers,
+        body: bodyWrapper.body,
+    };
+};
+exports.buildParameters = buildParameters;
+const handleResponseData = async (data) => {
+    const config = (0, config_1.get)();
+    if (!config.doNotStoreResult) {
+        ResultHandlerFactory_1.ResultHandlerFactory.get().setResult(data);
+    }
+    const { output } = (0, logger_1.get)("handler.fetch");
+    const formatted = config.options[constants_1.OPTION_PRETTY.longName]
+        ? JSON.stringify(data, null, 2)
+        : JSON.stringify(data);
+    if (config.options[constants_1.OPTION_OUTPUT.longName]) {
+        await fs_extra_1.default.writeFile(config.options[constants_1.OPTION_OUTPUT.longName], formatted);
+    }
+    else {
+        output(formatted);
+    }
+};
+exports.handleResponseData = handleResponseData;
+const handleResponse = async (data, headers) => {
+    if (headers?.[constants_1.X_CSRF_TOKEN]) {
+        (0, config_1.set)({ [constants_1.X_CSRF_TOKEN]: headers[constants_1.X_CSRF_TOKEN] });
+    }
+    else if (data) {
+        await (0, exports.handleResponseData)(data);
+    }
+};
+exports.handleResponse = handleResponse;
+const configRequiresBody = (method) => ["POST", "PUT", "PATCH"].includes(method.toUpperCase());
+exports.configRequiresBody = configRequiresBody;
+const buildHttpConfig = (method, path, parameterMappings) => {
+    const config = (0, config_1.get)();
+    const { url, body, headers } = (0, exports.buildParameters)(path, parameterMappings);
+    const httpConfig = {
+        url: url.toString(),
+        method,
+        data: (0, exports.configRequiresBody)(method) ? body : undefined,
+        headers: {
+            ...config.authorization,
+            ...headers,
+            publicfqdn: config.publicfqdn,
+        },
+    };
+    if ((0, utils_1.getAuthenticationMethod)() === constants_1.AuthenticationMethod.oauth) {
+        delete httpConfig.headers.publicfqdn;
+    }
+    return httpConfig;
+};
+exports.buildHttpConfig = buildHttpConfig;