AWS Lambda function to create CloudFront invalidation for CodePipeline

awsLambdaCodePipelineCloudfrontCreateInvalidation.js

const AWS = require('aws-sdk');

const getDistribution = async (client, bucket) => {
  const params = { MaxItems: '100' };
  for (;;) {
    const { DistributionList: { Items: DistributionItems, IsTruncated, NextMarker } } = await client.listDistributions(params).promise();
    if (!DistributionItems) continue;
    for (const distribution of DistributionItems) {
      const { Origins } = distribution
      if (!Origins?.Items) continue;
      for (const { Id } of Origins.Items) {
        if (Id === `S3-${bucket}`) return distribution;
      }
    }
    if (!IsTruncated) break;
    params.Marker = NextMarker;
  }
};

exports.handler = async (event, context) => {
  const codepipeline = new AWS.CodePipeline();
  const jobId = event["CodePipeline.job"].id;
  // Retrieve the AWS bucket name
  // UserParameters from the Lambda action configuration in AWS CodePipeline.
  const bucket = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
  const putJobSuccess = async (message) => {
    const params = {
      jobId: jobId
    };
    return codepipeline
      .putJobSuccessResult(params)
      .promise()
      .then(() => context.succeed(message))
      .catch(err => context.fail(err));
  };
  const putJobFailure = async (message) => {
    const params = {
      jobId: jobId,
      failureDetails: {
        message: JSON.stringify(message),
        type: 'JobFailed',
        externalExecutionId: context.awsRequestId
      }
    };
    return codepipeline.putJobFailureResult(params).promise().finally(() => context.fail(message));
  };

  if (!bucket) {
    await putJobFailure('The UserParameters field must contain a S3 bucket to invalidate');
    return;
  }

  const cloudfront = new AWS.CloudFront();
  let distribution;
  try {
    distribution = await getDistribution(cloudfront, bucket);
  } catch (er) {
    await putJobFailure(er);
    return;
  }

  if (!distribution) {
    await putJobFailure(`Unabled to find distribution for bucket ${bucket}`)
    return;
  }

  await cloudfront
    .createInvalidation({
      DistributionId: distribution.Id,
      InvalidationBatch: {
        CallerReference: Date.now().toString(),
        Paths: {
          Quantity: 1,
          Items: ['/*']
        }
      }
    })
    .promise()
    .then(data =>
      putJobSuccess(`Invalidation created ${data.Invalidation.Id}`)
    )
    .catch(err =>
      putJobFailure(err)
    );
};