@sap/cli-core 2023.12.0

package/commands/handler/succeed.js

@@ -0,0 +1,9 @@
+"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.succeed");
+    debug(`running succeed handler`);
+};
+exports.create = create;

package/commands/handler/utils.d.ts

@@ -0,0 +1,7 @@
+import { AuthenticationMethod } from "../../constants";
+export declare const getBooleanOption: (value: unknown) => boolean;
+export declare const parseOption: (value: string) => string;
+export declare const setAuthenticationMethod: (authenticationMethod: AuthenticationMethod) => void;
+export declare const getAuthenticationMethod: () => AuthenticationMethod;
+export declare const setTargetHost: (targetHost: string) => void;
+export declare const getTargetHost: () => string;

package/commands/handler/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTargetHost = exports.setTargetHost = exports.getAuthenticationMethod = exports.setAuthenticationMethod = exports.parseOption = exports.getBooleanOption = void 0;
+const logger_1 = require("../../logger");
+const config_1 = require("../../config");
+const constants_1 = require("../../constants");
+const getLogger = () => (0, logger_1.get)("commands.handler.utils");
+const getBooleanOption = (value) => !!value;
+exports.getBooleanOption = getBooleanOption;
+const decodeURIComponentInt = (value) => {
+    const { error } = getLogger();
+    try {
+        return decodeURIComponent(value);
+    }
+    catch (err) {
+        error(`Failed to decode URI for value '${value}'`, err);
+        throw err;
+    }
+};
+const replaceLeadingTrailingSingleQuotes = (value) => value.replace(/^'/, "").replace(/'$/, "");
+const parseOption = (value) => {
+    if (typeof value !== "string") {
+        return value;
+    }
+    let v = value.trim();
+    v = decodeURIComponentInt(v);
+    v = replaceLeadingTrailingSingleQuotes(v);
+    return v;
+};
+exports.parseOption = parseOption;
+const setAuthenticationMethod = (authenticationMethod) => {
+    (0, config_1.set)({ authenticationMethod });
+};
+exports.setAuthenticationMethod = setAuthenticationMethod;
+const getAuthenticationMethod = () => (0, config_1.get)().authenticationMethod;
+exports.getAuthenticationMethod = getAuthenticationMethod;
+const setTargetHost = (targetHost) => {
+    (0, config_1.set)({ targetHost });
+};
+exports.setTargetHost = setTargetHost;
+const getTargetHost = () => {
+    const config = (0, config_1.get)();
+    if (!config.targetHost) {
+        throw new Error("no target host set");
+    }
+    if (config.hostSetFromCustomConfig) {
+        const authenticationMethod = (0, exports.getAuthenticationMethod)();
+        if (authenticationMethod === constants_1.AuthenticationMethod.oauth) {
+            const { warn } = getLogger();
+            warn("Are you sure you want to use a custom configuration in combination with OAuth-based authentication?");
+        }
+        return config.host;
+    }
+    return config.targetHost;
+};
+exports.getTargetHost = getTargetHost;

package/commands/host.command.d.ts

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

