@sap/cli-core 2023.12.0

package/utils/commands.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCommand = exports.buildOption = exports.registerLongName = exports.isOptionAlreadyRegistered = exports.getShortFlagForLongName = exports.createCommand = void 0;
+const commander_1 = require("commander");
+const types_1 = require("../types");
+const root_1 = require("../commands/handler/root");
+const logger_1 = require("../logger");
+const registeredOptions = {};
+const getLogger = () => (0, logger_1.get)("utils.commands");
+const checkEmpty = (name, value) => {
+    if (value.trim() === "") {
+        throw new Error(`missing value for parameter ${name}`);
+    }
+};
+const checkCommand = (command) => {
+    const { command: name, description } = command;
+    try {
+        checkEmpty("command", name);
+        checkEmpty("description", description);
+    }
+    catch (err) {
+        const { trace } = getLogger();
+        trace(`failed to check command ${JSON.stringify(command, null, 2)} because of`, err);
+        throw err;
+    }
+};
+const createCommand = (name) => {
+    const { output } = getLogger();
+    const command = new commander_1.Command(name);
+    command.enablePositionalOptions();
+    command.exitOverride();
+    command.configureOutput({ writeErr: output, writeOut: output });
+    command.allowUnknownOption();
+    return command;
+};
+exports.createCommand = createCommand;
+const getShortFlagForLongName = (longName) => {
+    for (const s of Object.keys(registeredOptions)) {
+        if (registeredOptions[s] === longName) {
+            return s;
+        }
+    }
+    throw new Error(`no short flag registered for long name ${longName}`);
+};
+exports.getShortFlagForLongName = getShortFlagForLongName;
+const isOptionAlreadyRegistered = ({ longName }, command) => {
+    // @ts-expect-error ts(2551)
+    const opts = command.options.map((o) => o.long.replace("--", ""));
+    return opts.includes(longName);
+};
+exports.isOptionAlreadyRegistered = isOptionAlreadyRegistered;
+const registerLongName = (longName) => {
+    try {
+        return (0, exports.getShortFlagForLongName)(longName);
+    }
+    catch (err) {
+        for (const c of [
+            longName[0],
+            longName[0].toUpperCase() === longName[0]
+                ? longName[0].toLowerCase()
+                : longName[0].toUpperCase(),
+            ...types_1.CHARACTERS,
+        ]) {
+            if (!registeredOptions[c]) {
+                registeredOptions[c] = longName;
+                return c;
+            }
+        }
+        throw new Error(`no short flag found for name ${longName}`);
+    }
+};
+exports.registerLongName = registerLongName;
+const buildOption = ({ longName, description, choices, required, default: defaultValue, args, }) => {
+    const mandatory = !!required;
+    const shortFlag = (0, exports.registerLongName)(longName);
+    let newDescr = description;
+    if (!mandatory) {
+        newDescr = newDescr ? `${newDescr} (optional)` : "(optional)";
+    }
+    const argStr = args
+        ? args.reduce((p, c) => (c.optional ? `${p} [${c.name}]` : `${p} <${c.name}>`), "")
+        : "";
+    const option = new commander_1.Option(`-${shortFlag}, --${longName}${argStr}`, newDescr)
+        .makeOptionMandatory(mandatory)
+        .default(defaultValue);
+    if (choices && choices.length > 0) {
+        option.choices(choices);
+    }
+    return option;
+};
+exports.buildOption = buildOption;
+const buildCommand = (topCommand, command) => {
+    []
+        .concat([command], command.type === "topCommand" ? command.subCommands : [])
+        .forEach((c) => checkCommand(c));
+    const { command: name, description, options } = command;
+    const comm = (0, exports.createCommand)(name);
+    comm.description(description);
+    comm.enablePositionalOptions();
+    options?.forEach((o) => comm.addOption((0, exports.buildOption)(o)));
+    if (command.type === "topCommand") {
+        const { subCommands } = command;
+        subCommands.forEach((s) => (0, exports.buildCommand)(comm, s));
+    }
+    else {
+        // command.type === "command"
+        const { args, handler } = command;
+        if (args) {
+            args.forEach((a) => comm.argument(`<${a.argument}>`, a.description));
+        }
+        comm.action((0, root_1.create)(handler, `Failed to ${command.description}`)(comm));
+    }
+    topCommand.addCommand(comm);
+};
+exports.buildCommand = buildCommand;

