feat: ignore diff for certain stages

.projenrc.ts

@@ -43,6 +43,16 @@ const project = new GitHubActionTypeScriptProject({
         required: false,
         default: 'true',
       },
+      noDiffForStages: {
+        description: 'List of stages to ignore and not show a diff for',
+        required: false,
+        default: '',
+      },
+      noFailOnDestructiveChanges: {
+        description: '',
+        required: false,
+        default: 'List of stages where breaking changes will not fail the build',
+      },
     },
     runs: {
       using: RunsUsing.NODE_16, // overwrite to node20

src/action.ts

@@ -10,6 +10,8 @@ export async function run() {
     allowedDestroyTypes: getInput('allowedDestroyTypes').split(','),
     failOnDestructiveChanges: getBooleanInput('failOnDestructiveChanges'),
     githubToken: getInput('githubToken'),
+    noDiffForStages: getInput('noDiffForStages').split(','),
+    noFailOnDestructiveChanges: getInput('noFailOnDestructiveChanges').split(','),
   };
   const octokit = github.getOctokit(inputs.githubToken);
   const context = github.context;

src/inputs.ts

@@ -22,4 +22,18 @@ export interface Inputs {
    * @default true
    */
   failOnDestructiveChanges: boolean;
+
+  /**
+   * List of stages to ignore and not show a diff for
+   *
+   * @default - show diff for all stages
+   */
+  noDiffForStages: string[];
+
+  /**
+   * List of stages where breaking changes will not fail the build
+   *
+   * @default - breaking changes on any stage will fail the build
+   */
+  noFailOnDestructiveChanges: string[];
 }

src/stage-processor.ts

@@ -61,13 +61,15 @@ export class StageProcessor {
    * Process all of the stages. Once this has been run
    * the comment can be created with `commentStages()`
    */
-  public async processStages() {
+  public async processStages(ignoreDestructiveChanges: string[] = []) {
     for (const stage of this.stages) {
       for (const stack of stage.stacks) {
         try {
           const { comment, changes } = await this.diffStack(stack);
           this.stageComments[stage.name].comment.push(...comment);
-          this.stageComments[stage.name].destructiveChanges += changes;
+          if (!ignoreDestructiveChanges.includes(stage.name)) {
+            this.stageComments[stage.name].destructiveChanges += changes;
+          }
         } catch (e: any) {
           console.error('Error processing stages: ', e);
           throw e;
@@ -144,16 +146,19 @@ export class StageProcessor {
       '',
     ]);
     if (changes.destructiveChanges.length) {
+      output.push('');
       output.push('> [!WARNING]\n> ***Destructive Changes*** :bangbang:'),
       changes.destructiveChanges.forEach(change => {
         output.push(
           `> **Stack: ${change.stackName} - Resource: ${change.logicalId} - Impact:** ***${change.impact}***`,
         );
+        output.push('');
       });
     }
     const writable = new StringWritable({});
     formatDifferences(writable, diff);
 
+    output.push('');
     output.push('```shell');
     output.push(writable.data);
     output.push('```');

test/assembly.test.ts

@@ -1,12 +1,12 @@
 import * as path from 'path';
-import mockfs from 'mock-fs';
+import mock from 'mock-fs';
 import { AssemblyManifestReader } from '../src/assembly';
 
 describe('cloud assembly manifest reader', () => {
   const manifestFile = 'cdk.out/manifest.json';
   const lookupRoleArn = 'arn:${AWS::Partition}:iam::123456789012:role/cdk-hnb659fds-lookup-role-123456789012-us-east-1';
   beforeEach(() => {
-    mockfs({
+    mock({
       ['cdk.out']: {
         ['assembly-SomeStage']: {
           ['manifest.json']: JSON.stringify({
@@ -62,7 +62,7 @@ describe('cloud assembly manifest reader', () => {
   });
 
   afterEach(() => {
-    mockfs.restore();
+    mock.restore();
   });
 
   test('can read manifest from file', () => {

test/stage-processor.test.ts

@@ -75,4 +75,36 @@ describe('StageProcessor', () => {
     expect(p.Stage1.destructiveChanges).toEqual(1);
   });
 
+  test('stage with destructive changes-ignored', async () => {
+    cfnMock.on(GetTemplateCommand)
+      .resolves({
+        TemplateBody: JSON.stringify(stackInfo.content),
+      });
+    const processor = new StageProcessor([
+      {
+        name: 'Stage1',
+        stacks: [{
+          name: 'my-stack',
+          content: {
+            Resources: {
+              MyRole: {
+                Type: 'AWS::IAM::Role',
+                Properties: {
+                  RoleName: 'MyNewCustomName2',
+                },
+              },
+            },
+          },
+        }],
+      },
+    ], []);
+    await processor.processStages(['Stage1']);
+    const p = (processor as any).stageComments;
+    expect(p).toEqual({
+      Stage1: expect.any(Object),
+    });
+    expect(p.Stage1.comment.length).not.toEqual(0);
+    expect(p.Stage1.destructiveChanges).toEqual(0);
+  });
+
 });