@go-to-k/cdkd 0.30.0 → 0.30.1

package/dist/cli.js

@@ -12966,7 +12966,9 @@ import {
   GetFunctionCommand,
   ListFunctionsCommand,
   ListTagsCommand,
-  ResourceNotFoundException
+  ResourceNotFoundException,
+  waitUntilFunctionActiveV2,
+  waitUntilFunctionUpdatedV2
 } from "@aws-sdk/client-lambda";
 import {
   DescribeNetworkInterfacesCommand,
@@ -13009,6 +13011,14 @@ var LambdaFunctionProvider = class {
   eniWaitTimeoutMs = 10 * 60 * 1e3;
   eniWaitInitialDelayMs = 1e4;
   eniWaitMaxDelayMs = 3e4;
+  // Budget for the post-CreateFunction / post-Update wait that blocks until
+  // Configuration.State === 'Active' and LastUpdateStatus === 'Successful'.
+  // Must NOT be skipped by --no-wait: downstream resources (Custom Resource
+  // Invokes, EventSourceMappings, etc.) cannot operate against a function
+  // still in Pending / InProgress, so this is required for correctness, not
+  // a "convenience wait" like CloudFront / RDS readiness.
+  // Seconds (the SDK waiter contract is seconds, not ms).
+  functionReadyMaxWaitSeconds = 10 * 60;
   // delstack-style ENI cleanup tunables.
   // - initial sleep: gives AWS time to publish post-detach ENI state via
   //   DescribeNetworkInterfaces (right after the update, the API can return
@@ -13077,6 +13087,7 @@ var LambdaFunctionProvider = class {
         Tags: tags
       };
       const response = await this.lambdaClient.send(new CreateFunctionCommand(createParams));
+      await this.waitForFunctionActive(logicalId, resourceType, functionName);
       this.logger.debug(`Successfully created Lambda function ${logicalId}: ${functionName}`);
       return {
         physicalId: response.FunctionName || functionName,
@@ -13086,6 +13097,9 @@ var LambdaFunctionProvider = class {
         }
       };
     } catch (error) {
+      if (error instanceof ProvisioningError) {
+        throw error;
+      }
       const cause = error instanceof Error ? error : void 0;
       throw new ProvisioningError(
         `Failed to create Lambda function ${logicalId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -13142,6 +13156,7 @@ var LambdaFunctionProvider = class {
         };
         await this.lambdaClient.send(new UpdateFunctionConfigurationCommand(configParams));
         this.logger.debug(`Updated configuration for Lambda function ${physicalId}`);
+        await this.waitForFunctionUpdated(logicalId, resourceType, physicalId);
       }
       const newCode = properties["Code"];
       const oldCode = previousProperties["Code"];
@@ -13157,6 +13172,7 @@ var LambdaFunctionProvider = class {
         };
         await this.lambdaClient.send(new UpdateFunctionCodeCommand(codeParams));
         this.logger.debug(`Updated code for Lambda function ${physicalId}`);
+        await this.waitForFunctionUpdated(logicalId, resourceType, physicalId);
       }
       const getResponse = await this.lambdaClient.send(
         new GetFunctionCommand({ FunctionName: physicalId })
@@ -13170,6 +13186,9 @@ var LambdaFunctionProvider = class {
         }
       };
     } catch (error) {
+      if (error instanceof ProvisioningError) {
+        throw error;
+      }
       const cause = error instanceof Error ? error : void 0;
       throw new ProvisioningError(
         `Failed to update Lambda function ${logicalId}: ${error instanceof Error ? error.message : String(error)}`,
@@ -13336,6 +13355,58 @@ var LambdaFunctionProvider = class {
    * Timeout is a soft warning — downstream Subnet/SG deletion has its own
    * retries.
    */
+  /**
+   * Block until the function's State === 'Active'.
+   *
+   * Used after CreateFunction. Wraps the SDK's built-in
+   * `waitUntilFunctionActiveV2` (acceptors: SUCCESS=Active, FAILURE=Failed,
+   * RETRY=Pending). The waiter throws on FAILURE / TIMEOUT — both surface
+   * as `ProvisioningError` with the function-name as physicalId so the
+   * deploy engine's per-resource error handling treats them identically to
+   * a CreateFunction failure.
+   */
+  async waitForFunctionActive(logicalId, resourceType, functionName) {
+    try {
+      await waitUntilFunctionActiveV2(
+        { client: this.lambdaClient, maxWaitTime: this.functionReadyMaxWaitSeconds },
+        { FunctionName: functionName }
+      );
+    } catch (error) {
+      const cause = error instanceof Error ? error : void 0;
+      throw new ProvisioningError(
+        `Lambda function ${logicalId} did not reach Active state: ${error instanceof Error ? error.message : String(error)}`,
+        resourceType,
+        logicalId,
+        functionName,
+        cause
+      );
+    }
+  }
+  /**
+   * Block until the function's LastUpdateStatus === 'Successful'.
+   *
+   * Used after UpdateFunctionConfiguration / UpdateFunctionCode. Wraps the
+   * SDK's `waitUntilFunctionUpdatedV2` (acceptors: SUCCESS=Successful,
+   * FAILURE=Failed, RETRY=InProgress). Same error-wrapping contract as
+   * `waitForFunctionActive`.
+   */
+  async waitForFunctionUpdated(logicalId, resourceType, functionName) {
+    try {
+      await waitUntilFunctionUpdatedV2(
+        { client: this.lambdaClient, maxWaitTime: this.functionReadyMaxWaitSeconds },
+        { FunctionName: functionName }
+      );
+    } catch (error) {
+      const cause = error instanceof Error ? error : void 0;
+      throw new ProvisioningError(
+        `Lambda function ${logicalId} update did not complete: ${error instanceof Error ? error.message : String(error)}`,
+        resourceType,
+        logicalId,
+        functionName,
+        cause
+      );
+    }
+  }
   /**
    * Poll GetFunction until LastUpdateStatus is no longer `InProgress`.
    *
@@ -13348,6 +13419,12 @@ var LambdaFunctionProvider = class {
    * Bounded by eniWaitTimeoutMs (10min) and treated as a soft warning on
    * timeout: the subsequent ENI cleanup loop and downstream retries cover
    * the residual edge case.
+   *
+   * NOTE: deliberately separate from `waitForFunctionUpdated` (which uses
+   * the SDK's `waitUntilFunctionUpdatedV2` and throws on FAILURE). The
+   * pre-delete path needs a more lenient acceptor: if a prior update
+   * failed, we still want to proceed with DeleteFunction rather than
+   * abort, because the function is going away anyway.
    */
   async waitForLambdaUpdateCompleted(functionName) {
     const start = Date.now();
@@ -36062,7 +36139,7 @@ function reorderArgs(argv) {
 }
 async function main() {
   const program = new Command13();
-  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.30.0");
+  program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.30.1");
   program.addCommand(createBootstrapCommand());
   program.addCommand(createSynthCommand());
   program.addCommand(createListCommand());