package/commands/host.command.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommands = void 0;
+const config_1 = require("../config");
+const constants_1 = require("../constants");
+const logger_1 = require("../logger");
+const settings_1 = require("../settings");
+const commands_1 = require("../utils/commands");
+const utils_1 = require("../utils/utils");
+const handler_1 = require("./handler");
+const getLogger = () => (0, logger_1.get)("commands.host");
+const set = () => async () => {
+    const config = (0, config_1.get)();
+    try {
+        // throws if host is not valid
+        (0, utils_1.getInfoFromTenant)(config.arguments.host, config.verbose, false);
+        await (0, settings_1.set)(constants_1.OPTION_HOST.longName, config.arguments.host);
+    }
+    catch (err) {
+        const { debug, output } = getLogger();
+        debug("failed to set host", err);
+        output(`error: invalid value '${config.arguments.host}' for argument '<host>'`);
+        throw new Error("failed to set host");
+    }
+};
+const show = () => async () => {
+    const { output } = getLogger();
+    const settings = await (0, settings_1.get)();
+    if (settings[constants_1.OPTION_HOST.longName]) {
+        output(settings[constants_1.OPTION_HOST.longName]);
+    }
+    else {
+        output("no global host set. use dwc host set <host> to set a global host");
+        throw new Error("no global host set");
+    }
+};
+const clean = () => async () => {
+    await (0, settings_1.remove)(constants_1.OPTION_HOST.longName);
+};
+const addCommands = async (program) => {
+    (0, commands_1.buildCommand)(program, {
+        type: "topCommand",
+        command: "host",
+        description: "configure host properties",
+        subCommands: [
+            {
+                type: "command",
+                command: "set",
+                description: "set global host",
+                args: [{ argument: "host", description: "global host" }],
+                handler: (0, handler_1.createNextHandler)((0, handler_1.createParseArgumentsHandler)([{ argument: "host" }]), set),
+            },
+            {
+                type: "command",
+                command: "show",
+                description: "show global host",
+                handler: show,
+            },
+            {
+                type: "command",
+                command: "clean",
+                description: "clean global host",
+                handler: clean,
+            },
+        ],
+    });
+};
+exports.addCommands = addCommands;

package/commands/login.command.d.ts

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

package/commands/login.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const handler_1 = require("./handler");
+const constants_1 = require("../constants");
+const utils_1 = require("./handler/authentication/oauth/utils");
+const store = () => async () => {
+    await (0, utils_1.storeSecrets)();
+};
+const loginCommand = {
+    type: "command",
+    command: "login",
+    description: "log in to your account using interactive OAuth authentication",
+    options: [],
+    handler: (0, handler_1.createNextHandler)((0, handler_1.createParseArgumentsHandler)(), (0, handler_1.createOptionsHandler)([constants_1.OPTION_VERBOSE, constants_1.OPTION_OPTIONS_FILE]), (0, handler_1.createOauthHandler)(), store),
+};
+exports.default = loginCommand;

package/commands/logout.command.d.ts

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

package/commands/logout.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_1 = require("../cache");
+const constants_1 = require("../constants");
+const logger_1 = require("../logger");
+const handler = () => async () => {
+    try {
+        await (0, cache_1.deleteFile)(constants_1.CACHE_SECRETS_FILE);
+    }
+    catch (err) {
+        const { error } = (0, logger_1.get)("commands.logout");
+        error("failed to delete secrets file from cache", err);
+    }
+};
+const logoutCommand = {
+    type: "command",
+    command: "logout",
+    description: "log out from your account",
+    handler,
+};
+exports.default = logoutCommand;

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

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

package/commands/openAPI.command/index.js

