fix(flags): flags commands do not forward context parameters to synth

Author: go-to-k

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

@@ -498,7 +498,7 @@ export async function exec(args: string[], synthesizer?: Synthesizer): Promise<n
           unstableFeatures: configuration.settings.get(['unstable']),
         });
         const flagsData = await toolkit.flags(cloudExecutable);
-        const handler = new FlagCommandHandler(flagsData, ioHelper, args, toolkit);
+        const handler = new FlagCommandHandler(flagsData, ioHelper, args, toolkit, configuration.context.all);
         return handler.processFlagsCommand();
 
       case 'synthesize':

packages/aws-cdk/lib/commands/flags/flags.ts

@@ -14,13 +14,19 @@ export class FlagCommandHandler {
   private readonly ioHelper: IoHelper;
 
   /** Main component that sets up all flag operation components */
-  constructor(flagData: FeatureFlag[], ioHelper: IoHelper, options: FlagOperationsParams, toolkit: Toolkit) {
+  constructor(
+    flagData: FeatureFlag[],
+    ioHelper: IoHelper,
+    options: FlagOperationsParams,
+    toolkit: Toolkit,
+    cliContextValues: Record<string, any> = {},
+  ) {
     this.flags = flagData.filter(flag => !OBSOLETE_FLAGS.includes(flag.name));
     this.options = { ...options, concurrency: options.concurrency ?? 4 };
     this.ioHelper = ioHelper;
 
     const validator = new FlagValidator(ioHelper);
-    const flagOperations = new FlagOperations(this.flags, toolkit, ioHelper);
+    const flagOperations = new FlagOperations(this.flags, toolkit, ioHelper, cliContextValues);
     const interactiveHandler = new InteractiveHandler(this.flags, flagOperations);
 
     this.router = new FlagOperationRouter(validator, interactiveHandler, flagOperations);

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

@@ -48,6 +48,7 @@ export class FlagOperations {
     private readonly flags: FeatureFlag[],
     private readonly toolkit: Toolkit,
     private readonly ioHelper: IoHelper,
+    private readonly cliContextValues: Record<string, any> = {},
   ) {
     this.app = '';
     this.baseContextValues = {};
@@ -159,11 +160,12 @@ export class FlagOperations {
   /** Initializes the safety check by reading context and synthesizing baseline templates */
   private async initializeSafetyCheck(): Promise<void> {
     const baseContext = new CdkAppMultiContext(process.cwd());
-    this.baseContextValues = await baseContext.read();
+    this.baseContextValues = { ...await baseContext.read(), ...this.cliContextValues };
 
     this.baselineTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-baseline-'));
+    const mergedContext = new MemoryContext(this.baseContextValues);
     const baseSource = await this.toolkit.fromCdkApp(this.app, {
-      contextStore: baseContext,
+      contextStore: mergedContext,
       outdir: this.baselineTempDir,
     });
 
@@ -270,14 +272,14 @@ export class FlagOperations {
   /** Prototypes flag changes by synthesizing templates and showing diffs to the user */
   private async prototypeChanges(flagNames: string[], params: FlagOperationsParams): Promise<boolean> {
     const baseContext = new CdkAppMultiContext(process.cwd());
-    const baseContextValues = await baseContext.read();
+    const baseContextValues = { ...await baseContext.read(), ...this.cliContextValues };
     const memoryContext = new MemoryContext(baseContextValues);
 
     const cdkJson = await JSON.parse(await fs.readFile(path.join(process.cwd(), 'cdk.json'), 'utf-8'));
     const app = cdkJson.app;
 
     const source = await this.toolkit.fromCdkApp(app, {
-      contextStore: baseContext,
+      contextStore: memoryContext,
       outdir: fs.mkdtempSync(path.join(os.tmpdir(), 'cdk-original-')),
     });
 

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

@@ -1197,6 +1197,144 @@ describe('interactive prompts lead to the correct function calls', () => {
   });
 });
 
+describe('CLI context parameters', () => {
+  beforeEach(() => {
+    setupMockToolkitForPrototyping(mockToolkit);
+    jest.clearAllMocks();
+  });
+
+  test('CLI context values are merged with file context during prototyping', async () => {
+    const cdkJsonPath = await createCdkJsonFile({
+      '@aws-cdk/core:existingFlag': true,
+    });
+
+    setupMockToolkitForPrototyping(mockToolkit);
+
+    const requestResponseSpy = jest.spyOn(ioHelper, 'requestResponse');
+    requestResponseSpy.mockResolvedValue(false);
+
+    const cliContextValues = {
+      foo: 'bar',
+      myContextParam: 'myValue',
+    };
+
+    const options: FlagsOptions = {
+      FLAGNAME: ['@aws-cdk/core:testFlag'],
+      set: true,
+      value: 'true',
+    };
+
+    const flagOperations = new FlagCommandHandler(mockFlagsData, ioHelper, options, mockToolkit, cliContextValues);
+    await flagOperations.processFlagsCommand();
+
+    // Verify that fromCdkApp was called with a context store
+    expect(mockToolkit.fromCdkApp).toHaveBeenCalledTimes(2);
+
+    // Get the first call's context store
+    const firstCallArgs = mockToolkit.fromCdkApp.mock.calls[0];
+    const contextStore = firstCallArgs[1]?.contextStore;
+
+    // Verify the context store is a MemoryContext that contains both file and CLI context
+    expect(contextStore).toBeDefined();
+
+    await cleanupCdkJsonFile(cdkJsonPath);
+    requestResponseSpy.mockRestore();
+  });
+
+  test('CLI context values are passed to synthesis during safe flag checking', async () => {
+    const cdkJsonPath = await createCdkJsonFile({});
+
+    mockToolkit.diff.mockResolvedValue({
+      TestStack: { differenceCount: 0 } as any,
+    });
+
+    const requestResponseSpy = jest.spyOn(ioHelper, 'requestResponse');
+    requestResponseSpy.mockResolvedValue(false);
+
+    const cliContextValues = {
+      myCliParam: 'cliValue',
+    };
+
+    const options: FlagsOptions = {
+      safe: true,
+      concurrency: 4,
+    };
+
+    const flagOperations = new FlagCommandHandler(mockFlagsData, ioHelper, options, mockToolkit, cliContextValues);
+    await flagOperations.processFlagsCommand();
+
+    // Verify that fromCdkApp was called during safe flag checking
+    expect(mockToolkit.fromCdkApp).toHaveBeenCalled();
+
+    await cleanupCdkJsonFile(cdkJsonPath);
+    requestResponseSpy.mockRestore();
+  });
+
+  test('works correctly when no CLI context is provided', async () => {
+    const cdkJsonPath = await createCdkJsonFile({
+      '@aws-cdk/core:existingFlag': false,
+    });
+
+    setupMockToolkitForPrototyping(mockToolkit);
+
+    const requestResponseSpy = jest.spyOn(ioHelper, 'requestResponse');
+    requestResponseSpy.mockResolvedValue(false);
+
+    const options: FlagsOptions = {
+      FLAGNAME: ['@aws-cdk/core:testFlag'],
+      set: true,
+      value: 'true',
+    };
+
+    // Not passing cliContextValues (defaults to empty object)
+    const flagOperations = new FlagCommandHandler(mockFlagsData, ioHelper, options, mockToolkit);
+    await flagOperations.processFlagsCommand();
+
+    expect(mockToolkit.fromCdkApp).toHaveBeenCalledTimes(2);
+    expect(mockToolkit.synth).toHaveBeenCalledTimes(2);
+
+    await cleanupCdkJsonFile(cdkJsonPath);
+    requestResponseSpy.mockRestore();
+  });
+
+  test('FlagCommandHandler constructor accepts CLI context values', () => {
+    const cliContextValues = {
+      myParam: 'myValue',
+      foo: 'bar',
+    };
+
+    const options: FlagsOptions = {
+      all: true,
+    };
+
+    // Verify that constructor accepts CLI context values parameter
+    const handler = new FlagCommandHandler(mockFlagsData, ioHelper, options, mockToolkit, cliContextValues);
+    expect(handler).toBeDefined();
+  });
+
+  test('FlagCommandHandler passes CLI context to FlagOperations', async () => {
+    const cdkJsonPath = await createCdkJsonFile({});
+
+    setupMockToolkitForPrototyping(mockToolkit);
+
+    const cliContextValues = {
+      cliParam: 'cliValue',
+    };
+
+    const options: FlagsOptions = {
+      all: true,
+    };
+
+    const handler = new FlagCommandHandler(mockFlagsData, ioHelper, options, mockToolkit, cliContextValues);
+    await handler.processFlagsCommand();
+
+    // Just verify it doesn't throw and completes successfully
+    expect(mockToolkit.fromCdkApp).not.toHaveBeenCalled(); // Display mode doesn't call synthesis
+
+    await cleanupCdkJsonFile(cdkJsonPath);
+  });
+});
+
 describe('setSafeFlags', () => {
   beforeEach(() => {
     setupMockToolkitForPrototyping(mockToolkit);
@@ -1390,7 +1528,13 @@ async function displayFlags(params: FlagOperationsParams): Promise<void> {
   await f.displayFlags(params);
 }
 
-async function handleFlags(flagData: FeatureFlag[], _ioHelper: IoHelper, options: FlagsOptions, toolkit: Toolkit) {
-  const f = new FlagCommandHandler(flagData, _ioHelper, options, toolkit);
+async function handleFlags(
+  flagData: FeatureFlag[],
+  _ioHelper: IoHelper,
+  options: FlagsOptions,
+  toolkit: Toolkit,
+  cliContextValues: Record<string, any> = {},
+) {
+  const f = new FlagCommandHandler(flagData, _ioHelper, options, toolkit, cliContextValues);
   await f.processFlagsCommand();
 }