@aws-cdk/toolkit-lib 1.29.1 → 1.31.0

package/lib/toolkit/private/validation-report.js

@@ -0,0 +1,152 @@
+"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.obtainUnifiedValidationReport = obtainUnifiedValidationReport;
+exports.combineConclusions = combineConclusions;
+exports.throwIfValidationFailures = throwIfValidationFailures;
+const path = __importStar(require("path"));
+const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
+const fs = __importStar(require("fs-extra"));
+const collect_annotation_report_1 = require("./collect-annotation-report");
+const validate_formatting_1 = require("../../api/validate/validate-formatting");
+const toolkit_error_1 = require("../toolkit-error");
+const VALIDATION_REPORT_FILE = 'validation-report.json';
+/**
+ * The name of the plugin that emits construct annotations into the validation report.
+ *
+ * @see https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/core/lib/private/annotation-plugin.ts
+ */
+const CONSTRUCT_ANNOTATIONS_PLUGINNAME = 'Construct Annotations';
+/**
+ * Return a validation report that contains the validation report that the CDK app has written, as well as any Construct Metadata annotations in the manifest.
+ *
+ * This function takes into account the CDK app can already have written the
+ * construct annotations into the validation report, or not, depending on the
+ * setting of a deprecated feature flag. If the annotations are already in the report,
+ * they are not copied.
+ *
+ * Afterwards, the list of violations is filtered to only include those that are relevant to the stacks selected for validation.
+ *
+ * Returns whether an explicit report file was found or not.
+ */
+async function obtainUnifiedValidationReport(assembly, stacks) {
+    const ret = [];
+    const reportPath = path.join(assembly.directory, VALIDATION_REPORT_FILE);
+    if (await fs.pathExists(reportPath)) {
+        const selectedStackIds = new Set(stacks.hierarchicalIds);
+        const report = cloud_assembly_schema_1.Manifest.loadValidationReport(reportPath);
+        // Filter the report to only include violations for the selected stacks
+        const filteredReports = filterReportsByStacks(report.pluginReports, selectedStackIds);
+        ret.push(...filteredReports);
+    }
+    const alreadyHasAnnotations = ret.some((r) => r.pluginName === CONSTRUCT_ANNOTATIONS_PLUGINNAME);
+    if (!alreadyHasAnnotations) {
+        const annotationReport = (0, collect_annotation_report_1.collectAnnotationReport)(stacks);
+        if (annotationReport.violations.length > 0 || annotationReport.conclusion === 'failure') {
+            ret.push(annotationReport);
+        }
+    }
+    // Remove all inconsequential reports
+    return ret;
+}
+/**
+ * Return a success/failure conclusion from the given report
+ */
+function combineConclusions(reports) {
+    const reportHasFailures = reports.some((r) => r.conclusion === 'failure');
+    return reportHasFailures ? 'failure' : 'success';
+}
+/**
+ * For operations that are NOT `cdk validate`, read the validation report and produce a failure if validation failed.
+ *
+ * Validation failed if there are any plugin reports with a failure conclusion, or if there are any warnings and the assembly is in strict mode.
+ */
+async function throwIfValidationFailures(assembly, stacks, failAt, ioHelper) {
+    const pluginReports = await obtainUnifiedValidationReport(assembly, stacks);
+    if (pluginReports.length === 0) {
+        return;
+    }
+    const conclusion = combineConclusions(pluginReports);
+    const result = { conclusion, pluginReports };
+    await ioHelper.notify((0, validate_formatting_1.hostMessageFromValidation)(process.cwd(), result));
+    switch (failAt) {
+        case 'error':
+            if (conclusion === 'failure') {
+                const error = toolkit_error_1.AssemblyError.withStacks('Synthesis finished with errors', stacks.stackArtifacts);
+                error.attachSynthesisErrorCode('AnnotationErrors');
+                throw error;
+            }
+            break;
+        case 'warn':
+            // if we're failing at 'warn', then both warnings and errors cause failure, so the initial conclusion is correct
+            if (conclusion === 'failure' || hasWarnings(pluginReports)) {
+                const error = toolkit_error_1.AssemblyError.withStacks('Synthesis finished with warnings (--strict mode)', stacks.stackArtifacts);
+                error.attachSynthesisErrorCode('StrictAnnotationWarnings');
+                throw error;
+            }
+            break;
+        case 'none':
+            // if we're not failing at all, then the conclusion is always success
+            break;
+    }
+}
+function hasWarnings(reports) {
+    return reports.some((r) => r.violations.some((v) => v.severity === 'warning'));
+}
+/**
+ * Remove violations that aren't in onde of the given stacks
+ */
+function filterReportsByStacks(reports, selectedStackIds) {
+    return reports.map((report) => {
+        const filteredViolations = report.violations.filter((violation) => {
+            if (violation.violatingConstructs.length === 0)
+                return true;
+            return violation.violatingConstructs.some((c) => selectedStackIds.has(c.constructPath?.split('/')[0] ?? ''));
+        }).map((violation) => {
+            if (violation.violatingConstructs.length === 0)
+                return violation;
+            return {
+                ...violation,
+                violatingConstructs: violation.violatingConstructs.filter((c) => selectedStackIds.has(c.constructPath?.split('/')[0] ?? '')),
+            };
+        });
+        return {
+            ...report,
+            violations: filteredViolations,
+            conclusion: filteredViolations.length > 0 ? report.conclusion : 'success',
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation-report.js","sourceRoot":"","sources":["validation-report.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { PluginReportJson, PolicyValidationReportConclusion } from '@aws-cdk/cloud-assembly-schema';\nimport { Manifest } from '@aws-cdk/cloud-assembly-schema';\nimport * as fs from 'fs-extra';\nimport { collectAnnotationReport } from './collect-annotation-report';\nimport type { ValidateResult } from '../../actions/validate';\nimport type { StackCollection } from '../../api/cloud-assembly/stack-collection';\nimport type { IoHelper } from '../../api/io/private/io-helper';\nimport { hostMessageFromValidation } from '../../api/validate/validate-formatting';\nimport { AssemblyError } from '../toolkit-error';\nimport type { MinimumSeverity } from '../types';\n\nconst VALIDATION_REPORT_FILE = 'validation-report.json';\n\n/**\n * The name of the plugin that emits construct annotations into the validation report.\n *\n * @see https://github.com/aws/aws-cdk/blob/main/packages/aws-cdk-lib/core/lib/private/annotation-plugin.ts\n */\nconst CONSTRUCT_ANNOTATIONS_PLUGINNAME = 'Construct Annotations';\n\ninterface AssemblyLike {\n  readonly directory: string;\n}\n\n/**\n * Return a validation report that contains the validation report that the CDK app has written, as well as any Construct Metadata annotations in the manifest.\n *\n * This function takes into account the CDK app can already have written the\n * construct annotations into the validation report, or not, depending on the\n * setting of a deprecated feature flag. If the annotations are already in the report,\n * they are not copied.\n *\n * Afterwards, the list of violations is filtered to only include those that are relevant to the stacks selected for validation.\n *\n * Returns whether an explicit report file was found or not.\n */\nexport async function obtainUnifiedValidationReport(assembly: AssemblyLike, stacks: StackCollection): Promise<PluginReportJson[]> {\n  const ret: PluginReportJson[] = [];\n\n  const reportPath = path.join(assembly.directory, VALIDATION_REPORT_FILE);\n  if (await fs.pathExists(reportPath)) {\n    const selectedStackIds = new Set(stacks.hierarchicalIds);\n    const report = Manifest.loadValidationReport(reportPath);\n\n    // Filter the report to only include violations for the selected stacks\n    const filteredReports = filterReportsByStacks(report.pluginReports, selectedStackIds);\n    ret.push(...filteredReports);\n  }\n\n  const alreadyHasAnnotations = ret.some((r) => r.pluginName === CONSTRUCT_ANNOTATIONS_PLUGINNAME);\n  if (!alreadyHasAnnotations) {\n    const annotationReport = collectAnnotationReport(stacks);\n    if (annotationReport.violations.length > 0 || annotationReport.conclusion === 'failure') {\n      ret.push(annotationReport);\n    }\n  }\n\n  // Remove all inconsequential reports\n  return ret;\n}\n\n/**\n * Return a success/failure conclusion from the given report\n */\nexport function combineConclusions(reports: PluginReportJson[]): PolicyValidationReportConclusion {\n  const reportHasFailures = reports.some((r) => r.conclusion === 'failure');\n  return reportHasFailures ? 'failure' : 'success';\n}\n\n/**\n * For operations that are NOT `cdk validate`, read the validation report and produce a failure if validation failed.\n *\n * Validation failed if there are any plugin reports with a failure conclusion, or if there are any warnings and the assembly is in strict mode.\n */\nexport async function throwIfValidationFailures(\n  assembly: AssemblyLike,\n  stacks: StackCollection,\n  failAt: MinimumSeverity,\n  ioHelper: IoHelper,\n): Promise<void> {\n  const pluginReports = await obtainUnifiedValidationReport(assembly, stacks);\n  if (pluginReports.length === 0) {\n    return;\n  }\n\n  const conclusion = combineConclusions(pluginReports);\n  const result: ValidateResult = { conclusion, pluginReports };\n  await ioHelper.notify(hostMessageFromValidation(process.cwd(), result));\n\n  switch (failAt) {\n    case 'error':\n      if (conclusion === 'failure') {\n        const error = AssemblyError.withStacks('Synthesis finished with errors', stacks.stackArtifacts);\n        error.attachSynthesisErrorCode('AnnotationErrors');\n        throw error;\n      }\n      break;\n    case 'warn':\n      // if we're failing at 'warn', then both warnings and errors cause failure, so the initial conclusion is correct\n      if (conclusion === 'failure' || hasWarnings(pluginReports)) {\n        const error = AssemblyError.withStacks('Synthesis finished with warnings (--strict mode)', stacks.stackArtifacts);\n        error.attachSynthesisErrorCode('StrictAnnotationWarnings');\n        throw error;\n      }\n\n      break;\n    case 'none':\n      // if we're not failing at all, then the conclusion is always success\n      break;\n  }\n}\n\nfunction hasWarnings(reports: PluginReportJson[]): boolean {\n  return reports.some((r) => r.violations.some((v) => v.severity === 'warning'));\n}\n\n/**\n * Remove violations that aren't in onde of the given stacks\n */\nfunction filterReportsByStacks(reports: PluginReportJson[], selectedStackIds: Set<string>): PluginReportJson[] {\n  return reports.map((report) => {\n    const filteredViolations = report.violations.filter((violation) => {\n      if (violation.violatingConstructs.length === 0) return true;\n      return violation.violatingConstructs.some((c) =>\n        selectedStackIds.has(c.constructPath?.split('/')[0] ?? ''),\n      );\n    }).map((violation) => {\n      if (violation.violatingConstructs.length === 0) return violation;\n      return {\n        ...violation,\n        violatingConstructs: violation.violatingConstructs.filter((c) =>\n          selectedStackIds.has(c.constructPath?.split('/')[0] ?? ''),\n        ),\n      };\n    });\n\n    return {\n      ...report,\n      violations: filteredViolations,\n      conclusion: filteredViolations.length > 0 ? report.conclusion : ('success' as const),\n    };\n  });\n}\n"]}

package/lib/toolkit/toolkit-error.d.ts

@@ -11,6 +11,10 @@ export declare class ToolkitError extends Error {
      * Determines if a given error is an instance of AuthenticationError.
      */
     static isAuthenticationError(x: any): x is AuthenticationError;
+    /**
+     * Determines if a given error is an instance of AbortError.
+     */
+    static isAbortError(x: any): x is AbortError;
     /**
      * Determines if a given error is an instance of DeploymentError.
      */
@@ -51,6 +55,22 @@ export declare class AuthenticationError extends ToolkitError {
     readonly source = "user";
     constructor(errorCode: string, message: string);
 }
+/**
+ * Represents an abort of an operation because the user declined a confirmation.
+ *
+ * This is not a failure of the toolkit: the user was asked a question and chose
+ * not to proceed. It carries a per-action error code (for example
+ * `DeployAborted`) so the reason stays specific, while `isAbortError` lets
+ * consumers detect a user-initiated abort without matching on messages. The
+ * default message, `Operation cancelled`, is a sensible generic for any action.
+ */
+export declare class AbortError extends ToolkitError {
+    /**
+     * Denotes the source of the error as user.
+     */
+    readonly source = "user";
+    constructor(errorCode: string, message?: string);
+}
 /**
  * Represents an error causes by cloud assembly synthesis
  *

package/lib/toolkit/toolkit-error.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeploymentErrorCodes = exports.NoResultsFoundError = exports.ContextProviderError = exports.DeploymentError = exports.AssemblyError = exports.AuthenticationError = exports.ToolkitError = void 0;
+exports.DeploymentErrorCodes = exports.NoResultsFoundError = exports.ContextProviderError = exports.DeploymentError = exports.AssemblyError = exports.AbortError = exports.AuthenticationError = exports.ToolkitError = void 0;
 const TOOLKIT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ToolkitError');
 const AUTHENTICATION_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AuthenticationError');
+const ABORT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AbortError');
 const DEPLOYMENT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.DeploymentError');
 const ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AssemblyError');
 const CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ContextProviderError');
@@ -23,6 +24,12 @@ class ToolkitError extends Error {
     static isAuthenticationError(x) {
         return ToolkitError.isToolkitError(x) && AUTHENTICATION_ERROR_SYMBOL in x;
     }
+    /**
+     * Determines if a given error is an instance of AbortError.
+     */
+    static isAbortError(x) {
+        return ToolkitError.isToolkitError(x) && ABORT_ERROR_SYMBOL in x;
+    }
     /**
      * Determines if a given error is an instance of DeploymentError.
      */
@@ -85,6 +92,27 @@ class AuthenticationError extends ToolkitError {
     }
 }
 exports.AuthenticationError = AuthenticationError;
+/**
+ * Represents an abort of an operation because the user declined a confirmation.
+ *
+ * This is not a failure of the toolkit: the user was asked a question and chose
+ * not to proceed. It carries a per-action error code (for example
+ * `DeployAborted`) so the reason stays specific, while `isAbortError` lets
+ * consumers detect a user-initiated abort without matching on messages. The
+ * default message, `Operation cancelled`, is a sensible generic for any action.
+ */
+class AbortError extends ToolkitError {
+    /**
+     * Denotes the source of the error as user.
+     */
+    source = 'user';
+    constructor(errorCode, message = 'Operation cancelled') {
+        super(errorCode, message, 'abort');
+        Object.setPrototypeOf(this, AbortError.prototype);
+        Object.defineProperty(this, ABORT_ERROR_SYMBOL, { value: true });
+    }
+}
+exports.AbortError = AbortError;
 /**
  * Represents an error causes by cloud assembly synthesis
  *
@@ -193,4 +221,4 @@ class DeploymentErrorCodes {
     static PRIVATE_RESOURCE_ERROR = 'PrivateResourceError';
 }
 exports.DeploymentErrorCodes = DeploymentErrorCodes;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-error.js","sourceRoot":"","sources":["toolkit-error.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cloud-assembly-api';\n\nconst TOOLKIT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ToolkitError');\nconst AUTHENTICATION_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AuthenticationError');\nconst DEPLOYMENT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.DeploymentError');\nconst ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AssemblyError');\nconst CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ContextProviderError');\nconst NO_RESULTS_FOUND_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.NoResultsFoundError');\n\n/**\n * Represents a general toolkit error in the AWS CDK Toolkit.\n */\nexport class ToolkitError extends Error {\n  /**\n   * Determines if a given error is an instance of ToolkitError.\n   */\n  public static isToolkitError(x: any): x is ToolkitError {\n    return x !== null && typeof(x) === 'object' && TOOLKIT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of AuthenticationError.\n   */\n  public static isAuthenticationError(x: any): x is AuthenticationError {\n    return ToolkitError.isToolkitError(x) && AUTHENTICATION_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of DeploymentError.\n   */\n  public static isDeploymentError(x: any): x is DeploymentError {\n    return ToolkitError.isToolkitError(x) && DEPLOYMENT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of AssemblyError.\n   */\n  public static isAssemblyError(x: any): x is AssemblyError {\n    return ToolkitError.isToolkitError(x) && ASSEMBLY_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of ContextProviderError.\n   */\n  public static isContextProviderError(x: any): x is ContextProviderError {\n    return ToolkitError.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * A ToolkitError with an original error as cause\n   */\n  public static withCause(errorCode: string, message: string, error: unknown): ToolkitError {\n    return new ToolkitError(errorCode, message, 'toolkit', error);\n  }\n\n  /**\n   * The type of the error, defaults to \"toolkit\".\n   */\n  public readonly type: string;\n\n  /**\n   * Denotes the source of the error as the toolkit.\n   */\n  public readonly source: 'toolkit' | 'user';\n\n  /**\n   * The specific original cause of the error, if available\n   */\n  public readonly cause?: unknown;\n\n  constructor(errorCode: string, message: string, type: string = 'toolkit', cause?: unknown) {\n    super(message);\n    this.name = errorCode;\n    Object.setPrototypeOf(this, ToolkitError.prototype);\n    Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });\n    this.type = type;\n    this.source = 'toolkit';\n    this.cause = cause;\n  }\n}\n\n/**\n * Represents an authentication-specific error in the AWS CDK Toolkit.\n */\nexport class AuthenticationError extends ToolkitError {\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  constructor(errorCode: string, message: string) {\n    super(errorCode, message, 'authentication');\n    Object.setPrototypeOf(this, AuthenticationError.prototype);\n    Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * Represents an error causes by cloud assembly synthesis\n *\n * This includes errors thrown during app execution, as well as failing annotations.\n */\nexport class AssemblyError extends ToolkitError {\n  /**\n   * An AssemblyError with an original error as cause\n   */\n  public static withCause(message: string, error: unknown): AssemblyError {\n    return new AssemblyError(message, undefined, error);\n  }\n\n  /**\n   * An AssemblyError with a list of stacks as cause\n   */\n  public static withStacks(message: string, stacks?: cxapi.CloudFormationStackArtifact[]): AssemblyError {\n    return new AssemblyError(message, stacks);\n  }\n\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  /**\n   * The stacks that caused the error, if available\n   *\n   * The `messages` property of each `cxapi.CloudFormationStackArtifact` will contain the respective errors.\n   * Absence indicates synthesis didn't fully complete.\n   */\n  public readonly stacks?: cxapi.CloudFormationStackArtifact[];\n\n  private _synthErrorCode: string | undefined;\n\n  private constructor(message: string, stacks?: cxapi.CloudFormationStackArtifact[], cause?: unknown) {\n    super('AssemblyError', message, 'assembly', cause);\n    Object.setPrototypeOf(this, AssemblyError.prototype);\n    Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });\n    this.stacks = stacks;\n  }\n\n  /**\n   * The synthesis error code\n   */\n  public get synthErrorCode(): string | undefined {\n    return this._synthErrorCode;\n  }\n\n  public attachSynthesisErrorCode(synthesisErrorCode: string) {\n    this._synthErrorCode = synthesisErrorCode;\n  }\n}\n\n/**\n * Represents a deployment-related error in the AWS CDK Toolkit.\n */\nexport class DeploymentError extends ToolkitError {\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  public readonly deploymentErrorCode: string;\n\n  constructor(message: string, deploymentErrorCode: string) {\n    super('DeploymentError', message, 'deployment');\n    Object.setPrototypeOf(this, DeploymentError.prototype);\n    Object.defineProperty(this, DEPLOYMENT_ERROR_SYMBOL, { value: true });\n    this.deploymentErrorCode = deploymentErrorCode;\n  }\n}\n\n/**\n * Represents an error originating from a Context Provider\n */\nexport class ContextProviderError extends ToolkitError {\n  /**\n   * Determines if a given error is an instance of NoResultsFoundError.\n   */\n  public static isNoResultsFoundError(x: any): x is NoResultsFoundError {\n    return ToolkitError.isContextProviderError(x) && NO_RESULTS_FOUND_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * A ContextProviderError with an original error as cause\n   */\n  public static withCause(errorCode: string, message: string, error: unknown): ContextProviderError {\n    return new ContextProviderError(errorCode, message, error);\n  }\n\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  constructor(errorCode: string, message: string, cause?: unknown) {\n    super(errorCode, message, 'context-provider', cause);\n    Object.setPrototypeOf(this, ContextProviderError.prototype);\n    Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * A specific context provider lookup failure indicating no results where found for a context query\n */\nexport class NoResultsFoundError extends ContextProviderError {\n  constructor(message: string) {\n    super('NoResultsFound', message);\n    Object.setPrototypeOf(this, NoResultsFoundError.prototype);\n    Object.defineProperty(this, NO_RESULTS_FOUND_ERROR_SYMBOL, { value: true });\n  }\n}\n\nexport abstract class DeploymentErrorCodes {\n  public static readonly STACK_DISAPPEARED_ERROR_CODE = 'StackDisappeared';\n  public static readonly UNKNOWN_ERROR = 'UnknownError';\n  public static readonly PRIVATE_RESOURCE_ERROR = 'PrivateResourceError';\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toolkit-error.js","sourceRoot":"","sources":["toolkit-error.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as cxapi from '@aws-cdk/cloud-assembly-api';\n\nconst TOOLKIT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ToolkitError');\nconst AUTHENTICATION_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AuthenticationError');\nconst ABORT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AbortError');\nconst DEPLOYMENT_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.DeploymentError');\nconst ASSEMBLY_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.AssemblyError');\nconst CONTEXT_PROVIDER_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.ContextProviderError');\nconst NO_RESULTS_FOUND_ERROR_SYMBOL = Symbol.for('@aws-cdk/toolkit-lib.NoResultsFoundError');\n\n/**\n * Represents a general toolkit error in the AWS CDK Toolkit.\n */\nexport class ToolkitError extends Error {\n  /**\n   * Determines if a given error is an instance of ToolkitError.\n   */\n  public static isToolkitError(x: any): x is ToolkitError {\n    return x !== null && typeof(x) === 'object' && TOOLKIT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of AuthenticationError.\n   */\n  public static isAuthenticationError(x: any): x is AuthenticationError {\n    return ToolkitError.isToolkitError(x) && AUTHENTICATION_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of AbortError.\n   */\n  public static isAbortError(x: any): x is AbortError {\n    return ToolkitError.isToolkitError(x) && ABORT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of DeploymentError.\n   */\n  public static isDeploymentError(x: any): x is DeploymentError {\n    return ToolkitError.isToolkitError(x) && DEPLOYMENT_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of AssemblyError.\n   */\n  public static isAssemblyError(x: any): x is AssemblyError {\n    return ToolkitError.isToolkitError(x) && ASSEMBLY_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * Determines if a given error is an instance of ContextProviderError.\n   */\n  public static isContextProviderError(x: any): x is ContextProviderError {\n    return ToolkitError.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * A ToolkitError with an original error as cause\n   */\n  public static withCause(errorCode: string, message: string, error: unknown): ToolkitError {\n    return new ToolkitError(errorCode, message, 'toolkit', error);\n  }\n\n  /**\n   * The type of the error, defaults to \"toolkit\".\n   */\n  public readonly type: string;\n\n  /**\n   * Denotes the source of the error as the toolkit.\n   */\n  public readonly source: 'toolkit' | 'user';\n\n  /**\n   * The specific original cause of the error, if available\n   */\n  public readonly cause?: unknown;\n\n  constructor(errorCode: string, message: string, type: string = 'toolkit', cause?: unknown) {\n    super(message);\n    this.name = errorCode;\n    Object.setPrototypeOf(this, ToolkitError.prototype);\n    Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });\n    this.type = type;\n    this.source = 'toolkit';\n    this.cause = cause;\n  }\n}\n\n/**\n * Represents an authentication-specific error in the AWS CDK Toolkit.\n */\nexport class AuthenticationError extends ToolkitError {\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  constructor(errorCode: string, message: string) {\n    super(errorCode, message, 'authentication');\n    Object.setPrototypeOf(this, AuthenticationError.prototype);\n    Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * Represents an abort of an operation because the user declined a confirmation.\n *\n * This is not a failure of the toolkit: the user was asked a question and chose\n * not to proceed. It carries a per-action error code (for example\n * `DeployAborted`) so the reason stays specific, while `isAbortError` lets\n * consumers detect a user-initiated abort without matching on messages. The\n * default message, `Operation cancelled`, is a sensible generic for any action.\n */\nexport class AbortError extends ToolkitError {\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  constructor(errorCode: string, message: string = 'Operation cancelled') {\n    super(errorCode, message, 'abort');\n    Object.setPrototypeOf(this, AbortError.prototype);\n    Object.defineProperty(this, ABORT_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * Represents an error causes by cloud assembly synthesis\n *\n * This includes errors thrown during app execution, as well as failing annotations.\n */\nexport class AssemblyError extends ToolkitError {\n  /**\n   * An AssemblyError with an original error as cause\n   */\n  public static withCause(message: string, error: unknown): AssemblyError {\n    return new AssemblyError(message, undefined, error);\n  }\n\n  /**\n   * An AssemblyError with a list of stacks as cause\n   */\n  public static withStacks(message: string, stacks?: cxapi.CloudFormationStackArtifact[]): AssemblyError {\n    return new AssemblyError(message, stacks);\n  }\n\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  /**\n   * The stacks that caused the error, if available\n   *\n   * The `messages` property of each `cxapi.CloudFormationStackArtifact` will contain the respective errors.\n   * Absence indicates synthesis didn't fully complete.\n   */\n  public readonly stacks?: cxapi.CloudFormationStackArtifact[];\n\n  private _synthErrorCode: string | undefined;\n\n  private constructor(message: string, stacks?: cxapi.CloudFormationStackArtifact[], cause?: unknown) {\n    super('AssemblyError', message, 'assembly', cause);\n    Object.setPrototypeOf(this, AssemblyError.prototype);\n    Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });\n    this.stacks = stacks;\n  }\n\n  /**\n   * The synthesis error code\n   */\n  public get synthErrorCode(): string | undefined {\n    return this._synthErrorCode;\n  }\n\n  public attachSynthesisErrorCode(synthesisErrorCode: string) {\n    this._synthErrorCode = synthesisErrorCode;\n  }\n}\n\n/**\n * Represents a deployment-related error in the AWS CDK Toolkit.\n */\nexport class DeploymentError extends ToolkitError {\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  public readonly deploymentErrorCode: string;\n\n  constructor(message: string, deploymentErrorCode: string) {\n    super('DeploymentError', message, 'deployment');\n    Object.setPrototypeOf(this, DeploymentError.prototype);\n    Object.defineProperty(this, DEPLOYMENT_ERROR_SYMBOL, { value: true });\n    this.deploymentErrorCode = deploymentErrorCode;\n  }\n}\n\n/**\n * Represents an error originating from a Context Provider\n */\nexport class ContextProviderError extends ToolkitError {\n  /**\n   * Determines if a given error is an instance of NoResultsFoundError.\n   */\n  public static isNoResultsFoundError(x: any): x is NoResultsFoundError {\n    return ToolkitError.isContextProviderError(x) && NO_RESULTS_FOUND_ERROR_SYMBOL in x;\n  }\n\n  /**\n   * A ContextProviderError with an original error as cause\n   */\n  public static withCause(errorCode: string, message: string, error: unknown): ContextProviderError {\n    return new ContextProviderError(errorCode, message, error);\n  }\n\n  /**\n   * Denotes the source of the error as user.\n   */\n  public readonly source = 'user';\n\n  constructor(errorCode: string, message: string, cause?: unknown) {\n    super(errorCode, message, 'context-provider', cause);\n    Object.setPrototypeOf(this, ContextProviderError.prototype);\n    Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });\n  }\n}\n\n/**\n * A specific context provider lookup failure indicating no results where found for a context query\n */\nexport class NoResultsFoundError extends ContextProviderError {\n  constructor(message: string) {\n    super('NoResultsFound', message);\n    Object.setPrototypeOf(this, NoResultsFoundError.prototype);\n    Object.defineProperty(this, NO_RESULTS_FOUND_ERROR_SYMBOL, { value: true });\n  }\n}\n\nexport abstract class DeploymentErrorCodes {\n  public static readonly STACK_DISAPPEARED_ERROR_CODE = 'StackDisappeared';\n  public static readonly UNKNOWN_ERROR = 'UnknownError';\n  public static readonly PRIVATE_RESOURCE_ERROR = 'PrivateResourceError';\n}\n\n"]}

package/lib/toolkit/toolkit.d.ts

@@ -1,6 +1,6 @@
 import '../private/dispose-polyfill';
 import type { TemplateDiff } from '@aws-cdk/cloudformation-diff';
-import type { DeployResult, DestroyResult, FeatureFlag, RollbackResult } from './types';
+import type { DeployResult, DestroyResult, FeatureFlag, MinimumSeverity, RollbackResult } from './types';
 import type { BootstrapEnvironments, BootstrapOptions, BootstrapResult } from '../actions/bootstrap';
 import { type DeployOptions } from '../actions/deploy';
 import { type DestroyOptions } from '../actions/destroy';
@@ -53,11 +53,11 @@ export interface ToolkitOptions {
      */
     readonly toolkitStackName?: string;
     /**
-     * Fail Cloud Assemblies
+     * Fail Cloud Assembly operations with an error if there are validation errors in the assembly with at least the indicated severity.
      *
      * @default "error"
      */
-    readonly assemblyFailureAt?: 'error' | 'warn' | 'none';
+    readonly assemblyFailureAt?: MinimumSeverity;
     /**
      * The plugin host to use for loading and querying plugins
      *
@@ -103,6 +103,7 @@ export declare class Toolkit extends CloudAssemblySourceBuilder {
     private sdkProviderCache?;
     private baseCredentials;
     private readonly unstableFeatures;
+    private readonly assemblyFailureAt;
     constructor(props?: ToolkitOptions);
     /**
      * Bootstrap Action
@@ -202,13 +203,17 @@ export declare class Toolkit extends CloudAssemblySourceBuilder {
      */
     destroy(cx: ICloudAssemblySource, options?: DestroyOptions): Promise<DestroyResult>;
     /**
-     * Helper to allow destroy being called as part of the deploy action.
+     * Synthesize and destroy, labelling the work with an explicit action.
+     *
+     * Kept private: the CLI reaches it (via a `// @ts-ignore`) to keep the
+     * "deployed" wording when a destroy runs as part of a deploy (rollback
+     * cleanup). Not part of the public API.
      */
-    private _destroy;
+    private _destroyWithAction;
     /**
-     * Validate the stacks for errors and warnings according to the CLI's current settings
+     * Helper to allow destroy being called as part of the deploy action.
      */
-    private validateStacksMetadata;
+    private _destroy;
     /**
      * Create a deployments class
      */