Lambda function for Imagemin to optimize JPEGs and PNGs

imagemin-lambda-handler.js

/* 
  Copies Original File to originals/ folder in the same bucket
  Optimizes jpeg/png, writes the optimized jpeg/png in the same path
  If optimized jpeg/png size is somehow greater than the original, optimization is skipped.
  Webp version of the optimized jpeg/png is created and written in webps folder in the same bucket
  If webp version size is greater than optimized jpeg/png, webp write is skipped.

  For preparing imagemin binaries for the lambda runtime environment 
  See https://hub.docker.com/r/rajatbarman/imagemin-lambda

  After optimization it removes all the s3 buckets in your AWS account. (Joking)
*/

const AWS = require('aws-sdk');
const path = require('path');
const util = require('util');
const imagemin = require('imagemin');
const imageminPngquant = require('imagemin-pngquant');
const imageminJpegoptim = require('imagemin-jpegoptim');
const imageminWebp = require('imagemin-webp');
const s3 = new AWS.S3();

function putObject(params, optimizedImageBuffer) {
  return new Promise((resolve, reject) => {
    s3.putObject(params).promise()
      .then((response) => {
        resolve(Object.assign(response, { optimizedImageBuffer }));
      })
      .catch(reject);
  })
}

function getWebpFileName(objectKey) {
  const split = objectKey.split('.');
  return `${split.slice(0, split.length - 1).join('.')}.webp`;
}

function optimizeImageBuffer(response) {
  if (!response) {
    return;
  }
  const plugins = {
    'image/jpeg': [imageminJpegoptim({ max: 80 })],
    'image/png': [imageminPngquant({ quality: [0.8, 0.9] })]
  }[response.ContentType];

  return new Promise((resolve, reject) => {
    imagemin.buffer(response.Body, {
      plugins
    })
    .then((optimizedImageBuffer) => {
      resolve({ optimizedImageBuffer, response });
    })
    .catch(reject);
  });
}

function getWebpImageBuffer(optimizedImageBuffer) {
  if (!optimizedImageBuffer) {
    return;
  }
  return new Promise((resolve, reject) => {
    imagemin.buffer(optimizedImageBuffer, {
      plugins: [imageminWebp()]
    })
    .then((webpImageBuffer) => {
      resolve({ webpImageBuffer, optimizedImageBuffer });
    })
    .catch(reject);
  });
}

function processObject(bucket, objectKey) {
  const absoluteImagePath = `${bucket}/${objectKey}`;
  if (objectKey.indexOf('originals/') !== -1) {
    /* 
      The function is triggered from originals folder 
      Don't do anything
    */
    return;
  }
  console.log('Input: ', absoluteImagePath);

  /* Copy s3 object to originals folder */
  const fetchMetadataParams = {
    Bucket: bucket,
    Key: objectKey,
  };

  const copyParams = {
    Bucket: bucket,
    CopySource: absoluteImagePath,
    Key: `originals/${objectKey}`
  };

  return s3.headObject(fetchMetadataParams).promise()
    .then((response) => {
      if (response.Metadata && response.Metadata.is_processed) {
        return Promise.reject('Already processed');
      }
      return s3.copyObject(copyParams).promise();
    })
    .then(() => {
      console.log('Progress: Copied object to originals folder', absoluteImagePath);
      return s3
        .getObject({ Bucket: bucket, Key: objectKey })
        .promise();
    })
    .then((response) => {
      console.log('Progress: Got the s3 object', absoluteImagePath);
      return optimizeImageBuffer(response);
    })
    .then(({ optimizedImageBuffer, response }) => {
      const optimizedImageLength = Buffer.from(optimizedImageBuffer).length;
      const originalImageLength = Buffer.from(response.Body).length;
      
      if (optimizedImageLength >= originalImageLength) {
        console.log(
          'Error: Optimized Image size is greater than original image size', 
          absoluteImagePath,
          optimizedImageLength,
          originalImageLength
        );
        /* Resolving promise to let the webp process happen */
        return Promise.resolve({ optimizedImageBuffer, error: true });
      }

      console.log('Progress: Optimized Image', absoluteImagePath);
      return putObject({
        Metadata: {
          is_processed: 'true',
        },
        Bucket: bucket,
        Key: objectKey,
        Body: optimizedImageBuffer,
        ContentType: response.ContentType,
      }, optimizedImageBuffer);
    })
    .then(({ optimizedImageBuffer, error }) => {
      if (!error) {
        console.log('Success: Successfully wrote optimized image in s3', absoluteImagePath);
      }
      return getWebpImageBuffer(optimizedImageBuffer);
    })
    .then(({ webpImageBuffer, optimizedImageBuffer }) => {
      const optimizedImageLength = Buffer.from(optimizedImageBuffer).length;
      const webpImageLength = Buffer.from(webpImageBuffer).length;
      if (webpImageLength >= optimizedImageLength) {
        return Promise.reject('Webp image length is greater than jpeg/png length, not writing webp.');
      }
      console.log('Progress: Created Webp Buffer', absoluteImagePath);
      return s3.putObject({
        Bucket: bucket,
        Key: `webps/${getWebpFileName(objectKey)}`,
        Body: webpImageBuffer,
        ContentType: 'image/webp',
      }).promise();
    })
    .then(() => {
      console.log('Success: Successfully wrote webp image in s3', absoluteImagePath);
    })
    .catch((err) => {
      // Failed to copy original object, not proceeding further
      console.log('Error: ', absoluteImagePath, err);
    });
}

module.exports.optimizeImage = event => {
  console.log('Reading options from event:\n', util.inspect(event, { depth: 5 }));
  
  event.Records.forEach(record => {
    const { s3: s3Obj } = record;
    const bucket = s3Obj.bucket.name;
    const objectKey = decodeURIComponent(s3Obj.object.key.replace(/\+/g, ' '));
    processObject(bucket, objectKey);
  });

  return {};
};