aws-cdk/lib/cli/util/check-unknown-options.js

AWS CDK CLI, the command line tool for CDK apps

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.findUnknownOptions = findUnknownOptions;
// eslint-disable-next-line @typescript-eslint/no-require-imports
const config = require('../cli-type-registry.json');
/**
 * Build a set of all known option names for a given option definitions object.
 * Includes the kebab-case name, its camelCase equivalent, all aliases, and negativeAliases.
 *
 * @param optionDefs - Option definitions keyed by their kebab-case CLI names
 *   (as defined in cli-type-registry.json). Each key is converted to camelCase
 *   and both forms are included in the returned set.
 */
function collectKnownOptions(optionDefs) {
    const known = new Set();
    for (const [name, def] of Object.entries(optionDefs)) {
        known.add(name);
        known.add(kebabToCamel(name));
        if (def.alias) {
            const aliases = Array.isArray(def.alias) ? def.alias : [def.alias];
            for (const a of aliases) {
                known.add(a);
            }
        }
        if (def.negativeAlias) {
            known.add(def.negativeAlias);
        }
    }
    return known;
}
/** Pre-computed set of known global options (static, doesn't depend on argv) */
const globalKnownOptions = collectKnownOptions(config.globalOptions);
/** Reverse mapping from command alias to canonical command name */
const commandAliasMap = new Map();
for (const [name, def] of Object.entries(config.commands)) {
    if (def.aliases) {
        for (const alias of def.aliases) {
            commandAliasMap.set(alias, name);
        }
    }
}
/** yargs internal keys that are always present in argv */
const yargsInternals = new Set(['_', '$0', 'help', 'h', 'version']);
/**
 * Detect unrecognized CLI options.
 *
 * Yargs does not enable strict option checking by default, so unknown flags
 * are silently swallowed. This function compares the parsed argv keys against
 * the known global and command options from the CLI type registry and returns
 * any that don't match.
 */
function findUnknownOptions(argv) {
    const command = argv._[0];
    const canonicalCommand = commandAliasMap.get(command) ?? command;
    const commandDef = config.commands[canonicalCommand];
    const commandKnownOptions = commandDef?.options
        ? collectKnownOptions(commandDef.options)
        : new Set();
    const positionalArgRaw = commandDef?.arg?.name;
    const positionalArgs = positionalArgRaw
        ? new Set([positionalArgRaw, positionalArgRaw.toLowerCase()])
        : new Set();
    const unknown = [];
    for (const key of Object.keys(argv)) {
        if (argv[key] === undefined) {
            continue;
        }
        if (yargsInternals.has(key) || positionalArgs.has(key)) {
            continue;
        }
        if (globalKnownOptions.has(key) || commandKnownOptions.has(key)) {
            continue;
        }
        // yargs .env('CDK') injects CDK_* environment variables as camelCase argv
        // keys (e.g. CDK_INTEG_ATMOSPHERE_POOL -> integAtmospherePool). These are
        // intentional configuration from the environment, not user typos.
        if (isFromEnvPrefix(key, 'CDK')) {
            continue;
        }
        unknown.push(key);
    }
    return unknown;
}
function kebabToCamel(str) {
    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
}
/**
 * Checks whether a camelCase argv key was injected by yargs' .env(PREFIX)
 * feature. yargs converts PREFIX_FOO_BAR env vars into camelCase keys
 * (fooBar). We reverse the mapping and check if the env var exists.
 */
function isFromEnvPrefix(key, prefix) {
    const screamingSnake = key.replace(/[A-Z]/g, (m) => `_${m}`).toUpperCase();
    return process.env[`${prefix}_${screamingSnake}`] !== undefined;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-unknown-options.js","sourceRoot":"","sources":["check-unknown-options.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst config = require('../cli-type-registry.json');\n\n/**\n * Build a set of all known option names for a given option definitions object.\n * Includes the kebab-case name, its camelCase equivalent, all aliases, and negativeAliases.\n *\n * @param optionDefs - Option definitions keyed by their kebab-case CLI names\n *   (as defined in cli-type-registry.json). Each key is converted to camelCase\n *   and both forms are included in the returned set.\n */\nfunction collectKnownOptions(optionDefs: Record<string, any>): Set<string> {\n  const known = new Set<string>();\n  for (const [name, def] of Object.entries<any>(optionDefs)) {\n    known.add(name);\n    known.add(kebabToCamel(name));\n    if (def.alias) {\n      const aliases = Array.isArray(def.alias) ? def.alias : [def.alias];\n      for (const a of aliases) {\n        known.add(a);\n      }\n    }\n    if (def.negativeAlias) {\n      known.add(def.negativeAlias);\n    }\n  }\n  return known;\n}\n\n/** Pre-computed set of known global options (static, doesn't depend on argv) */\nconst globalKnownOptions = collectKnownOptions(config.globalOptions);\n\n/** Reverse mapping from command alias to canonical command name */\nconst commandAliasMap = new Map<string, string>();\nfor (const [name, def] of Object.entries<any>(config.commands)) {\n  if (def.aliases) {\n    for (const alias of def.aliases) {\n      commandAliasMap.set(alias, name);\n    }\n  }\n}\n\n/** yargs internal keys that are always present in argv */\nconst yargsInternals = new Set(['_', '$0', 'help', 'h', 'version']);\n\n/**\n * Detect unrecognized CLI options.\n *\n * Yargs does not enable strict option checking by default, so unknown flags\n * are silently swallowed. This function compares the parsed argv keys against\n * the known global and command options from the CLI type registry and returns\n * any that don't match.\n */\nexport function findUnknownOptions(argv: any): string[] {\n  const command = argv._[0];\n  const canonicalCommand = commandAliasMap.get(command) ?? command;\n\n  const commandDef = config.commands[canonicalCommand];\n  const commandKnownOptions = commandDef?.options\n    ? collectKnownOptions(commandDef.options)\n    : new Set<string>();\n\n  const positionalArgRaw = commandDef?.arg?.name;\n  const positionalArgs = positionalArgRaw\n    ? new Set([positionalArgRaw, positionalArgRaw.toLowerCase()])\n    : new Set<string>();\n\n  const unknown: string[] = [];\n  for (const key of Object.keys(argv)) {\n    if (argv[key] === undefined) {\n      continue;\n    }\n    if (yargsInternals.has(key) || positionalArgs.has(key)) {\n      continue;\n    }\n    if (globalKnownOptions.has(key) || commandKnownOptions.has(key)) {\n      continue;\n    }\n    // yargs .env('CDK') injects CDK_* environment variables as camelCase argv\n    // keys (e.g. CDK_INTEG_ATMOSPHERE_POOL -> integAtmospherePool). These are\n    // intentional configuration from the environment, not user typos.\n    if (isFromEnvPrefix(key, 'CDK')) {\n      continue;\n    }\n\n    unknown.push(key);\n  }\n\n  return unknown;\n}\n\nfunction kebabToCamel(str: string): string {\n  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());\n}\n\n/**\n * Checks whether a camelCase argv key was injected by yargs' .env(PREFIX)\n * feature. yargs converts PREFIX_FOO_BAR env vars into camelCase keys\n * (fooBar). We reverse the mapping and check if the env var exists.\n */\nfunction isFromEnvPrefix(key: string, prefix: string): boolean {\n  const screamingSnake = key.replace(/[A-Z]/g, (m) => `_${m}`).toUpperCase();\n  return process.env[`${prefix}_${screamingSnake}`] !== undefined;\n}\n"]}