@@ -0,0 +1,102 @@
+"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");
+const getCommandDescription = (document, segments, index) => {
+    const segment = segments
+        .slice(0, index + 1)
+        .reduce((prev, curr) => (prev !== "" ? `${prev} ${curr}` : curr), "");
+    return document.tags.find((t) => t.name === segment)?.description || "";
+};
+const addCommandToArray = (document, commands, segments, index) => {
+    const segment = segments[index];
+    let command = commands.find((c) => c.command === segment);
+    if (command?.type === "topCommand") {
+        return addCommandToArray(document, command.subCommands, segments, index + 1);
+    }
+    if (index + 1 < segments.length) {
+        command = {
+            type: "topCommand",
+            description: getCommandDescription(document, segments, index),
+            command: segment,
+            subCommands: [],
+            options: [constants_1.OPTION_HOST],
+        };
+        commands.push(command);
+        return addCommandToArray(document, command.subCommands, segments, index + 1);
+    }
+    // @ts-expect-error ts(2322) handler is missing - OK
+    command = {
+        type: "command",
+        description: getCommandDescription(document, segments, index),
+        command: segment,
+        options: [],
+    };
+    // @ts-expect-error ts(2345) handler is missing - OK
+    commands.push(command);
+    // @ts-expect-error ts(2345) handler is missing - OK
+    return { command, remove: () => commands.splice(commands.length - 1, 1) };
+};
+const setHandler = (command, method, path, parameterMappings, readPathResponseHandler, ...handler) => {
+    // eslint-disable-next-line
+    command.handler = (0, handler_1.createNextHandler)((0, handler_1.createParseArgumentsHandler)(), (0, handler_1.createMandatoryOptionsHandler)(), (0, handler_1.createAuthenticationHandler)(), ...handler, (0, handler_1.createFetchHandler)(method, path, parameterMappings, readPathResponseHandler));
+};
+const addCommands = async (program) => {
+    const { error, debug, trace } = getLogger();
+    try {
+        const doc = await (0, discovery_1.init)();
+        const commands = [];
+        for (const path of Object.keys(doc.paths)) {
+            const pathItem = doc.paths[path];
+            for (const method of Object.keys(pathItem).filter((i) => i !== "parameters")) {
+                const handler = [];
+                let remove;
+                try {
+                    const parameterMappings = [];
+                    // eslint-disable-next-line
+                    const operation = pathItem[method];
+                    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));
+                    const readPathResponseHandler = (0, utils_1.handleReadPathHandler)(doc, operation);
+                    setHandler(command, method, (0, utils_1.updatePath)(doc, path), parameterMappings, readPathResponseHandler, ...[
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        (0, handler_1.createOptionsHandler)(command.options),
+                        ...handler,
+                    ]);
+                    delete command.options;
+                }
+                catch (err) {
+                    error("cannot add command", err.stack);
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    remove();
+                }
+            }
+        }
+        for (const command of commands) {
+            trace("adding command %s", JSON.stringify(command));
+            try {
+                (0, commands_1.buildCommand)(program, command);
+            }
+            catch (err) {
+                error("error while adding command %s", JSON.stringify(command, null, 2), err.stack);
+            }
+        }
+    }
+    catch (err) {
+        debug("error while initializing discovery", err.stack);
+        throw err;
+    }
+};
+exports.addCommands = addCommands;

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

@@ -0,0 +1,19 @@
+import { Command, Discovery, Handler, In, JSONReference, JSONSchema, Operation, Option, ParameterMappings, Parameters, ResponsePostProcessor } from "../../types";
+type ExtendedType = {
+    allowEmptyValue?: boolean;
+    required?: boolean;
+};
+export declare const updatePath: (doc: Discovery, path: string) => string;
+export declare const isPathParameter: (segment: string) => boolean;
+export declare const writeParameter: (parameter: string, value: string) => string;
+export declare const getSegments: (value: string) => Array<string>;
+export declare const handleReadPathHandler: (doc: Discovery, operation: Operation) => ResponsePostProcessor;
+export declare const getDescriptionForCommand: (command: Command, operation: Operation) => string;
+export declare const getSchema: <T>(obj: JSONReference | T, doc: Discovery) => T;
+export declare const addOptionToCommand: (option: Option, options: Array<Option>) => void;
+export declare const buildOptionFromType: (doc: Discovery, parameterIn: In, name: string, type: JSONSchema & ExtendedType, parameterMappings: ParameterMappings, options: Array<Option>, description?: string) => void;
+export declare const handleRequestBody: (operation: Operation, handler: Array<Handler>, doc: Discovery, parameterMappings: ParameterMappings, command: Command) => void;
+export declare const handleForceOption: (operation: Operation, handler: Array<Handler>) => void;
+export declare const handleResponses: (operation: Operation, command: Command) => void;
+export declare const handleParameters: (operation: Operation, doc: Discovery, parameterMappings: ParameterMappings, command: Command, topLevelParameters?: Parameters) => void;
+export {};

package/commands/openAPI.command/utils.js

