feat(cli): watch command now starts with a deployment (#18057)

Similar to `tsc -w`, `cdk watch` should trigger an initial deployment instead
of waiting for a file change event. We achieve this by pulling out the callback
function for `'all'` and calling that function during the `'ready'` callback.

Closes #17776.

----

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

Author: kaizencc

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

@@ -295,31 +295,39 @@ export class CdkToolkit {
     // |            |                |      | <------------------ |            | <------------------ |            | <-------------|
     // --------------                --------  'cdk deploy' done  --------------  'cdk deploy' done  --------------
     let latch: 'pre-ready' | 'open' | 'deploying' | 'queued' = 'pre-ready';
+
+    const deployAndWatch = async () => {
+      latch = 'deploying';
+
+      await this.invokeDeployFromWatch(options);
+
+      // If latch is still 'deploying' after the 'await', that's fine,
+      // but if it's 'queued', that means we need to deploy again
+      while ((latch as 'deploying' | 'queued') === 'queued') {
+        // TypeScript doesn't realize latch can change between 'awaits',
+        // and thinks the above 'while' condition is always 'false' without the cast
+        latch = 'deploying';
+        print("Detected file changes during deployment. Invoking 'cdk deploy' again");
+        await this.invokeDeployFromWatch(options);
+      }
+      latch = 'open';
+    };
+
     chokidar.watch(watchIncludes, {
       ignored: watchExcludes,
       cwd: rootDir,
       // ignoreInitial: true,
-    }).on('ready', () => {
+    }).on('ready', async () => {
       latch = 'open';
       debug("'watch' received the 'ready' event. From now on, all file changes will trigger a deployment");
-    }).on('all', async (event, filePath) => {
+      print("Triggering initial 'cdk deploy'");
+      await deployAndWatch();
+    }).on('all', async (event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir', filePath?: string) => {
       if (latch === 'pre-ready') {
         print(`'watch' is observing ${event === 'addDir' ? 'directory' : 'the file'} '%s' for changes`, filePath);
       } else if (latch === 'open') {
-        latch = 'deploying';
         print("Detected change to '%s' (type: %s). Triggering 'cdk deploy'", filePath, event);
-        await this.invokeDeployFromWatch(options);
-
-        // If latch is still 'deploying' after the 'await', that's fine,
-        // but if it's 'queued', that means we need to deploy again
-        while ((latch as 'deploying' | 'queued') === 'queued') {
-          // TypeScript doesn't realize latch can change between 'awaits',
-          // and thinks the above 'while' condition is always 'false' without the cast
-          latch = 'deploying';
-          print("Detected file changes during deployment. Invoking 'cdk deploy' again");
-          await this.invokeDeployFromWatch(options);
-        }
-        latch = 'open';
+        await deployAndWatch();
       } else { // this means latch is either 'deploying' or 'queued'
         latch = 'queued';
         print("Detected change to '%s' (type: %s) while 'cdk deploy' is still running. " +

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

@@ -350,13 +350,20 @@ describe('watch', () => {
 
     describe("when the 'ready' event has already fired", () => {
       beforeEach(() => {
+        // The ready callback triggers a deployment so each test
+        // that uses this function will see 'cdkDeployMock' called
+        // an additional time.
         fakeChokidarWatcherOn.readyCallback();
       });
 
+      test("an initial 'deploy' is triggered, without any file changes", async () => {
+        expect(cdkDeployMock).toHaveBeenCalledTimes(1);
+      });
+
       test("does trigger a 'deploy' for a file change", async () => {
         await fakeChokidarWatcherOn.fileEventCallback('add', 'my-file');
 
-        expect(cdkDeployMock).toHaveBeenCalled();
+        expect(cdkDeployMock).toHaveBeenCalledTimes(2);
       });
 
       test("triggers a 'deploy' twice for two file changes", async () => {
@@ -365,17 +372,18 @@ describe('watch', () => {
           fakeChokidarWatcherOn.fileEventCallback('change', 'my-file2'),
         ]);
 
-        expect(cdkDeployMock).toHaveBeenCalledTimes(2);
+        expect(cdkDeployMock).toHaveBeenCalledTimes(3);
       });
 
       test("batches file changes that happen during 'deploy'", async () => {
         await Promise.all([
           fakeChokidarWatcherOn.fileEventCallback('add', 'my-file1'),
           fakeChokidarWatcherOn.fileEventCallback('change', 'my-file2'),
           fakeChokidarWatcherOn.fileEventCallback('unlink', 'my-file3'),
+          fakeChokidarWatcherOn.fileEventCallback('add', 'my-file4'),
         ]);
 
-        expect(cdkDeployMock).toHaveBeenCalledTimes(2);
+        expect(cdkDeployMock).toHaveBeenCalledTimes(3);
       });
     });
   });