Update index.mjs

Author: magenx

lambda/image_optimization/index.mjs

@@ -1,11 +1,10 @@
-
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: MIT-0
 
 import { GetObjectCommand, PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import Sharp from 'sharp';
 
-const s3Client = new S3Client();
+const s3Client = new S3Client({ region: process.env.s3BucketRegion });
 const S3_ORIGINAL_IMAGE_BUCKET = process.env.originalImageBucketName;
 const S3_TRANSFORMED_IMAGE_BUCKET = process.env.transformedImageBucketName;
 const TRANSFORMED_IMAGE_CACHE_TTL = process.env.transformedImageCacheTTL;
@@ -14,94 +13,118 @@ const MAX_IMAGE_SIZE = parseInt(process.env.maxImageSize);
 export const handler = async (event) => {
     // Validate if this is a GET request
     if (!event.requestContext || !event.requestContext.http || !(event.requestContext.http.method === 'GET')) return sendError(400, 'Only GET method is supported', event);
-    // An example of expected path is /images/rio/1.jpeg/format=auto,width=100 or /images/rio/1.jpeg/original where /images/rio/1.jpeg is the path of the original image
-    var imagePathArray = event.requestContext.http.path.split('/');
-    // get the requested image operations
-    var operationsPrefix = imagePathArray.pop();
-    // get the original image path images/rio/1.jpg
-    imagePathArray.shift();
-    var originalImagePath = imagePathArray.join('/');
+
+    // Extracting the path and query parameters
+    const path = event.requestContext.http.path;
+    const queryStringParameters = event.queryStringParameters || {};
+    
+    // The image path from the URL
+    const imagePath = path.startsWith('/') ? path.substring(1) : path;
+
+    // Check if the requested file should be processed or ignored
+    const fileExtension = path.split('.').pop().toLowerCase();
+    const supportedExtensions = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'avif', 'svg'];
+
+    if (!supportedExtensions.includes(fileExtension)) {
+        // If the file is not an image, return a 302 redirect to the original URL
+        return {
+            statusCode: 302,
+            headers: {
+                'Location': path,
+                'Cache-Control': 'no-cache'
+            }
+        };
+    }
+
+    // Extracting operations from query parameters
+    const width = queryStringParameters.width ? parseInt(queryStringParameters.width) : null;
+    const height = queryStringParameters.height ? parseInt(queryStringParameters.height) : null;
+    const format = queryStringParameters['image-type'] || null;
+    const quality = queryStringParameters.quality ? parseInt(queryStringParameters.quality) : null;
 
     var startTime = performance.now();
-    // Downloading original image
     let originalImageBody;
     let contentType;
+    
     try {
-        const getOriginalImageCommand = new GetObjectCommand({ Bucket: S3_ORIGINAL_IMAGE_BUCKET, Key: originalImagePath });
+        const getOriginalImageCommand = new GetObjectCommand({ Bucket: S3_ORIGINAL_IMAGE_BUCKET, Key: imagePath });
         const getOriginalImageCommandOutput = await s3Client.send(getOriginalImageCommand);
-        console.log(`Got response from S3 for ${originalImagePath}`);
+        console.log(`Got response from S3 for ${imagePath}`);
 
-        originalImageBody = getOriginalImageCommandOutput.Body.transformToByteArray();
+        originalImageBody = await getOriginalImageCommandOutput.Body.transformToByteArray();
         contentType = getOriginalImageCommandOutput.ContentType;
     } catch (error) {
         return sendError(500, 'Error downloading original image', error);
     }
-    let transformedImage = Sharp(await originalImageBody, { failOn: 'none', animated: true });
-    // Get image orientation to rotate if needed
+
+    let transformedImage = Sharp(originalImageBody, { failOn: 'none', animated: true });
     const imageMetadata = await transformedImage.metadata();
-    // execute the requested operations 
-    const operationsJSON = Object.fromEntries(operationsPrefix.split(',').map(operation => operation.split('=')));
-    // variable holding the server timing header value
+
     var timingLog = 'img-download;dur=' + parseInt(performance.now() - startTime);
     startTime = performance.now();
+
     try {
-        // check if resizing is requested
-        var resizingOptions = {};
-        if (operationsJSON['width']) resizingOptions.width = parseInt(operationsJSON['width']);
-        if (operationsJSON['height']) resizingOptions.height = parseInt(operationsJSON['height']);
-        if (resizingOptions) transformedImage = transformedImage.resize(resizingOptions);
-        // check if rotation is needed
+        if (width || height) {
+           transformedImage = transformedImage.resize({
+               width: width,
+               height: height,
+               fit: Sharp.fit.inside,
+               withoutEnlargement: true
+            });
+        }
         if (imageMetadata.orientation) transformedImage = transformedImage.rotate();
-        // check if formatting is requested
-        if (operationsJSON['format']) {
+        
+        if (format) {
             var isLossy = false;
-            switch (operationsJSON['format']) {
+            switch (format) {
                 case 'jpeg': contentType = 'image/jpeg'; isLossy = true; break;
                 case 'gif': contentType = 'image/gif'; break;
                 case 'webp': contentType = 'image/webp'; isLossy = true; break;
                 case 'png': contentType = 'image/png'; break;
                 case 'avif': contentType = 'image/avif'; isLossy = true; break;
                 default: contentType = 'image/jpeg'; isLossy = true;
             }
-            if (operationsJSON['quality'] && isLossy) {
-                transformedImage = transformedImage.toFormat(operationsJSON['format'], {
-                    quality: parseInt(operationsJSON['quality']),
-                });
-            } else transformedImage = transformedImage.toFormat(operationsJSON['format']);
+            if (quality && isLossy) {
+                transformedImage = transformedImage.toFormat(format, { quality: quality });
+            } else {
+                transformedImage = transformedImage.toFormat(format);
+            }
         } else {
-            /// If not format is precised, Sharp converts svg to png by default https://github.com/aws-samples/image-optimization/issues/48
             if (contentType === 'image/svg+xml') contentType = 'image/png';
         }
+        
         transformedImage = await transformedImage.toBuffer();
     } catch (error) {
-        return sendError(500, 'error transforming image', error);
+        return sendError(500, 'Error transforming image', error);
     }
+    
     timingLog = timingLog + ',img-transform;dur=' + parseInt(performance.now() - startTime);
-
-    // handle gracefully generated images bigger than a specified limit (e.g. Lambda output object limit)
     const imageTooBig = Buffer.byteLength(transformedImage) > MAX_IMAGE_SIZE;
-
-    // upload transformed image back to S3 if required in the architecture
+    
     if (S3_TRANSFORMED_IMAGE_BUCKET) {
         startTime = performance.now();
         try {
+            const metadata = {
+            'cache-control': TRANSFORMED_IMAGE_CACHE_TTL,
+            'width': width ? width.toString() : 'empty',
+            'height': height ? height.toString() : 'empty',
+            'quality': quality ? quality.toString() : 'empty'
+            };
             const putImageCommand = new PutObjectCommand({
                 Body: transformedImage,
                 Bucket: S3_TRANSFORMED_IMAGE_BUCKET,
-                Key: originalImagePath + '/' + operationsPrefix,
+                Key: imagePath,
                 ContentType: contentType,
-                Metadata: {
-                    'cache-control': TRANSFORMED_IMAGE_CACHE_TTL,
-                },
-            })
+                Metadata: metadata
+            });
             await s3Client.send(putImageCommand);
             timingLog = timingLog + ',img-upload;dur=' + parseInt(performance.now() - startTime);
-            // If the generated image file is too big, send a redirection to the generated image on S3, instead of serving it synchronously from Lambda. 
+            
             if (imageTooBig) {
                 return {
                     statusCode: 302,
                     headers: {
-                        'Location': '/' + originalImagePath + '?' + operationsPrefix.replace(/,/g, "&"),
+                        'Location': '/' + imagePath + '?' + new URLSearchParams(queryStringParameters).toString(),
                         'Cache-Control': 'private,no-store',
                         'Server-Timing': timingLog
                     }
@@ -112,19 +135,20 @@ export const handler = async (event) => {
         }
     }
 
-    // Return error if the image is too big and a redirection to the generated image was not possible, else return transformed image
     if (imageTooBig) {
         return sendError(403, 'Requested transformed image is too big', '');
-    } else return {
-        statusCode: 200,
-        body: transformedImage.toString('base64'),
-        isBase64Encoded: true,
-        headers: {
-            'Content-Type': contentType,
-            'Cache-Control': TRANSFORMED_IMAGE_CACHE_TTL,
-            'Server-Timing': timingLog
-        }
-    };
+    } else {
+        return {
+            statusCode: 200,
+            body: transformedImage.toString('base64'),
+            isBase64Encoded: true,
+            headers: {
+                'Content-Type': contentType,
+                'Cache-Control': TRANSFORMED_IMAGE_CACHE_TTL,
+                'Server-Timing': timingLog
+            }
+        };
+    }
 };
 
 function sendError(statusCode, body, error) {