@@ -0,0 +1,334 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 getLogger = () => (0, logger_1.get)("commands.openAPI.utils");
+const updatePath = (doc, path) => {
+    const version = (0, utils_1.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;
+const writeParameter = (parameter, value) => `--${(0, lodash_1.kebabCase)(parameter.slice(1, -1))} ${value}`;
+exports.writeParameter = writeParameter;
+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)) {
+        return params
+            ? `${params} ${(0, exports.writeParameter)(pathSegment, locationSegment)}`
+            : (0, exports.writeParameter)(pathSegment, locationSegment);
+    }
+    return params;
+};
+const getPathItem = (doc, operation, path) => {
+    const pathItem = doc.paths[path];
+    if (pathItem.get) {
+        return pathItem;
+    }
+    throw new Error(`path ${operation["x-read-path"]} does not support GET operation`);
+};
+const outputReadCommand = (doc, operation, response, path) => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const locationSegments = (0, exports.getSegments)(response.headers.location);
+    const pathSegments = (0, exports.getSegments)(path);
+    let params = "";
+    for (let i = 0; i < pathSegments.length; i++) {
+        params = handleParameter(params, pathSegments[i], locationSegments[i]);
+    }
+    const pathItem = getPathItem(doc, operation, path);
+    const { output } = getLogger();
+    output(`Use ${(0, config_1.get)()[constants_1.CLI_NAME]} ${
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    pathItem.get.operationId} ${params} to retrieve the entity you just created`);
+};
+const readPathHandlerFunction = (doc, operation, path) => async (response) => {
+    const { debug } = getLogger();
+    if (!response.headers.location) {
+        debug("response contains no location header");
+    }
+    else {
+        outputReadCommand(doc, operation, response, path);
+    }
+};
+const dummyFunction = async () => {
+    // This is intentional
+};
+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;
+const getReferenceFromDocument = (reference, document) => {
+    const { trace } = getLogger();
+    const segments = reference.$ref.split("/");
+    if (segments.length < 4 || // #(1)/components(2)/(parameters|schemas|responses|...)(3)/<name>(4)
+        segments[0] !== "#" ||
+        segments[1] !== "components") {
+        throw new Error(`invalid reference ${reference.$ref}`);
+    }
+    const path = segments
+        .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);
+};
+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);
+    }
+    if (schema.type === "object" && schema.properties) {
+        let keys = [];
+        Object.keys(schema.properties).forEach((property) => {
+            keys = keys.concat(getKeysFromSchema(schema.properties[property], doc, key ? `${key}.${property}` : property, schema.required?.includes(property)));
+        });
+        return keys;
+    }
+    return [{ key, schema, required }];
+};
+const flattenType = (type, doc) => {
+    if (type.oneOf) {
+        let result = [];
+        type.oneOf.forEach((t) => {
+            result = result.concat(flattenType(t, doc));
+        });
+        return result;
+    }
+    if (type.$ref) {
+        const schema = (0, exports.getSchema)(type, doc);
+        return flattenType({
+            ...schema,
+            allowEmptyValue: type.allowEmptyValue,
+            required: type.required,
+        }, doc);
+    }
+    if (type.type === "object") {
+        throw new Error("type: Object not supported");
+    }
+    return [type];
+};
+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) {
+            throw new Error("constants not allowed for multiple types");
+        }
+    }
+};
+const initParams = (types) => {
+    const params = { booleanAvailable: false, choices: [] };
+    for (const t of types) {
+        if (t.type === "boolean") {
+            params.booleanAvailable = true;
+        }
+        else {
+            t.enum?.forEach((e) => params.choices.push(e.toString()));
+        }
+        params.default = t.default;
+    }
+    return params;
+};
+const handleOptionName = (name, params, description) => {
+    let optionName = lodash_1.default.kebabCase(name);
+    let def;
+    let newDescription = description;
+    if (params.default !== undefined) {
+        if (params.booleanAvailable && params.default === true) {
+            // see npmjs.com/package/commander#other-option-types-negatable-boolean-and-booleanvalue
+            optionName = `no-${optionName}`;
+            if (description) {
+                newDescription = `do not ${description}`;
+            }
+        }
+        else {
+            def = params.default.toString();
+        }
+    }
+    return {
+        optionName,
+        def,
+        description: newDescription,
+    };
+};
+const buildOption = (longName, types, params, description, def) => {
+    const option = {
+        longName,
+        required: !types[0].allowEmptyValue && types[0].required,
+        description: description || "",
+        default: def === "false" ? undefined : def,
+        args: params.booleanAvailable && types.length === 1
+            ? undefined
+            : [
+                {
+                    name: longName,
+                    optional: params.booleanAvailable && types.length > 1,
+                },
+            ],
+        choices: params.choices.length > 0 ? params.choices : undefined,
+    };
+    if (option.required) {
+        const desc = option.description ? ` (${option.description})` : "";
+        option.prompts = {
+            message: `Provide a value for option ${option.longName}${desc}:`,
+            type: params.choices.length > 0 ? "select" : "text",
+        };
+    }
+    return option;
+};
+const handleOption = (name, params, types, options, description) => {
+    const { optionName, def, description: newDescription, } = handleOptionName(name, params, description);
+    const option = buildOption(optionName, types, params, newDescription, def);
+    (0, exports.addOptionToCommand)(option, options);
+};
+const requiresUserInput = (name) => name !== constants_1.X_CSRF_TOKEN;
+const buildOptionFromType = (doc, parameterIn, name, type, parameterMappings, options, description) => {
+    try {
+        const types = flattenType(type, doc);
+        checkTypes(types);
+        if (types[0].enum?.length === 1) {
+            parameterMappings.push({
+                in: parameterIn,
+                name,
+                source: { type: "value", value: types[0].enum[0] },
+            });
+        }
+        else {
+            const params = initParams(types);
+            if (requiresUserInput(name)) {
+                handleOption(name, params, types, options, description);
+            }
+            parameterMappings.push({
+                in: parameterIn,
+                name,
+                source: {
+                    type: "option",
+                    name: (0, lodash_1.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
+                },
+            });
+        }
+    }
+    catch (err) {
+        if (!type.required) {
+            const { trace } = getLogger();
+            trace(`option ${name} silently ignored since not required`, err.stack);
+        }
+        else {
+            throw err;
+        }
+    }
+};
+exports.buildOptionFromType = buildOptionFromType;
+const handleRequestBody = (operation, handler, doc, parameterMappings, command) => {
+    if (operation["x-requestbody-fileonly"]) {
+        handler.push((0, handler_1.createInputHandler)());
+    }
+    else if (operation.requestBody) {
+        const schema = (0, exports.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)(doc, "body", key.key, {
+                ...key.schema,
+                required: key.required,
+            }, parameterMappings, 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            command.options, key.schema.description);
+        });
+    }
+};
+exports.handleRequestBody = handleRequestBody;
+const handleForceOption = (operation, handler) => {
+    if (operation["x-user-to-confirm"]) {
+        handler.push((0, handler_1.createForceHandler)(operation["x-user-to-confirm"]));
+    }
+};
+exports.handleForceOption = handleForceOption;
+const handleResponses = (operation, command) => {
+    if (operation.responses?.[200]) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        (0, exports.addOptionToCommand)(constants_1.OPTION_OUTPUT, command.options);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    (0, exports.addOptionToCommand)(constants_1.OPTION_PRETTY, command.options);
+};
+exports.handleResponses = handleResponses;
+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)(doc, parameter.in, parameter.name, {
+                ...parameter.schema,
+                allowEmptyValue: parameter.allowEmptyValue,
+                required: parameter.required,
+            }, parameterMappings, 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            command.options, parameter.description);
+        }
+        catch (err) {
+            error("cannot add option", err.stack);
+        }
+    });
+};
+exports.handleParameters = handleParameters;

package/commands/passcode.command.d.ts

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