package/utils/http/index.d.ts

@@ -0,0 +1,7 @@
+import { HTTPConfig, HTTPResponse } from "../../types";
+export declare const DEFAULTS: {
+    maxBodyLength: number;
+    maxContentLength: number;
+    maxRedirects: number;
+};
+export declare const fetch: (config: HTTPConfig) => Promise<HTTPResponse>;

package/utils/http/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetch = exports.DEFAULTS = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("../../config");
+const logger_1 = require("../../logger");
+const constants_1 = require("../../constants");
+const utils_1 = require("./utils");
+const core_1 = require("../../config/core");
+exports.DEFAULTS = {
+    maxBodyLength: -1,
+    maxContentLength: -1,
+    maxRedirects: 0, // must be set to 0 because maxBodyLength: -1 won't work otherwise, see github.com/axios/axios/issues/4263
+};
+const HEADERS_ETAG = "x-sap-cli-core-discovery-etag";
+const getLogger = () => (0, logger_1.get)("http");
+const setEtag = (headers) => {
+    const { debug } = getLogger();
+    if (headers?.[HEADERS_ETAG]) {
+        (0, config_1.set)({ etag: headers[HEADERS_ETAG] });
+    }
+    else {
+        debug("header %s is not available", HEADERS_ETAG);
+    }
+};
+const getCsrfTokenFromConfig = () => {
+    const cnfg = (0, config_1.get)();
+    return cnfg[constants_1.X_CSRF_TOKEN] ? { [constants_1.X_CSRF_TOKEN]: cnfg[constants_1.X_CSRF_TOKEN] } : {};
+};
+const fetch = async (config) => {
+    const cnfg = (0, config_1.get)();
+    const { debug, trace, error, output } = getLogger();
+    try {
+        if (cnfg.verbose) {
+            // eslint-disable-next-line
+            output("%s %s", config.method.toUpperCase(), config.url);
+        }
+        debug("http config: %s", JSON.stringify(config));
+        const res = await (0, axios_1.default)({
+            ...config,
+            ...exports.DEFAULTS,
+            headers: {
+                ...getCsrfTokenFromConfig(),
+                ...config.headers,
+                "User-Agent": `${(0, core_1.getPackageName)()}+${(0, core_1.getVersion)()}`,
+            },
+        });
+        if (cnfg.verbose) {
+            output("%d %s", res.status, res.statusText);
+            (0, utils_1.printCorrelationId)(res);
+        }
+        trace("response", res);
+        setEtag(res.headers);
+        return res;
+    }
+    catch (err) {
+        error("error while executing http request", err.toString(), err.response);
+        if (cnfg.verbose) {
+            (0, utils_1.printError)(err);
+            (0, utils_1.printCorrelationId)(err.response);
+        }
+        setEtag(err.response?.headers);
+        throw err;
+    }
+};
+exports.fetch = fetch;

package/utils/http/utils.d.ts

@@ -0,0 +1,7 @@
+import { HTTPResponse } from "../../types";
+export declare const printCorrelationId: (response: HTTPResponse | undefined) => void;
+export declare const printError: (err: {
+    response?: HTTPResponse;
+    reason?: string;
+    message?: string;
+}) => void;

package/utils/http/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printError = exports.printCorrelationId = void 0;
+const logger_1 = require("../../logger");
+const getLogger = () => (0, logger_1.get)("handler.http.utils");
+const CORRELATION_ID_KEYS = [
+    "x-correlationid",
+    "x-vcap-request-id",
+    "x-request-id",
+];
+const printCorrelationId = (response) => {
+    if (!response) {
+        return;
+    }
+    let corrId = Object.entries(response.headers || {}).find((e) => CORRELATION_ID_KEYS.includes(e[0]))?.[1];
+    if (!corrId && response.data?.details?.stack) {
+        const stack = response.data.details.stack;
+        if (stack.startsWith("See correlation id ")) {
+            corrId = stack.replace("See correlation id ", "");
+        }
+    }
+    const { output } = getLogger();
+    output(corrId ? `Correlation ID ${corrId}` : "No correlation ID available");
+};
+exports.printCorrelationId = printCorrelationId;
+const printError = (err) => {
+    const { output, debug } = getLogger();
+    if (err.response) {
+        output("Request failed with %i %s", err.response.status, err.response.statusText);
+        if (err.response.data?.details?.message) {
+            output('Error: "%s"', err.response.data.details.message);
+        }
+        else {
+            debug("No error message available");
+        }
+    }
+    else if (err.reason) {
+        output('Request failed with reason "%s"', err.reason);
+    }
+    else if (err.message) {
+        output('Request failed with message "%s"', err.message);
+    }
+    else {
+        output("Request failed with an unknown error");
+    }
+};
+exports.printError = printError;

