Delete an old version of lambda(with provisioned concurrency) after new version is created

Hi It seems like you're encountering an issue with the lambda.waitFor() method not behaving as expected when waiting for the provisioning concurrency to be set up on a newer version of a Lambda function before deleting the old version.

lambda.waitFor() should indeed wait until the specified event occurs, but it's possible that it might not be the most suitable method for waiting on the provisioning concurrency setup.

One alternative approach you mentioned is periodically checking the status of the provisioning concurrency using getProvisionedConcurrencyConfig() until it's in the "READY" state before proceeding with the deletion of the old alias. This approach seems reasonable and practical.

Here's how you can implement it:

• After creating the new version of the Lambda function, periodically check the status of the provisioning concurrency for that version.
• Once the provisioning concurrency is in the "READY" state, proceed with deleting the old version of the alias. Here's a rough outline of how you can achieve this:

javascript

async function waitForProvisionedConcurrency(functionName, aliasName, version) {
    const params = {
        FunctionName: functionName,
        Qualifier: `${version}:${aliasName}`
    };

    let provisionedConcurrencyConfig;
    do {
        // Get the provisioned concurrency configuration
        provisionedConcurrencyConfig = await lambda.getProvisionedConcurrencyConfig(params).promise();

        // Check if the status is "READY"
        if (provisionedConcurrencyConfig.Status === 'READY') {
            return;
        }

        // Wait for a certain period before checking again
        await new Promise(resolve => setTimeout(resolve, 5000)); // Wait for 5 seconds
    } while (true);
}

// Example usage after creating the new version
const functionName = 'your-function-name';
const aliasName = 'your-alias-name';
const newVersion = 'new-version';

// Wait for provisioning concurrency to be ready
await waitForProvisionedConcurrency(functionName, aliasName, newVersion);

// Now, proceed with deleting the old version of the alias
// You can use whatever method you were using previously to delete the old alias

This approach should ensure that you wait until the provisioning concurrency is set up on the new version before deleting the old version of the alias. It eliminates the need for static waits and provides a more dynamic and efficient solution.