Error handling on bucket queries

Thought about error handling for S3 queries for a couple of seconds Below is a concise guide on error handling when querying for JSON files in an S3 bucket using JavaScript (Node.js). We’ll assume you’re using the AWS SDK for JavaScript (v2 or v3). The same principles generally apply to any AWS operation where you need robust error handling.

1. Common Approaches A. Using Promises/async-await In AWS SDK v2, each method (e.g., s3.getObject()) can return a promise if you append .promise(). In AWS SDK v3, methods already return promises.

Example (v2 with .promise()):

const AWS = require('aws-sdk');
const s3 = new AWS.S3();

async function getJsonFile(bucketName, keyName) {
  try {
    const data = await s3
      .getObject({ Bucket: bucketName, Key: keyName })
      .promise();
      
    // Convert data.Body from Buffer to string, then parse as JSON
    const jsonString = data.Body.toString('utf-8');
    return JSON.parse(jsonString);
    
  } catch (error) {
    // Handle error here
    if (error.code === 'NoSuchKey') {
      // The key doesn't exist
      console.error(`File not found: s3://${bucketName}/${keyName}`);
    } else if (error.code === 'AccessDenied') {
      // Permissions issue
      console.error('AccessDenied: Check your IAM policies and bucket ACL.');
    } else {
      // General or unexpected error
      console.error(`Failed to get object: ${error.message}`);
    }
    throw error; // rethrow if you want the caller to handle it
  }
}

(async () => {
  try {
    const result = await getJsonFile('my-bucket', 'path/to/file.json');
    console.log('File contents:', result);
  } catch (err) {
    console.error('Error in main flow:', err);
  }
})();

B. Using Callbacks (AWS SDK v2) If you’re not using Promises or async/await, you can provide a callback. The callback’s first argument is the error object (if any).

const AWS = require('aws-sdk');
const s3 = new AWS.S3();

function getJsonFileCallback(bucketName, keyName, callback) {
  s3.getObject({ Bucket: bucketName, Key: keyName }, (error, data) => {
    if (error) {
      // Error handling
      console.error(`S3 getObject error: ${error.message}`);
      return callback(error);
    }
    try {
      const jsonString = data.Body.toString('utf-8');
      const json = JSON.parse(jsonString);
      callback(null, json);
    } catch (parseErr) {
      console.error(`JSON parse error: ${parseErr.message}`);
      callback(parseErr);
    }
  });
}

// Usage
getJsonFileCallback('my-bucket', 'path/to/file.json', (err, result) => {
  if (err) {
    console.error('Error retrieving file:', err);
  } else {
    console.log('File contents:', result);
  }
});

This callback approach is older style; you’ll see it in legacy code, but many modern Node.js applications prefer Promises/async/await.