normalize default value

Author: vivian12300

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

@@ -1276,29 +1276,46 @@ export class Toolkit extends CloudAssemblySourceBuilder {
   /**
    * Retrieve feature flag information from the cloud assembly
    */
-
   public async flags(cx: ICloudAssemblySource): Promise<FeatureFlag[]> {
     this.requireUnstableFeature('flags');
 
     const ioHelper = asIoHelper(this.ioHost, 'flags');
     await using assembly = await assemblyFromSource(ioHelper, cx);
-    const artifacts = assembly.cloudAssembly.manifest.artifacts;
+    const artifacts = Object.values(assembly.cloudAssembly.manifest.artifacts!);
+    const featureFlagReports = artifacts.filter(a => a.type === ArtifactType.FEATURE_FLAG_REPORT);
+
+    const flags = featureFlagReports.flatMap(report => {
+      const properties = report.properties as FeatureFlagReportProperties;
+      const moduleName = properties.module;
+
+      const flagsWithUnconfiguredBehavesLike = Object.entries(properties.flags)
+        .filter(([_, flagInfo]) => flagInfo.unconfiguredBehavesLike != undefined);
 
-    return Object.values(artifacts!)
-      .filter(a => a.type === ArtifactType.FEATURE_FLAG_REPORT)
-      .flatMap(report => {
-        const properties = report.properties as FeatureFlagReportProperties;
-        const moduleName = properties.module;
+      const shouldIncludeUnconfiguredBehavesLike = flagsWithUnconfiguredBehavesLike.length > 0;
 
-        return Object.entries(properties.flags).map(([flagName, flagInfo]) => ({
+      return Object.entries(properties.flags).map(([flagName, flagInfo]) => {
+        const baseFlag = {
           module: moduleName,
           name: flagName,
           recommendedValue: flagInfo.recommendedValue,
           userValue: flagInfo.userValue ?? undefined,
           explanation: flagInfo.explanation ?? '',
-          unconfiguredBehavesLike: flagInfo.unconfiguredBehavesLike,
-        }));
+        };
+
+        if (shouldIncludeUnconfiguredBehavesLike) {
+          return {
+            ...baseFlag,
+            unconfiguredBehavesLike: {
+              v2: flagInfo.unconfiguredBehavesLike?.v2 === true ? true : false,
+            },
+          };
+        }
+
+        return baseFlag;
       });
+    });
+
+    return flags;
   }
 
   private requireUnstableFeature(requestedFeature: UnstableFeature) {

packages/aws-cdk/lib/commands/flag-operations.ts

@@ -87,7 +87,7 @@ export async function handleFlags(flagData: FeatureFlag[], ioHelper: IoHelper, o
         default: true,
         unconfigured: true,
       };
-      await setMultipleFlags(params);
+      await checkDefaultBehavior(params);
     } else if (answer == FlagsMenuOptions.MODIFY_SPECIFIC_FLAG) {
       await setFlag(params, true);
     } else if (answer == FlagsMenuOptions.EXIT) {
@@ -167,8 +167,7 @@ export async function handleFlags(flagData: FeatureFlag[], ioHelper: IoHelper, o
   }
 
   if (options.set && options.all && options.default) {
-    await setMultipleFlags(params);
-    return;
+    await checkDefaultBehavior(params);
   }
 
   if (options.set && options.unconfigured && options.recommended) {
@@ -177,9 +176,23 @@ export async function handleFlags(flagData: FeatureFlag[], ioHelper: IoHelper, o
   }
 
   if (options.set && options.unconfigured && options.default) {
+    await checkDefaultBehavior(params);
+  }
+}
+
+/**
+ * Checks if the `unconfiguredBehavesLike` field is populated
+ *
+ * @returns true if --default options can be run
+ */
+async function checkDefaultBehavior(params: FlagOperationsParams) {
+  const { flagData, ioHelper } = params;
+  if (flagData[0].unconfiguredBehavesLike) {
     await setMultipleFlags(params);
     return;
   }
+  await ioHelper.defaults.error('The --default options are not compatible with the AWS CDK library used by your application. Please upgrade to 2.212.0 or above.');
+  return;
 }
 
 async function setFlag(params: FlagOperationsParams, interactive?: boolean) {

packages/aws-cdk/test/commands/flag-operations.test.ts

@@ -572,6 +572,65 @@ describe('modifyValues', () => {
   });
 });
 
+describe('checkDefaultBehavior', () => {
+  test('calls setMultipleFlags when unconfiguredBehavesLike is present', async () => {
+    const flagsWithUnconfiguredBehavior: FeatureFlag[] = [
+      {
+        module: 'aws-cdk-lib',
+        name: '@aws-cdk/core:testFlag',
+        recommendedValue: 'true',
+        userValue: undefined,
+        explanation: 'Test flag',
+        unconfiguredBehavesLike: { v2: 'true' },
+      },
+    ];
+
+    const cdkJsonPath = await createCdkJsonFile({});
+    setupMockToolkitForPrototyping(mockToolkit);
+
+    const requestResponseSpy = jest.spyOn(ioHelper, 'requestResponse');
+    requestResponseSpy.mockResolvedValue(true);
+
+    const options: FlagsOptions = {
+      set: true,
+      all: true,
+      default: true,
+    };
+
+    await handleFlags(flagsWithUnconfiguredBehavior, ioHelper, options, mockToolkit);
+
+    expect(mockToolkit.fromCdkApp).toHaveBeenCalled();
+    expect(mockToolkit.synth).toHaveBeenCalled();
+
+    await cleanupCdkJsonFile(cdkJsonPath);
+    requestResponseSpy.mockRestore();
+  });
+
+  test('shows error when unconfiguredBehavesLike is not present', async () => {
+    const flagsWithoutUnconfiguredBehavior: FeatureFlag[] = [
+      {
+        module: 'aws-cdk-lib',
+        name: '@aws-cdk/core:testFlag',
+        recommendedValue: 'true',
+        userValue: undefined,
+        explanation: 'Test flag',
+      },
+    ];
+
+    const options: FlagsOptions = {
+      set: true,
+      all: true,
+      default: true,
+    };
+
+    await handleFlags(flagsWithoutUnconfiguredBehavior, ioHelper, options, mockToolkit);
+
+    const plainTextOutput = output();
+    expect(plainTextOutput).toContain('The --default options are not compatible with the AWS CDK library used by your application.');
+    expect(mockToolkit.fromCdkApp).not.toHaveBeenCalled();
+  });
+});
+
 describe('interactive prompts lead to the correct function calls', () => {
   beforeEach(() => {
     setupMockToolkitForPrototyping(mockToolkit);
@@ -654,11 +713,30 @@ describe('interactive prompts lead to the correct function calls', () => {
     const requestResponseSpy = jest.spyOn(ioHelper, 'requestResponse');
     requestResponseSpy.mockResolvedValue(true);
 
+    const flagsWithUnconfiguredBehavior: FeatureFlag[] = [
+      {
+        module: 'aws-cdk-lib',
+        name: '@aws-cdk/core:testFlag',
+        recommendedValue: 'true',
+        userValue: 'false',
+        explanation: 'Test flag for unit tests',
+        unconfiguredBehavesLike: { v2: 'true' },
+      },
+      {
+        module: 'aws-cdk-lib',
+        name: '@aws-cdk/s3:anotherFlag',
+        recommendedValue: 'false',
+        userValue: undefined,
+        explanation: 'Another test flag',
+        unconfiguredBehavesLike: { v2: 'false' },
+      },
+    ];
+
     const options: FlagsOptions = {
       interactive: true,
     };
 
-    await handleFlags(mockFlagsData, ioHelper, options, mockToolkit);
+    await handleFlags(flagsWithUnconfiguredBehavior, ioHelper, options, mockToolkit);
 
     expect(mockToolkit.fromCdkApp).toHaveBeenCalledTimes(2);
     expect(mockToolkit.synth).toHaveBeenCalledTimes(2);