feat(cli): warn of non-existent stacks in cdk destroy

packages/@aws-cdk-testing/cli-integ/tests/cli-integ-tests/cli.integtest.ts

@@ -2634,6 +2634,20 @@ integTest('hotswap ECS deployment respects properties override', withDefaultFixt
   expect(describeServicesResponse.services?.[0].deploymentConfiguration?.maximumPercent).toEqual(ecsMaximumHealthyPercent);
 }));
 
+integTest('cdk destroy does not fail even if the stacks do not exist', withDefaultFixture(async (fixture) => {
+  const nonExistingStackName1 = 'non-existing-stack-1';
+  const nonExistingStackName2 = 'non-existing-stack-2';
+
+  await expect(fixture.cdkDestroy([nonExistingStackName1, nonExistingStackName2])).resolves.not.toThrow();
+}));
+
+integTest('cdk destroy with no force option exits without prompt if the stacks do not exist', withDefaultFixture(async (fixture) => {
+  const nonExistingStackName1 = 'non-existing-stack-1';
+  const nonExistingStackName2 = 'non-existing-stack-2';
+
+  await expect(fixture.cdk(['destroy', ...fixture.fullStackName([nonExistingStackName1, nonExistingStackName2])])).resolves.not.toThrow();
+}));
+
 async function listChildren(parent: string, pred: (x: string) => Promise<boolean>) {
   const ret = new Array<string>();
   for (const child of await fs.readdir(parent, { encoding: 'utf-8' })) {

packages/aws-cdk/lib/cdk-toolkit.ts

@@ -4,6 +4,7 @@ import * as cxapi from '@aws-cdk/cx-api';
 import * as chalk from 'chalk';
 import * as chokidar from 'chokidar';
 import * as fs from 'fs-extra';
+import { minimatch } from 'minimatch';
 import * as promptly from 'promptly';
 import * as uuid from 'uuid';
 import { DeploymentMethod, SuccessfulDeployStackResult } from './api';
@@ -799,6 +800,16 @@ export class CdkToolkit {
   public async destroy(options: DestroyOptions) {
     let stacks = await this.selectStacksForDestroy(options.selector, options.exclusively);
 
+    await this.suggestStacks({
+      selector: options.selector,
+      stacks,
+      exclusively: options.exclusively,
+    });
+    if (stacks.stackArtifacts.length === 0) {
+      warning(`No stacks match the name(s): ${chalk.red(options.selector.patterns.join(', '))}`);
+      return;
+    }
+
     // The stacks will have been ordered for deployment, so reverse them for deletion.
     stacks = stacks.reversed();
 
@@ -1162,6 +1173,49 @@ export class CdkToolkit {
     return stacks;
   }
 
+  private async suggestStacks(props: {
+    selector: StackSelector;
+    stacks: StackCollection;
+    exclusively?: boolean;
+  }) {
+    const assembly = await this.assembly();
+    const selectorWithoutPatterns: StackSelector = {
+      ...props.selector,
+      allTopLevel: true,
+      patterns: [],
+    };
+    const stacksWithoutPatterns = await assembly.selectStacks(selectorWithoutPatterns, {
+      extend: props.exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Downstream,
+      defaultBehavior: DefaultSelection.OnlySingle,
+    });
+
+    const patterns = props.selector.patterns.map(pattern => {
+      const notExist = !props.stacks.stackArtifacts.find(stack =>
+        minimatch(stack.hierarchicalId, pattern),
+      );
+
+      const closelyMatched = notExist ? stacksWithoutPatterns.stackArtifacts.map(stack => {
+        if (minimatch(stack.hierarchicalId.toLowerCase(), pattern.toLowerCase())) {
+          return stack.hierarchicalId;
+        }
+        return;
+      }).filter((stack): stack is string => stack !== undefined) : [];
+
+      return {
+        pattern,
+        notExist,
+        closelyMatched,
+      };
+    });
+
+    for (const pattern of patterns) {
+      if (pattern.notExist) {
+        const closelyMatched = pattern.closelyMatched.length > 0 ? ` Do you mean ${chalk.blue(pattern.closelyMatched.join(', '))}?` : '';
+        warning(`${chalk.red(pattern.pattern)} does not exist.${closelyMatched}`);
+      }
+    };
+  }
+
   /**
    * Validate the stacks for errors and warnings according to the CLI's current settings
    */

packages/aws-cdk/test/cdk-toolkit.test.ts

@@ -953,6 +953,70 @@ describe('destroy', () => {
       });
     }).resolves;
   });
+
+  test('does not throw and warns if there are only non-existent stacks', async () => {
+    const toolkit = defaultToolkitSetup();
+
+    await toolkit.destroy({
+      selector: { patterns: ['Test-Stack-X', 'Test-Stack-Y'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    });
+
+    expect(flatten(stderrMock.mock.calls)).toEqual(
+      expect.arrayContaining([
+        expect.stringMatching(/Test-Stack-X does not exist./),
+        expect.stringMatching(/Test-Stack-Y does not exist./),
+        expect.stringMatching(/No stacks match the name\(s\): Test-Stack-X, Test-Stack-Y/),
+      ]),
+    );
+  });
+
+  test('does not throw and warns if there is a non-existent stack and the other exists', async () => {
+    const toolkit = defaultToolkitSetup();
+
+    await toolkit.destroy({
+      selector: { patterns: ['Test-Stack-X', 'Test-Stack-B'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    });
+
+    expect(flatten(stderrMock.mock.calls)).toEqual(
+      expect.arrayContaining([
+        expect.stringMatching(/Test-Stack-X does not exist./),
+      ]),
+    );
+    expect(flatten(stderrMock.mock.calls)).not.toEqual(
+      expect.arrayContaining([
+        expect.stringMatching(/Test-Stack-B does not exist./),
+      ]),
+    );
+    expect(flatten(stderrMock.mock.calls)).not.toEqual(
+      expect.arrayContaining([
+        expect.stringMatching(/No stacks match the name\(s\)/),
+      ]),
+    );
+  });
+
+  test('does not throw and suggests valid names if there is a non-existent but closely matching stack', async () => {
+    const toolkit = defaultToolkitSetup();
+
+    await toolkit.destroy({
+      selector: { patterns: ['test-stack-b'] },
+      exclusively: true,
+      force: true,
+      fromDeploy: true,
+    });
+
+    expect(flatten(stderrMock.mock.calls)).toEqual(
+      expect.arrayContaining([
+        expect.stringMatching(/test-stack-b does not exist. Do you mean Test-Stack-B?/),
+        expect.stringMatching(/No stacks match the name\(s\): test-stack-b/),
+      ]),
+    );
+  });
 });
 
 describe('watch', () => {