@sap/cli-core 2025.16.0 → 2025.19.0

package/commands/login.command.js

@@ -1,33 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyHost = void 0;
-const SecretsStorageSingleton_1 = require("../cache/secrets/SecretsStorageSingleton");
-const utils_1 = require("../cache/secrets/utils");
-const constants_1 = require("../constants");
-const logger_1 = require("../logger");
-const utils_2 = require("../logger/utils");
-const openUtils_1 = require("../utils/openUtils");
-const options_1 = require("../utils/options");
-const utils_3 = require("../utils/utils");
-const init_command_1 = require("./config.command/cache.command/init.command");
-const handler_1 = require("./handler");
-const utils_4 = require("./handler/options/utils");
-const getLogger = () => (0, logger_1.get)("commands.login");
-const verifyHost = async () => async () => {
+import { SecretsStorageSingleton } from "../cache/secrets/SecretsStorageSingleton.js";
+import { getTenantUrl } from "../cache/secrets/utils.js";
+import { OPTION_ACCESS_TOKEN, OPTION_AUTHORIZATION_FLOW, OPTION_AUTHORIZATION_URL, OPTION_BROWSER, OPTION_CLIENT_ID, OPTION_CLIENT_SECRET, OPTION_CODE, OPTION_HOST, OPTION_OPTIONS_FILE, OPTION_REFRESH_TOKEN, OPTION_SECRETS_FILE, OPTION_TLS_VERSION, OPTION_TOKEN_URL, OPTION_VERBOSE, ROOT_COMMAND, } from "../constants.js";
+import { get } from "../logger/index.js";
+import { logVerbose } from "../logger/utils.js";
+import { getDefaultBrowser, getSupportedBrowsers } from "../utils/openUtils.js";
+import { getOptionValueFromConfig } from "../utils/options.js";
+import { buildOptionName } from "../utils/utils.js";
+import { init } from "./config.command/cache.command/init.command/index.js";
+import { createMandatoryOptionsHandler, createNextHandler, createOauthHandler, createOptionsHandler, createOrHandler, createParseArgumentsHandler, } from "./handler/index.js";
+import { promptForValue } from "./handler/options/utils.js";
+const getLogger = () => get("commands.login");
+export const verifyHost = async () => async () => {
     const logger = getLogger();
     try {
-        const url = (0, utils_1.getTenantUrl)();
+        const url = getTenantUrl();
         logger.debug(`url defined as ${url}`);
     }
     catch (err) {
         logger.error("tenant URL not defined. use option -H, --host");
-        (0, utils_2.logVerbose)(logger, "specify the tenant URL using option --host");
+        logVerbose(logger, "specify the tenant URL using option --host");
         throw new Error("tenant URL not defined. use option -H, --host");
     }
 };
-exports.verifyHost = verifyHost;
 const confirmSecretsOverwrite = async (tenantUrl) => {
-    const promptResponse = await (0, utils_4.promptForValue)({
+    const promptResponse = await promptForValue({
         prompts: {
             type: "confirm",
             message: `Secret for tenant ${tenantUrl} already exists. Do you want to overwrite it?`,
@@ -42,37 +38,42 @@ const initializeCache = async () => async () => {
     const { warn, info } = getLogger();
     info("initializing cache after successful login");
     try {
-        (0, options_1.getOptionValueFromConfig)(constants_1.OPTION_HOST);
-        await (await (0, init_command_1.init)())();
+        getOptionValueFromConfig(OPTION_HOST);
+        await (await init())();
     }
     catch (err) {
-        warn(`option ${(0, utils_3.buildOptionName)(constants_1.ROOT_COMMAND, constants_1.OPTION_HOST)} not defined, skipping cache init`);
+        warn(`option ${buildOptionName(ROOT_COMMAND, OPTION_HOST)} not defined, skipping cache init`);
     }
 };
 const fetchSupportedBrowsers = async () => {
-    const list = await (0, openUtils_1.getSupportedBrowsers)();
+    const list = await getSupportedBrowsers();
     return list.map(({ name }) => name);
 };
 const saveSecrets = async () => async () => {
-    await SecretsStorageSingleton_1.SecretsStorageSingleton.SINGLETON.synchronizeSecretsToStorage();
+    await SecretsStorageSingleton.SINGLETON.synchronizeSecretsToStorage();
 };
-const warnIfSecretExists = async () => {
+const warnIfSecretExistsInCache = async () => {
     return async () => {
         const logger = getLogger();
-        const tenantUrl = (0, utils_1.getTenantUrl)();
-        const secretsStorage = SecretsStorageSingleton_1.SecretsStorageSingleton.SINGLETON;
-        if (secretsStorage.hasSecretForTenant &&
-            secretsStorage.hasSecretForTenant(tenantUrl)) {
+        const tenantUrl = getTenantUrl();
+        const secretsStorage = SecretsStorageSingleton.SINGLETON;
+        // Default secret is from cache since secrets file and options aren't loaded yet
+        const cachedSecret = await secretsStorage.getDefaultSecret();
+        if (cachedSecret) {
             const shouldOverwrite = await confirmSecretsOverwrite(tenantUrl);
             logger.debug(`user response for overwriting secrets for tenant ${tenantUrl}: ${shouldOverwrite}`);
             if (!shouldOverwrite) {
                 const message = `Aborted: Secret for tenant ${tenantUrl} already exists and will not be overwritten.`;
                 logger.warn(message);
-                // Do not throw, just log and return
+                // Stop proceeding with the login process as a secret for the tenant already exists
                 return;
             }
+            logger.info(`Overwriting existing secret for tenant ${tenantUrl}. Proceeding with login.`);
+            // Remove the cached secret to allow the new one to be created
+            secretsStorage.deleteSecretById(cachedSecret.id);
+            logger.debug(`Existing secret for tenant ${tenantUrl} has been removed.`);
         }
-        throw new Error(`Warning: Previous login secrets for tenant ${tenantUrl} will be removed and overwritten with new credentials.`);
+        throw new Error(`Login secret for tenant ${tenantUrl} must be loaded.`);
     };
 };
 const loginCommand = {
@@ -80,24 +81,25 @@ const loginCommand = {
     command: "login",
     description: "log in to your account using interactive OAuth authentication",
     options: [],
-    handler: (0, handler_1.createNextHandler)("login.command", (0, handler_1.createParseArgumentsHandler)(), (0, handler_1.createOptionsHandler)([
-        { ...constants_1.OPTION_HOST, hidden: false, required: true },
-        constants_1.OPTION_VERBOSE,
-        constants_1.OPTION_OPTIONS_FILE,
-        { ...constants_1.OPTION_AUTHORIZATION_URL, hidden: false },
-        { ...constants_1.OPTION_TOKEN_URL, hidden: false },
-        { ...constants_1.OPTION_CLIENT_ID, hidden: false },
-        { ...constants_1.OPTION_CLIENT_SECRET, hidden: false },
-        { ...constants_1.OPTION_ACCESS_TOKEN, hidden: false },
-        { ...constants_1.OPTION_CODE, hidden: false },
-        { ...constants_1.OPTION_REFRESH_TOKEN, hidden: false },
-        { ...constants_1.OPTION_SECRETS_FILE, hidden: false },
+    handler: createNextHandler("login.command", createParseArgumentsHandler(), createOptionsHandler([
+        { ...OPTION_HOST, hidden: false, required: true },
+        OPTION_VERBOSE,
+        OPTION_OPTIONS_FILE,
+        { ...OPTION_AUTHORIZATION_URL, hidden: false },
+        { ...OPTION_TOKEN_URL, hidden: false },
+        { ...OPTION_CLIENT_ID, hidden: false },
+        { ...OPTION_CLIENT_SECRET, hidden: false },
+        { ...OPTION_ACCESS_TOKEN, hidden: false },
+        { ...OPTION_CODE, hidden: false },
+        { ...OPTION_REFRESH_TOKEN, hidden: false },
+        { ...OPTION_SECRETS_FILE, hidden: false },
+        { ...OPTION_TLS_VERSION, hidden: false },
         {
-            ...constants_1.OPTION_BROWSER,
+            ...OPTION_BROWSER,
             choices: fetchSupportedBrowsers,
-            default: openUtils_1.getDefaultBrowser,
+            default: getDefaultBrowser,
         },
-        { ...constants_1.OPTION_AUTHORIZATION_FLOW, hidden: false },
-    ]), (0, handler_1.createMandatoryOptionsHandler)(), exports.verifyHost, (0, handler_1.createOrHandler)("commands.login", warnIfSecretExists, (0, handler_1.createNextHandler)("commands.login", (0, handler_1.createOauthHandler)(true), initializeCache, saveSecrets))),
+        { ...OPTION_AUTHORIZATION_FLOW, hidden: false },
+    ]), createMandatoryOptionsHandler(), verifyHost, createOrHandler("commands.login", warnIfSecretExistsInCache, createNextHandler("commands.login", createOauthHandler(), initializeCache, saveSecrets))),
 };
-exports.default = loginCommand;
+export default loginCommand;

package/commands/logout.command.d.ts

@@ -1,3 +1,3 @@
-import { LeafCommand } from "../types";
+import { LeafCommand } from "../types.js";
 declare const logoutCommand: LeafCommand;
 export default logoutCommand;

package/commands/logout.command.js

@@ -1,30 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const SecretsStorageSingleton_1 = require("../cache/secrets/SecretsStorageSingleton");
-const constants_1 = require("../constants");
-const logger_1 = require("../logger");
-const config_1 = require("../config");
-const handler_1 = require("./handler");
-const utils_1 = require("../logger/utils");
-const utils_2 = require("./utils");
+import { SecretsStorageSingleton } from "../cache/secrets/SecretsStorageSingleton.js";
+import { OPTION_LOGIN_ID, OPTION_VERBOSE } from "../constants.js";
+import { get as getLogger } from "../logger/index.js";
+import { get as getConfig } from "../config/index.js";
+import { createNextHandler, createOptionsHandler, createParseArgumentsHandler, } from "./handler/index.js";
+import { logVerbose } from "../logger/utils.js";
+import { getChoices } from "./utils.js";
 const handler = async () => async () => {
     try {
-        const config = (0, config_1.get)();
-        SecretsStorageSingleton_1.SecretsStorageSingleton.SINGLETON.deleteSecretById(config.options[constants_1.OPTION_LOGIN_ID.longName]);
+        const config = getConfig();
+        SecretsStorageSingleton.SINGLETON.deleteSecretById(config.options[OPTION_LOGIN_ID.longName]);
     }
     catch (err) {
-        const logger = (0, logger_1.get)("commands.logout");
+        const logger = getLogger("commands.logout");
         logger.error("failed to delete secrets file from cache", err);
-        (0, utils_1.logVerbose)(logger, err.message);
+        logVerbose(logger, err.message);
     }
 };
 const logoutCommand = {
     type: "command",
     command: "logout",
     description: "log out from your account",
-    handler: (0, handler_1.createNextHandler)("logout.command", (0, handler_1.createParseArgumentsHandler)(), (0, handler_1.createOptionsHandler)([
-        { ...constants_1.OPTION_LOGIN_ID, choices: utils_2.getChoices },
-        constants_1.OPTION_VERBOSE,
+    handler: createNextHandler("logout.command", createParseArgumentsHandler(), createOptionsHandler([
+        { ...OPTION_LOGIN_ID, choices: getChoices },
+        OPTION_VERBOSE,
     ]), handler),
 };
-exports.default = logoutCommand;
+export default logoutCommand;

package/commands/openAPI.command/index.d.ts

@@ -1,2 +1,2 @@
-import { AddCommands } from "../../types";
+import { AddCommands } from "../../types.js";
 export declare const addCommands: AddCommands;

package/commands/openAPI.command/index.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addCommands = void 0;
-const discovery_1 = require("../../discovery");
-const logger_1 = require("../../logger");
-const constants_1 = require("../../constants");
-const handler_1 = require("../handler");
-const commands_1 = require("../../utils/commands");
-const utils_1 = require("./utils");
-const getLogger = () => (0, logger_1.get)("commands.openAPI");
+import { init } from "../../discovery/index.js";
+import { get } from "../../logger/index.js";
+import { OPTION_HOST } from "../../constants.js";
+import { createFetchHandler, createMandatoryOptionsHandler, createNextHandler, createParseArgumentsHandler, createAuthenticationHandler, createOptionsHandler, } from "../handler/index.js";
+import { buildCommand } from "../../utils/commands.js";
+import { getDescriptionForCommand, getSchema, handleDeprecationNotice, handleForceOption, handleParameters, handleReadPathHandler, handleRequestBody, handleResponses, updatePath, } from "./utils.js";
+const getLogger = () => get("commands.openAPI");
 const getCommandDescription = (document, segments, index) => {
     const segment = segments
         .slice(0, index + 1)
@@ -26,7 +23,7 @@ const addCommandToArray = (document, commands, segments, index) => {
             description: getCommandDescription(document, segments, index),
             command: segment,
             subCommands: [],
-            options: [constants_1.OPTION_HOST],
+            options: [OPTION_HOST],
         };
         commands.push(command);
         return addCommandToArray(document, command.subCommands, segments, index + 1);
@@ -45,12 +42,12 @@ const addCommandToArray = (document, commands, segments, index) => {
 };
 const setHandler = (command, method, path, parameterMappings, readPathResponseHandler, ...handler) => {
     // eslint-disable-next-line no-param-reassign
-    command.handler = (0, handler_1.createNextHandler)("openAPI.command", (0, handler_1.createParseArgumentsHandler)(), (0, handler_1.createMandatoryOptionsHandler)(), (0, handler_1.createAuthenticationHandler)(), ...handler, (0, handler_1.createFetchHandler)(method, path, parameterMappings, readPathResponseHandler));
+    command.handler = createNextHandler("openAPI.command", createParseArgumentsHandler(), createMandatoryOptionsHandler(), createAuthenticationHandler(), ...handler, createFetchHandler(method, path, parameterMappings, readPathResponseHandler));
 };
-const addCommands = async (program) => {
+export const addCommands = async (program) => {
     const { error, debug, trace } = getLogger();
     try {
-        const doc = await (0, discovery_1.init)();
+        const doc = await init();
         const commands = [];
         for (const path of Object.keys(doc.paths)) {
             const pathItem = doc.paths[path];
@@ -63,14 +60,14 @@ const addCommands = async (program) => {
                     const cmd = addCommandToArray(doc, commands, operation.operationId.split(" "), 0);
                     remove = cmd.remove;
                     const { command } = cmd;
-                    command.description = (0, utils_1.getDescriptionForCommand)(command, operation);
-                    (0, utils_1.handleRequestBody)(operation, handler, doc, parameterMappings, command);
-                    (0, utils_1.handleForceOption)(operation, handler);
-                    (0, utils_1.handleResponses)(operation, command);
-                    (0, utils_1.handleParameters)(operation, doc, parameterMappings, command, (0, utils_1.getSchema)(pathItem.parameters || [], doc));
-                    (0, utils_1.handleDeprecationNotice)(operation, command);
-                    const readPathResponseHandler = (0, utils_1.handleReadPathHandler)(doc, operation);
-                    setHandler(command, method, (0, utils_1.updatePath)(doc, path), parameterMappings, readPathResponseHandler, ...[(0, handler_1.createOptionsHandler)(command.options), ...handler]);
+                    command.description = getDescriptionForCommand(command, operation);
+                    handleRequestBody(operation, handler, doc, parameterMappings, command);
+                    handleForceOption(operation, handler);
+                    handleResponses(operation, command);
+                    handleParameters(operation, doc, parameterMappings, command, getSchema(pathItem.parameters || [], doc));
+                    handleDeprecationNotice(operation, command);
+                    const readPathResponseHandler = handleReadPathHandler(doc, operation);
+                    setHandler(command, method, updatePath(doc, path), parameterMappings, readPathResponseHandler, ...[createOptionsHandler(command.options), ...handler]);
                     delete command.options;
                 }
                 catch (err) {
@@ -83,7 +80,7 @@ const addCommands = async (program) => {
             trace("adding command %s", JSON.stringify(command));
             try {
                 // eslint-disable-next-line no-await-in-loop
-                await (0, commands_1.buildCommand)(program, command);
+                await buildCommand(program, command);
             }
             catch (err) {
                 error("error while adding command %s", JSON.stringify(command, null, 2), err.stack);
@@ -95,4 +92,3 @@ const addCommands = async (program) => {
         throw err;
     }
 };
-exports.addCommands = addCommands;

package/commands/openAPI.command/utils.d.ts

@@ -1,4 +1,4 @@
-import { Command, Discovery, Handler, In, JSONReference, JSONSchema, Operation, Option, ParameterMappings, Parameters, ResponsePostProcessor } from "../../types";
+import { Command, Discovery, Handler, In, JSONReference, JSONSchema, Operation, Option, ParameterMappings, Parameters, ResponsePostProcessor } from "../../types.js";
 type ExtendedType = {
     allowEmptyValue?: boolean;
     required?: boolean;

package/commands/openAPI.command/utils.js

@@ -1,75 +1,35 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleDeprecationNotice = exports.handleParameters = exports.handleResponses = exports.handleForceOption = exports.handleRequestBody = exports.buildOptionFromType = exports.addOptionToCommand = exports.getSchema = exports.getDescriptionForCommand = exports.handleReadPathHandler = exports.getSegments = exports.writeParameter = exports.isPathParameter = exports.updatePath = void 0;
-const lodash_1 = __importStar(require("lodash"));
-const constants_1 = require("../../constants");
-const logger_1 = require("../../logger");
-const utils_1 = require("../../utils/utils");
-const config_1 = require("../../config");
-const handler_1 = require("../handler");
-const ResultHandlerFactory_1 = require("../../result/ResultHandlerFactory");
-const getLogger = () => (0, logger_1.get)("commands.openAPI.utils");
-const updatePath = (doc, path) => {
-    const version = (0, utils_1.parseVersion)(doc.info.version);
+import { kebabCase, get } from "lodash-es";
+import { CLI_NAME, OPTION_OUTPUT, OPTION_NO_PRETTY, X_CSRF_TOKEN, } from "../../constants.js";
+import { get as loggerGet } from "../../logger/index.js";
+import { parseVersion } from "../../utils/utils.js";
+import { get as getConfig } from "../../config/index.js";
+import { createForceHandler, createInputHandler } from "../handler/index.js";
+import { ResultHandlerFactory } from "../../result/ResultHandlerFactory.js";
+const getLogger = () => loggerGet("commands.openAPI.utils");
+export const updatePath = (doc, path) => {
+    const version = parseVersion(doc.info.version);
     if (version.major < 2023) {
         return `/dwaas-core${path}`;
     }
     return path;
 };
-exports.updatePath = updatePath;
-const isPathParameter = (segment) => /^{.*}$/.test(segment);
-exports.isPathParameter = isPathParameter;
+export const isPathParameter = (segment) => /^{.*}$/.test(segment);
 function getParameterName(parameter) {
-    return `--${(0, lodash_1.kebabCase)(parameter.slice(1, -1))}`;
+    return `--${kebabCase(parameter.slice(1, -1))}`;
 }
-const writeParameter = (parameter, value) => `${getParameterName(parameter)} ${value}`;
-exports.writeParameter = writeParameter;
-const getSegments = (value) => {
+export const writeParameter = (parameter, value) => `${getParameterName(parameter)} ${value}`;
+export const getSegments = (value) => {
     const segments = value.split("/");
     return segments.filter((segment) => {
         const s = segment.trim();
         return s !== "" && s !== "marketplace";
     });
 };
-exports.getSegments = getSegments;
 const handleParameter = (params, pathSegment, locationSegment) => {
-    if ((0, exports.isPathParameter)(pathSegment)) {
+    if (isPathParameter(pathSegment)) {
         return params
-            ? `${params} ${(0, exports.writeParameter)(pathSegment, locationSegment)}`
-            : (0, exports.writeParameter)(pathSegment, locationSegment);
+            ? `${params} ${writeParameter(pathSegment, locationSegment)}`
+            : writeParameter(pathSegment, locationSegment);
     }
     return params;
 };
@@ -81,14 +41,14 @@ const getPathItem = (doc, operation, path) => {
     throw new Error(`path ${operation["x-read-path"]} does not support GET operation`);
 };
 function handleOptions(options, option, value) {
-    if ((0, exports.isPathParameter)(option)) {
+    if (isPathParameter(option)) {
         return { ...options, [getParameterName(option)]: value };
     }
     return options;
 }
 const outputReadCommand = (doc, operation, response, path) => {
-    const locationSegments = (0, exports.getSegments)(response.headers.location);
-    const pathSegments = (0, exports.getSegments)(path);
+    const locationSegments = getSegments(response.headers.location);
+    const pathSegments = getSegments(path);
     let params = "";
     let options = {};
     for (let i = 0; i < pathSegments.length; i++) {
@@ -96,12 +56,12 @@ const outputReadCommand = (doc, operation, response, path) => {
         options = handleOptions(options, pathSegments[i], locationSegments[i]);
     }
     const pathItem = getPathItem(doc, operation, path);
-    ResultHandlerFactory_1.ResultHandlerFactory.get().setResult({
+    ResultHandlerFactory.get().setResult({
         command: pathItem.get.operationId,
         options,
     });
     const { output } = getLogger();
-    output(`Use ${(0, config_1.get)()[constants_1.CLI_NAME]} ${pathItem.get.operationId} ${params} to retrieve the entity you just created`);
+    output(`Use ${getConfig()[CLI_NAME]} ${pathItem.get.operationId} ${params} to retrieve the entity you just created`);
 };
 const readPathHandlerFunction = (doc, operation, path) => async (response) => {
     const { debug } = getLogger();
@@ -115,16 +75,14 @@ const readPathHandlerFunction = (doc, operation, path) => async (response) => {
 const dummyFunction = async () => {
     // This is intentional
 };
-const handleReadPathHandler = (doc, operation) => {
+export const handleReadPathHandler = (doc, operation) => {
     const path = operation["x-read-path"];
     if (path) {
         return readPathHandlerFunction(doc, operation, path);
     }
     return dummyFunction;
 };
-exports.handleReadPathHandler = handleReadPathHandler;
-const getDescriptionForCommand = (command, operation) => command.description || operation.description || operation.summary || "";
-exports.getDescriptionForCommand = getDescriptionForCommand;
+export const getDescriptionForCommand = (command, operation) => command.description || operation.description || operation.summary || "";
 const getReferenceFromDocument = (reference, document) => {
     const { trace } = getLogger();
     const segments = reference.$ref.split("/");
@@ -137,21 +95,20 @@ const getReferenceFromDocument = (reference, document) => {
         .slice(1)
         .reduce((prev, curr) => (prev !== "" ? `${prev}.${curr}` : curr), "");
     trace("reading reference %s, path %s", reference.$ref, path);
-    return lodash_1.default.get(document, path);
+    return get(document, path);
 };
-const getSchema = (obj, doc) => {
+export const getSchema = (obj, doc) => {
     if (obj.$ref) {
         return getReferenceFromDocument(obj, doc);
     }
     return obj;
 };
-exports.getSchema = getSchema;
 const getKeysFromSchema = (schema, doc, key = "", required = false) => {
     const { trace } = getLogger();
     trace(`retrieving keys for key ${key} from schema ${JSON.stringify(schema)}`);
     if (schema.$ref) {
         // eslint-disable-next-line no-param-reassign
-        schema = (0, exports.getSchema)(schema, doc);
+        schema = getSchema(schema, doc);
     }
     if (schema.type === "object" && schema.properties) {
         let keys = [];
@@ -171,7 +128,7 @@ const flattenType = (type, doc) => {
         return result;
     }
     if (type.$ref) {
-        const schema = (0, exports.getSchema)(type, doc);
+        const schema = getSchema(type, doc);
         return flattenType({
             ...schema,
             allowEmptyValue: type.allowEmptyValue,
@@ -183,12 +140,11 @@ const flattenType = (type, doc) => {
     }
     return [type];
 };
-const addOptionToCommand = (option, options) => {
+export const addOptionToCommand = (option, options) => {
     const { trace } = getLogger();
     options.push(option);
     trace("added option %s", JSON.stringify(option));
 };
-exports.addOptionToCommand = addOptionToCommand;
 const checkTypes = (types) => {
     for (const t of types) {
         if (types.length > 1 && t.enum?.length === 1) {
@@ -210,7 +166,7 @@ const initParams = (types) => {
     return params;
 };
 const handleOptionName = (name, params, description) => {
-    let optionName = lodash_1.default.kebabCase(name);
+    let optionName = kebabCase(name);
     let def;
     let newDescription = description;
     if (params.default !== undefined) {
@@ -259,10 +215,10 @@ const buildOption = (commandName, longName, types, params, description, def) =>
 const handleOption = (commandName, name, params, types, options, description) => {
     const { optionName, def, description: newDescription, } = handleOptionName(name, params, description);
     const option = buildOption(commandName, optionName, types, params, newDescription, def);
-    (0, exports.addOptionToCommand)(option, options);
+    addOptionToCommand(option, options);
 };
-const requiresUserInput = (name) => name !== constants_1.X_CSRF_TOKEN;
-const buildOptionFromType = (commandName, doc, parameterIn, name, type, parameterMappings, options, description) => {
+const requiresUserInput = (name) => name !== X_CSRF_TOKEN;
+export const buildOptionFromType = (commandName, doc, parameterIn, name, type, parameterMappings, options, description) => {
     try {
         const types = flattenType(type, doc);
         checkTypes(types);
@@ -283,7 +239,7 @@ const buildOptionFromType = (commandName, doc, parameterIn, name, type, paramete
                 name,
                 source: {
                     type: "option",
-                    name: (0, lodash_1.kebabCase)(name),
+                    name: kebabCase(name),
                     dataType: params.booleanAvailable ? "boolean" : "string", // we don't care whether it's a string or number, it simply must not be boolean in this case
                 },
             });
@@ -299,45 +255,41 @@ const buildOptionFromType = (commandName, doc, parameterIn, name, type, paramete
         }
     }
 };
-exports.buildOptionFromType = buildOptionFromType;
-const handleRequestBody = (operation, handler, doc, parameterMappings, command) => {
+export const handleRequestBody = (operation, handler, doc, parameterMappings, command) => {
     if (operation["x-requestbody-fileonly"]) {
-        handler.push((0, handler_1.createInputHandler)());
+        handler.push(createInputHandler());
     }
     else if (operation.requestBody) {
-        const schema = (0, exports.getSchema)(Object.values(operation.requestBody.content)[0].schema, doc);
+        const schema = getSchema(Object.values(operation.requestBody.content)[0].schema, doc);
         const keys = getKeysFromSchema(schema, doc);
         keys.forEach((key) => {
             if (key.schema.oneOf) {
                 throw new Error("invalid request body parameter resolution, oneOf not supported");
             }
-            (0, exports.buildOptionFromType)(command.command, doc, "body", key.key, {
+            buildOptionFromType(command.command, doc, "body", key.key, {
                 ...key.schema,
                 required: key.required,
             }, parameterMappings, command.options, key.schema.description);
         });
     }
 };
-exports.handleRequestBody = handleRequestBody;
-const handleForceOption = (operation, handler) => {
+export const handleForceOption = (operation, handler) => {
     if (operation["x-user-to-confirm"]) {
-        handler.push((0, handler_1.createForceHandler)(operation["x-user-to-confirm"]));
+        handler.push(createForceHandler(operation["x-user-to-confirm"]));
     }
 };
-exports.handleForceOption = handleForceOption;
-const handleResponses = (operation, command) => {
+export const handleResponses = (operation, command) => {
     if (operation.responses?.[200]) {
-        (0, exports.addOptionToCommand)(constants_1.OPTION_OUTPUT, command.options);
+        addOptionToCommand(OPTION_OUTPUT, command.options);
     }
-    (0, exports.addOptionToCommand)(constants_1.OPTION_NO_PRETTY, command.options);
+    addOptionToCommand(OPTION_NO_PRETTY, command.options);
 };
-exports.handleResponses = handleResponses;
-const handleParameters = (operation, doc, parameterMappings, command, topLevelParameters = []) => {
+export const handleParameters = (operation, doc, parameterMappings, command, topLevelParameters = []) => {
     const { error } = getLogger();
     (operation.parameters || []).concat(topLevelParameters).forEach((p) => {
         try {
-            const parameter = (0, exports.getSchema)(p, doc);
-            (0, exports.buildOptionFromType)(command.command, doc, parameter.in, parameter.name, {
+            const parameter = getSchema(p, doc);
+            buildOptionFromType(command.command, doc, parameter.in, parameter.name, {
                 ...parameter.schema,
                 allowEmptyValue: parameter.allowEmptyValue,
                 required: parameter.required,
@@ -348,8 +300,7 @@ const handleParameters = (operation, doc, parameterMappings, command, topLevelPa
         }
     });
 };
-exports.handleParameters = handleParameters;
-const handleDeprecationNotice = (operation, command) => {
+export const handleDeprecationNotice = (operation, command) => {
     if (operation.deprecated && command.type === "command") {
         // eslint-disable-next-line no-param-reassign
         command.deprecationInfo = {
@@ -361,4 +312,3 @@ const handleDeprecationNotice = (operation, command) => {
         };
     }
 };
-exports.handleDeprecationNotice = handleDeprecationNotice;

package/commands/utils.d.ts

@@ -1,3 +1,3 @@
-import { ChoicesFunction } from "../types";
+import { ChoicesFunction } from "../types.js";
 export declare const getChoices: ChoicesFunction;
 export declare const getBrowserChoices: ChoicesFunction;

package/commands/utils.js

@@ -1,14 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrowserChoices = exports.getChoices = void 0;
-const SecretsStorageSingleton_1 = require("../cache/secrets/SecretsStorageSingleton");
-const openUtils_1 = require("../utils/openUtils");
-const getChoices = async () => {
-    return SecretsStorageSingleton_1.SecretsStorageSingleton.SINGLETON.getAllSecrets().map((secret) => secret.id.toString(10));
+import { SecretsStorageSingleton } from "../cache/secrets/SecretsStorageSingleton.js";
+import { getSupportedBrowsers } from "../utils/openUtils.js";
+export const getChoices = async () => {
+    return SecretsStorageSingleton.SINGLETON.getAllSecrets().map((secret) => secret.id.toString(10));
 };
-exports.getChoices = getChoices;
-const getBrowserChoices = async () => {
-    const list = await (0, openUtils_1.getSupportedBrowsers)();
+export const getBrowserChoices = async () => {
+    const list = await getSupportedBrowsers();
     return list.map(({ name }) => name);
 };
-exports.getBrowserChoices = getBrowserChoices;

package/config/core.d.ts

@@ -1,4 +1,4 @@
-import { AuthenticationMethod } from "../constants";
+import { AuthenticationMethod } from "../constants.js";
 export declare const getName: () => string;
 export declare const getPackageName: () => string;
 export declare const getDescription: () => string;