package/utils/options.d.ts

@@ -0,0 +1,3 @@
+import { Option } from "../types";
+export declare const getOptionValueFromConfig: (option: Option, defaultValue?: string) => string;
+export declare const getOptionValueFromConfigGracefully: (option: Option) => string | undefined;

package/utils/options.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOptionValueFromConfigGracefully = exports.getOptionValueFromConfig = void 0;
+const config_1 = require("../config");
+const getOptionValueFromConfig = (option, defaultValue) => {
+    const config = (0, config_1.get)();
+    if (!config.options[option.longName] &&
+        typeof defaultValue !== "string" &&
+        !defaultValue) {
+        throw new Error(`no value found for option ${option.longName}`);
+    }
+    return config.options[option.longName]
+        ? config.options[option.longName]
+        : defaultValue;
+};
+exports.getOptionValueFromConfig = getOptionValueFromConfig;
+const getOptionValueFromConfigGracefully = (option) => {
+    try {
+        return (0, exports.getOptionValueFromConfig)(option);
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+exports.getOptionValueFromConfigGracefully = getOptionValueFromConfigGracefully;

package/utils/utils.d.ts

@@ -0,0 +1,24 @@
+import { PackageJson } from "../types";
+export declare const parseVersion: (version: string) => {
+    major: number;
+    minor: number;
+};
+export declare const requireFile: (p: string) => any;
+export declare const readPackageJson: (cwd?: string, force?: boolean) => PackageJson;
+export declare const getVersion: (cwd?: string) => string;
+export declare const getName: (cwd?: string) => string;
+export declare const getPackageName: (cwd?: string) => string;
+export declare const getDescription: (cwd?: string) => string;
+export declare const getBin: (cwd?: string) => string;
+export declare const parseTenant: (tenant: string) => string;
+export declare const getInfoFromTenant: (tenant: string, verbose: boolean, printOutput?: boolean) => {
+    host: string;
+    publicfqdn: string;
+    passcodeUrl: string;
+    tenantUrl: string;
+};
+export declare const sha256: (string: string) => string;
+export declare const toConstantCase: (string: string) => string;
+export declare const openUrlInBrowser: (url: string, queryParameters?: {
+    [key: string]: string;
+}) => Promise<void>;

package/utils/utils.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openUrlInBrowser = exports.toConstantCase = exports.sha256 = exports.getInfoFromTenant = exports.parseTenant = exports.getBin = exports.getDescription = exports.getPackageName = exports.getName = exports.getVersion = exports.readPackageJson = exports.requireFile = exports.parseVersion = void 0;
+const crypto = __importStar(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const lodash_1 = require("lodash");
+const open_1 = __importDefault(require("open"));
+const logger_1 = require("../logger");
+let pgk;
+const getLogger = () => (0, logger_1.get)("utils.utils");
+const REGEX_HTTPS = /http(s)*:\/\//;
+const parseVersion = (version) => {
+    const segments = version.split(".");
+    return { major: parseInt(segments[0], 10), minor: parseInt(segments[1], 10) };
+};
+exports.parseVersion = parseVersion;
+// eslint-disable-next-line import/no-dynamic-require, global-require
+const requireFile = (p) => require(p);
+exports.requireFile = requireFile;
+const readPackageJson = (cwd = "", force = false) => {
+    if (!pgk || force) {
+        const { trace } = getLogger();
+        try {
+            const p = path_1.default.join(cwd, "./package.json");
+            trace(`reading ${p}`);
+            pgk = (0, exports.requireFile)(p);
+        }
+        catch (err) {
+            trace("failed to read package.json first time", err.stack);
+            try {
+                const p = path_1.default.join(cwd, "../package.json");
+                trace(`reading ${p}`);
+                pgk = (0, exports.requireFile)(p);
+            }
+            catch (err2) {
+                trace("failed to read package.json second time", err.stack);
+                const p = path_1.default.join(cwd, "../../package.json");
+                trace(`reading ${p}`);
+                pgk = (0, exports.requireFile)(p);
+            }
+        }
+    }
+    return pgk;
+};
+exports.readPackageJson = readPackageJson;
+const getVersion = (cwd = "") => {
+    return (0, exports.readPackageJson)(cwd, true).version;
+};
+exports.getVersion = getVersion;
+const getName = (cwd = "") => {
+    const segments = (0, exports.readPackageJson)(cwd, true).name.split(/^@.*\//);
+    return segments[segments.length - 1];
+};
+exports.getName = getName;
+const getPackageName = (cwd = "") => {
+    return (0, exports.readPackageJson)(cwd, true).name;
+};
+exports.getPackageName = getPackageName;
+const getDescription = (cwd = "") => {
+    return (0, exports.readPackageJson)(cwd, true).description;
+};
+exports.getDescription = getDescription;
+const getBin = (cwd = "") => {
+    const keys = Object.keys((0, exports.readPackageJson)(cwd, true).bin || {});
+    if (keys.length === 0) {
+        throw new Error("no bin property defined in package.json or bin property is empty");
+    }
+    return keys[0];
+};
+exports.getBin = getBin;
+const removeProtocol = (tenant) => tenant.replace(REGEX_HTTPS, "");
+const parseTenant = (tenant) => {
+    const t = REGEX_HTTPS.test(tenant) ? tenant : `https://${tenant}`;
+    /*
+        One can enter the tenant in different ways, for example
+    
+          <protocol>://<fqdn>.<landscape>.cloud.sap/
+          <fqdn>.<landscape>.cloud.sap/
+          <fqdn>.<landscape>.cloud.sap
+          <protocol>://<fqdn>.<landscape>.cloud.sap/dwaas-ui/index.html#/
+    
+        However, we want the tenant in this format, eventually:
+    
+          <protocol>://<fqdn>.<landscape>.cloud.sap
+       */
+    return new URL(t).host;
+};
+exports.parseTenant = parseTenant;
+const getInfoFromTenant = (tenant, verbose, printOutput = true) => {
+    let protocol;
+    try {
+        protocol = new URL(tenant).protocol;
+    }
+    catch {
+        protocol = "https:";
+    }
+    const publicfqdn = removeProtocol(tenant);
+    const segments = publicfqdn.split(".");
+    const hostname = segments[0];
+    const region = segments[1];
+    if (!region) {
+        const { output, error } = getLogger();
+        if (printOutput) {
+            output("error: invalid value '%s' for option '-H, --host <host>'", tenant);
+        }
+        if (verbose) {
+            output("value '%s' does not match pattern https://<prefix>.<landscape>.hcs.sap.cloud", tenant);
+        }
+        error("invalid region", region);
+        throw new Error("invalid region");
+    }
+    const parsedTenant = (0, exports.parseTenant)(tenant);
+    return {
+        host: `${protocol}//dwaas-core.sac${region}.cfapps.orca.net.sap`,
+        publicfqdn: parsedTenant,
+        passcodeUrl: `https://${hostname}.authentication.${region}.hana.ondemand.com/passcode`,
+        tenantUrl: `${protocol}//${parsedTenant}`,
+    };
+};
+exports.getInfoFromTenant = getInfoFromTenant;
+const sha256 = (string) => 
+// NOSONAR actually sha256 (or SHA-256) is considered secure according to SonarQube
+crypto.createHash("sha256").update(string).digest("base64");
+exports.sha256 = sha256;
+const toConstantCase = (string) => (0, lodash_1.upperCase)(string).replace(/ /g, "_");
+exports.toConstantCase = toConstantCase;
+const openUrlInBrowser = async (url, queryParameters = {}) => {
+    const u = new URL(url);
+    for (const [key, value] of Object.entries(queryParameters)) {
+        u.searchParams.append(key, value);
+    }
+    const urlString = u.toString();
+    const { debug } = getLogger();
+    debug(`open browser at ${urlString}`);
+    await (0, open_1.default)(urlString);
+};
+exports.openUrlInBrowser = openUrlInBrowser;