refactor: filter stacks before getting their templates (#960)

The `refactor` command only operates on the stacks that are relevant for
the target CDK application. However, it gets all the templates of the
deployed stacks before filtering them, which is wasteful.

Invert the order, so that the filtering happens before getting the
templates.

---
By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache-2.0 license

Author: otaviomacedo

packages/@aws-cdk-testing/cli-integ/resources/cdk-apps/app/app.js

@@ -1184,6 +1184,10 @@ switch (stackSet) {
   case 'stage-with-no-stacks':
     break;
 
+  case 'stage-only':
+    new SomeStage(app, `${stackPrefix}-stage`);
+    break;
+
   default:
     throw new Error(`Unrecognized INTEG_STACK_SET: '${stackSet}'`);
 }

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

@@ -0,0 +1,21 @@
+import { integTest, withDefaultFixture } from '../../../lib';
+
+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.cdkDestroy([nonExistingStackName1, nonExistingStackName2], {
+    force: false,
+  })).resolves.not.toThrow();
+}));
+
+integTest('cdk destroy does not fail even if the stages do not exist', withDefaultFixture(async (fixture) => {
+  await expect(fixture.cdkDestroy('NonExistent/*')).resolves.not.toThrow();
+}));

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

@@ -0,0 +1,28 @@
+import { DescribeStacksCommand } from '@aws-sdk/client-cloudformation';
+import { integTest, withDefaultFixture } from '../../../lib';
+
+integTest('cdk destroy can destroy stacks in stage-only configuration', withDefaultFixture(async (fixture) => {
+  const integStackSet = 'stage-only';
+
+  const stageNameSuffix = 'stage';
+  const specifiedStackName = `${stageNameSuffix}/*`;
+
+  await fixture.cdkDeploy(specifiedStackName, {
+    modEnv: {
+      INTEG_STACK_SET: integStackSet,
+    },
+  });
+
+  const stackName = `${fixture.fullStackName(stageNameSuffix)}-StackInStage`;
+  const stack = await fixture.aws.cloudFormation.send(new DescribeStacksCommand({ StackName: stackName }));
+  expect(stack.Stacks?.length ?? 0).toEqual(1);
+
+  await fixture.cdkDestroy(specifiedStackName, {
+    modEnv: {
+      INTEG_STACK_SET: integStackSet,
+    },
+  });
+
+  await expect(fixture.aws.cloudFormation.send(new DescribeStacksCommand({ StackName: stackName })))
+    .rejects.toThrow(/does not exist/);
+}));

packages/@aws-cdk/toolkit-lib/test/actions/diff.test.ts

@@ -11,7 +11,7 @@ import { Toolkit } from '../../lib/toolkit';
 import { cdkOutFixture, disposableCloudAssemblySource, TestIoHost } from '../_helpers';
 import { mockCloudFormationClient, MockSdk, mockSSMClient, restoreSdkMocksToDefault, setDefaultSTSMocks } from '../_helpers/mock-sdk';
 
-jest.setTimeout(20_000);
+jest.setTimeout(60_000);
 
 let ioHost: TestIoHost;
 let toolkit: Toolkit;

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

@@ -10,6 +10,7 @@ import * as chalk from 'chalk';
 import * as chokidar from 'chokidar';
 import { type EventName, EVENTS } from 'chokidar/handler.js';
 import * as fs from 'fs-extra';
+import * as picomatch from 'picomatch';
 import { CliIoHost } from './io-host';
 import type { Configuration } from './user-configuration';
 import { PROJECT_CONFIG } from './user-configuration';
@@ -917,6 +918,17 @@ export class CdkToolkit {
 
     const stacks = await this.selectStacksForDestroy(options.selector, options.exclusively);
 
+    await this.suggestStacks({
+      selector: options.selector,
+      stacks,
+      exclusively: options.exclusively,
+    });
+
+    if (stacks.stackArtifacts.length === 0) {
+      await this.ioHost.asIoHelper().defaults.warn(`No stacks match the name(s): ${chalk.red(options.selector.patterns.join(', '))}`);
+      return;
+    }
+
     if (!options.force) {
       const motivation = 'Destroying stacks is an irreversible action';
       const question = `Are you sure you want to delete: ${chalk.blue(stacks.stackArtifacts.map((s) => s.hierarchicalId).join(', '))}`;
@@ -1319,6 +1331,51 @@ export class CdkToolkit {
     return stacks;
   }
 
+  private async suggestStacks(props: {
+    selector: StackSelector;
+    stacks: StackCollection;
+    exclusively: boolean;
+  }) {
+    if (props.selector.patterns.length === 0) {
+      return;
+    }
+
+    const assembly = await this.assembly();
+    const selectorWithoutPatterns: StackSelector = {
+      patterns: [],
+    };
+    const stacksWithoutPatterns = await assembly.selectStacks(selectorWithoutPatterns, {
+      extend: props.exclusively ? ExtendedStackSelection.None : ExtendedStackSelection.Downstream,
+      defaultBehavior: DefaultSelection.AllStacks,
+    });
+
+    const patterns = props.selector.patterns.map(pattern => {
+      const notExist = !props.stacks.stackArtifacts.find(stack =>
+        picomatch.isMatch(stack.hierarchicalId, pattern),
+      );
+
+      const closelyMatched = notExist ? stacksWithoutPatterns.stackArtifacts.map(stack => {
+        if (picomatch.isMatch(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(', '))}?` : '';
+        await this.ioHost.asIoHelper().defaults.warn(`${chalk.red(pattern.pattern)} does not exist.${closelyMatched}`);
+      }
+    }
+  }
+
   /**
    * Validate the stacks for errors and warnings according to the CLI's current settings
    */