aws-cdk 2.1029.4 → 2.1031.0

package/lib/commands/flags/validator.d.ts

@@ -0,0 +1,22 @@
+import type { FlagOperationsParams } from './types';
+import type { IoHelper } from '../../api-private';
+export declare class FlagValidator {
+    private readonly ioHelper;
+    constructor(ioHelper: IoHelper);
+    /** Shows error message when CDK version is incompatible with flags command */
+    showIncompatibleVersionError(): Promise<void>;
+    /** Validates all parameters and returns true if valid, false if any validation fails */
+    validateParams(params: FlagOperationsParams): Promise<boolean>;
+    /** Validates that --all and specific flag names are not used together */
+    private validateFlagNameAndAll;
+    /** Validates that modification options require --set flag */
+    private validateSetRequirement;
+    /** Validates that --value requires a specific flag name */
+    private validateValueRequirement;
+    /** Validates that mutually exclusive options are not used together */
+    private validateMutuallyExclusive;
+    /** Validates that --unconfigured is not used with specific flag names */
+    private validateUnconfiguredUsage;
+    /** Validates that --set operations have required accompanying options */
+    private validateSetWithFlags;
+}

package/lib/commands/flags/validator.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlagValidator = void 0;
+class FlagValidator {
+    constructor(ioHelper) {
+        this.ioHelper = ioHelper;
+    }
+    /** Shows error message when CDK version is incompatible with flags command */
+    async showIncompatibleVersionError() {
+        await this.ioHelper.defaults.error('The \'cdk flags\' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');
+    }
+    /** Validates all parameters and returns true if valid, false if any validation fails */
+    async validateParams(params) {
+        const validations = [
+            () => this.validateFlagNameAndAll(params),
+            () => this.validateSetRequirement(params),
+            () => this.validateValueRequirement(params),
+            () => this.validateMutuallyExclusive(params),
+            () => this.validateUnconfiguredUsage(params),
+            () => this.validateSetWithFlags(params),
+        ];
+        for (const validation of validations) {
+            const isValid = await validation();
+            if (!isValid)
+                return false;
+        }
+        return true;
+    }
+    /** Validates that --all and specific flag names are not used together */
+    async validateFlagNameAndAll(params) {
+        if (params.FLAGNAME && params.all) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that modification options require --set flag */
+    async validateSetRequirement(params) {
+        if ((params.value || params.recommended || params.default || params.unconfigured) && !params.set) {
+            await this.ioHelper.defaults.error('Error: This option can only be used with --set.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --value requires a specific flag name */
+    async validateValueRequirement(params) {
+        if (params.value && !params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: --value requires a specific flag name. Please specify a flag name when providing a value.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that mutually exclusive options are not used together */
+    async validateMutuallyExclusive(params) {
+        if (params.recommended && params.default) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --recommended and --default. Please choose one option.');
+            return false;
+        }
+        if (params.unconfigured && params.all) {
+            await this.ioHelper.defaults.error('Error: Cannot use both --unconfigured and --all. Please choose one option.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --unconfigured is not used with specific flag names */
+    async validateUnconfiguredUsage(params) {
+        if (params.unconfigured && params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.');
+            return false;
+        }
+        return true;
+    }
+    /** Validates that --set operations have required accompanying options */
+    async validateSetWithFlags(params) {
+        if (params.set && params.FLAGNAME && !params.value) {
+            await this.ioHelper.defaults.error('Error: When setting a specific flag, you must provide a --value.');
+            return false;
+        }
+        if (params.set && params.all && !params.recommended && !params.default) {
+            await this.ioHelper.defaults.error('Error: When using --set with --all, you must specify either --recommended or --default.');
+            return false;
+        }
+        if (params.set && params.unconfigured && !params.recommended && !params.default) {
+            await this.ioHelper.defaults.error('Error: When using --set with --unconfigured, you must specify either --recommended or --default.');
+            return false;
+        }
+        if (params.set && !params.all && !params.unconfigured && !params.FLAGNAME) {
+            await this.ioHelper.defaults.error('Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.');
+            return false;
+        }
+        return true;
+    }
+}
+exports.FlagValidator = FlagValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validator.js","sourceRoot":"","sources":["validator.ts"],"names":[],"mappings":";;;AAGA,MAAa,aAAa;IACxB,YAA6B,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;IAC/C,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,4BAA4B;QAChC,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,oIAAoI,CAAC,CAAC;IAC3K,CAAC;IAED,wFAAwF;IACxF,KAAK,CAAC,cAAc,CAAC,MAA4B;QAC/C,MAAM,WAAW,GAAG;YAClB,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC;YACzC,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC;YACzC,GAAG,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,MAAM,CAAC;YAC3C,GAAG,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC;YAC5C,GAAG,EAAE,CAAC,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC;YAC5C,GAAG,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC;SACxC,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,MAAM,UAAU,EAAE,CAAC;YACnC,IAAI,CAAC,OAAO;gBAAE,OAAO,KAAK,CAAC;QAC7B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yEAAyE;IACjE,KAAK,CAAC,sBAAsB,CAAC,MAA4B;QAC/D,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;YAClC,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,iIAAiI,CAAC,CAAC;YACtK,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,6DAA6D;IACrD,KAAK,CAAC,sBAAsB,CAAC,MAA4B;QAC/D,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,OAAO,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC;YACjG,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;YACtF,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,2DAA2D;IACnD,KAAK,CAAC,wBAAwB,CAAC,MAA4B;QACjE,IAAI,MAAM,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,kGAAkG,CAAC,CAAC;YACvI,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sEAAsE;IAC9D,KAAK,CAAC,yBAAyB,CAAC,MAA4B;QAClE,IAAI,MAAM,CAAC,WAAW,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACzC,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,+EAA+E,CAAC,CAAC;YACpH,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;YACtC,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,4EAA4E,CAAC,CAAC;YACjH,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yEAAyE;IACjE,KAAK,CAAC,yBAAyB,CAAC,MAA4B;QAClE,IAAI,MAAM,CAAC,YAAY,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC3C,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,uGAAuG,CAAC,CAAC;YAC5I,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,yEAAyE;IACjE,KAAK,CAAC,oBAAoB,CAAC,MAA4B;QAC7D,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YACnD,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,kEAAkE,CAAC,CAAC;YACvG,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACvE,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,yFAAyF,CAAC,CAAC;YAC9H,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,YAAY,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAChF,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,kGAAkG,CAAC,CAAC;YACvI,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC1E,MAAM,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,0GAA0G,CAAC,CAAC;YAC/I,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAhGD,sCAgGC","sourcesContent":["import type { FlagOperationsParams } from './types';\nimport type { IoHelper } from '../../api-private';\n\nexport class FlagValidator {\n  constructor(private readonly ioHelper: IoHelper) {\n  }\n\n  /** Shows error message when CDK version is incompatible with flags command */\n  async showIncompatibleVersionError(): Promise<void> {\n    await this.ioHelper.defaults.error('The \\'cdk flags\\' command is not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');\n  }\n\n  /** Validates all parameters and returns true if valid, false if any validation fails */\n  async validateParams(params: FlagOperationsParams): Promise<boolean> {\n    const validations = [\n      () => this.validateFlagNameAndAll(params),\n      () => this.validateSetRequirement(params),\n      () => this.validateValueRequirement(params),\n      () => this.validateMutuallyExclusive(params),\n      () => this.validateUnconfiguredUsage(params),\n      () => this.validateSetWithFlags(params),\n    ];\n\n    for (const validation of validations) {\n      const isValid = await validation();\n      if (!isValid) return false;\n    }\n    return true;\n  }\n\n  /** Validates that --all and specific flag names are not used together */\n  private async validateFlagNameAndAll(params: FlagOperationsParams): Promise<boolean> {\n    if (params.FLAGNAME && params.all) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --all and a specific flag name. Please use either --all to show all flags or specify a single flag name.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that modification options require --set flag */\n  private async validateSetRequirement(params: FlagOperationsParams): Promise<boolean> {\n    if ((params.value || params.recommended || params.default || params.unconfigured) && !params.set) {\n      await this.ioHelper.defaults.error('Error: This option can only be used with --set.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --value requires a specific flag name */\n  private async validateValueRequirement(params: FlagOperationsParams): Promise<boolean> {\n    if (params.value && !params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: --value requires a specific flag name. Please specify a flag name when providing a value.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that mutually exclusive options are not used together */\n  private async validateMutuallyExclusive(params: FlagOperationsParams): Promise<boolean> {\n    if (params.recommended && params.default) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --recommended and --default. Please choose one option.');\n      return false;\n    }\n    if (params.unconfigured && params.all) {\n      await this.ioHelper.defaults.error('Error: Cannot use both --unconfigured and --all. Please choose one option.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --unconfigured is not used with specific flag names */\n  private async validateUnconfiguredUsage(params: FlagOperationsParams): Promise<boolean> {\n    if (params.unconfigured && params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: Cannot use --unconfigured with a specific flag name. --unconfigured works with multiple flags.');\n      return false;\n    }\n    return true;\n  }\n\n  /** Validates that --set operations have required accompanying options */\n  private async validateSetWithFlags(params: FlagOperationsParams): Promise<boolean> {\n    if (params.set && params.FLAGNAME && !params.value) {\n      await this.ioHelper.defaults.error('Error: When setting a specific flag, you must provide a --value.');\n      return false;\n    }\n    if (params.set && params.all && !params.recommended && !params.default) {\n      await this.ioHelper.defaults.error('Error: When using --set with --all, you must specify either --recommended or --default.');\n      return false;\n    }\n    if (params.set && params.unconfigured && !params.recommended && !params.default) {\n      await this.ioHelper.defaults.error('Error: When using --set with --unconfigured, you must specify either --recommended or --default.');\n      return false;\n    }\n    if (params.set && !params.all && !params.unconfigured && !params.FLAGNAME) {\n      await this.ioHelper.defaults.error('Error: When using --set, you must specify either --all, --unconfigured, or provide a specific flag name.');\n      return false;\n    }\n    return true;\n  }\n}\n"]}