Cloud storage integration concept in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when uploading a file using Express with Multer and AWS S3?

Consider this Express route that uses Multer middleware to handle file uploads and then uploads the file to AWS S3. What is the expected behavior after a successful upload?

Express

const express = require('express');
const multer = require('multer');
const AWS = require('aws-sdk');
const app = express();
const upload = multer({ storage: multer.memoryStorage() });
const s3 = new AWS.S3();

app.post('/upload', upload.single('file'), async (req, res) => {
  const params = {
    Bucket: 'my-bucket',
    Key: req.file.originalname,
    Body: req.file.buffer
  };
  try {
    await s3.upload(params).promise();
    res.status(200).send('File uploaded successfully');
  } catch (err) {
    res.status(500).send('Upload failed');
  }
});

A The file is stored in memory temporarily, then uploaded to the S3 bucket with the original filename, and the client receives a success message.

B The file is saved to disk first, then uploaded to S3, and the client receives the file URL in the response.

C The file is uploaded directly to S3 without being processed by Multer, and the client receives an error.

D The file is stored in memory but never uploaded to S3, and the client receives a timeout error.

💡 Hint

Think about how Multer's memoryStorage works and what the AWS S3 upload method expects.

Multer with memoryStorage keeps the file in memory as a buffer. The AWS S3 upload method uses this buffer to upload the file to the specified bucket with the original filename. If successful, the client gets a success message.

📝 Syntax

intermediate

Identify the syntax error in this Express route integrating Google Cloud Storage

Which option correctly fixes the syntax error in this Express route that uploads a file to Google Cloud Storage?

Express

const express = require('express');
const {Storage} = require('@google-cloud/storage');
const multer = require('multer');
const app = express();
const storage = new Storage();
const bucket = storage.bucket('my-bucket');
const upload = multer({ storage: multer.memoryStorage() });

app.post('/upload', upload.single('file'), async (req, res) => {
  const blob = bucket.file(req.file.originalname);
  const blobStream = blob.createWriteStream();

  blobStream.on('error', (err) => {
    res.status(500).send(err.message);
  });

  blobStream.on('finish', () => {
    res.status(200).send('Upload complete');
  });

  blobStream.end(req.file.buffer);
});

A Add a return statement before res.status(200).send('Upload complete') to fix the missing return error.

B Change blobStream.end(req.file.buffer) to blobStream.write(req.file.buffer) to fix the stream usage.

C Add a semicolon after bucket.file(req.file.originalname) to fix the missing semicolon error.

D Add async keyword to the callback function to fix the missing async error.

💡 Hint

Look carefully at the line that creates the blob variable.

The line creating the blob variable is missing a semicolon, which causes a syntax error. Adding the semicolon fixes the syntax issue. The other options do not address syntax errors.

🔧 Debug

advanced

Why does this Express app fail to upload files to Azure Blob Storage?

Given this Express route, why does the file upload to Azure Blob Storage fail with a 500 error?

Express

const express = require('express');
const multer = require('multer');
const { BlobServiceClient } = require('@azure/storage-blob');
const app = express();
const upload = multer({ storage: multer.memoryStorage() });
const blobServiceClient = BlobServiceClient.fromConnectionString(process.env.AZURE_CONN_STRING);
const containerClient = blobServiceClient.getContainerClient('my-container');

app.post('/upload', upload.single('file'), async (req, res) => {
  try {
    const blockBlobClient = containerClient.getBlockBlobClient(req.file.originalname);
    await blockBlobClient.upload(req.file.buffer, req.file.buffer.length);
    res.status(200).send('Upload successful');
  } catch (error) {
    res.status(500).send('Upload failed');
  }
});

A The container name 'my-container' is invalid and causes the upload to fail.

B The upload method requires the buffer length as a second argument, which is missing.

C Multer's memoryStorage does not provide a buffer, so req.file.buffer is undefined.

D The BlobServiceClient is not initialized correctly without a SAS token.

💡 Hint

Check the Azure Blob Storage SDK documentation for the upload method signature.

The Azure Blob Storage upload method requires two arguments: the data buffer and its length. Omitting the length causes the upload to fail. Adding req.file.buffer.length as the second argument fixes the issue.

❓ state_output

advanced

What is the output of this Express route using AWS S3 upload with callback?

What response does the client receive when this Express route uploads a file to AWS S3 using a callback?

Express

const express = require('express');
const multer = require('multer');
const AWS = require('aws-sdk');
const app = express();
const upload = multer({ storage: multer.memoryStorage() });
const s3 = new AWS.S3();

app.post('/upload', upload.single('file'), (req, res) => {
  const params = {
    Bucket: 'my-bucket',
    Key: req.file.originalname,
    Body: req.file.buffer
  };
  s3.upload(params, (err, data) => {
    if (err) {
      res.status(500).send('Upload error');
    }
  });
  res.status(200).send('Upload started');
});

A The client immediately receives 'Upload started' before the upload finishes.

B The client receives 'Upload error' if the upload fails, otherwise 'Upload started'.

C The client waits until the upload finishes and then receives 'Upload started'.

D The client never receives a response because res.send is called twice.

💡 Hint

Consider the asynchronous nature of the s3.upload callback and when res.send is called.

The res.status(200).send('Upload started') is called immediately after s3.upload is initiated, without waiting for the callback. So the client gets this message right away. The callback's res.send is never called, which can cause issues but does not affect this immediate response.

🧠 Conceptual

expert

Which option best describes the advantage of using signed URLs for cloud storage uploads in Express?

When integrating cloud storage with Express, what is the main benefit of generating signed URLs for clients to upload files directly?

A It enables the server to store files temporarily before forwarding them to cloud storage.

B It encrypts the files automatically during upload to enhance security.

C It allows the Express server to validate file contents before upload to cloud storage.

D It reduces server load by allowing clients to upload files directly to cloud storage without passing through the Express server.

💡 Hint

Think about how signed URLs change the upload flow between client, server, and cloud storage.

Signed URLs let clients upload files directly to cloud storage, bypassing the Express server. This reduces server bandwidth and processing load. The other options describe unrelated or incorrect benefits.

Practice

1. What is the main purpose of integrating cloud storage with an Express app?

easy

A. To store Express app logs locally

B. To speed up the Express server response time

C. To replace the Express router functionality

D. To save and share files online safely

Solution

1. Step 1: Understand cloud storage role

   Cloud storage is used to save files online so they can be accessed safely from anywhere.

2. Step 2: Relate to Express app integration

   Integrating cloud storage with Express allows the app to upload and store files securely in the cloud.

3. Final Answer:

   To save and share files online safely -> Option D

4. Quick Check:

   Cloud storage = safe online file saving [OK]

Hint: Cloud storage means saving files online safely [OK]

Common Mistakes:

• Thinking cloud storage speeds up server response
• Confusing cloud storage with routing features
• Assuming cloud storage is for local logs

2. Which middleware is commonly used in Express to handle file uploads before sending to cloud storage?

easy

A. body-parser

B. cors

C. multer

D. helmet

Solution

1. Step 1: Identify middleware for file uploads

   Multer is a popular Express middleware designed specifically to handle multipart/form-data, which is used for uploading files.

2. Step 2: Confirm other options' roles

   Cors handles cross-origin requests, body-parser parses JSON or urlencoded data, helmet adds security headers. None handle file uploads.

3. Final Answer:

   multer -> Option C

4. Quick Check:

   File upload middleware = multer [OK]

Hint: Multer handles file uploads in Express [OK]

Common Mistakes:

• Choosing cors for file uploads
• Confusing body-parser with file upload handling
• Selecting helmet which is for security headers

3. Given this Express snippet using multer and AWS SDK, what will be the output if the upload succeeds?

const upload = multer({ dest: 'uploads/' });
app.post('/upload', upload.single('file'), async (req, res) => {
  const params = { Bucket: 'mybucket', Key: req.file.filename, Body: fs.createReadStream(req.file.path) };
  await s3.upload(params).promise();
  res.send('Upload successful');
});

medium

A. SyntaxError: Unexpected token

B. Upload successful

C. Error: Missing file parameter

D. Upload failed due to AWS credentials

Solution

1. Step 1: Analyze multer usage

   Multer saves the uploaded file to 'uploads/' and adds file info to req.file, so req.file.filename and req.file.path exist.

2. Step 2: Check AWS upload call

   The s3.upload call uses the file stream correctly and awaits the promise, so if AWS credentials are correct, upload succeeds.

3. Final Answer:

   Upload successful -> Option B

4. Quick Check:

   Correct multer + AWS upload = success message [OK]

Hint: If multer and AWS upload succeed, response is success message [OK]

Common Mistakes:

• Assuming syntax error due to async/await
• Forgetting multer adds req.file
• Ignoring AWS credentials setup

4. Identify the error in this Express route for uploading to Google Cloud Storage:

app.post('/upload', upload.single('file'), (req, res) => {
  const bucket = storage.bucket('mybucket');
  bucket.upload(req.file.path, (err, file) => {
    if (err) res.status(500).send('Upload error');
  });
  res.send('File uploaded');
});

medium

A. Missing await or callback handling before sending response

B. Incorrect bucket name syntax

C. upload.single should be upload.array

D. req.file.path is undefined

Solution

1. Step 1: Check asynchronous upload call

   bucket.upload is asynchronous with a callback, but res.send is called immediately after, not waiting for upload to finish.

2. Step 2: Understand response timing

   Sending response before upload completes can cause wrong success message even if upload fails.

3. Final Answer:

   Missing await or callback handling before sending response -> Option A

4. Quick Check:

   Async upload must finish before response [OK]

Hint: Wait for async upload before sending response [OK]

Common Mistakes:

• Sending response immediately without waiting
• Assuming bucket name syntax is wrong
• Confusing single vs array upload middleware

5. You want to upload multiple files from an Express app to Azure Blob Storage and keep track of their URLs. Which approach correctly handles this scenario? const upload = multer({ dest: 'uploads/' }); app.post('/upload-multiple', upload.array('files'), async (req, res) => { const urls = []; for (const file of req.files) { const blobClient = containerClient.getBlockBlobClient(file.filename); await blobClient.uploadFile(file.path); urls.push(blobClient.url); } res.json({ uploadedUrls: urls }); });

hard

A. Uploads files sequentially, collects URLs, then responds with JSON list

B. Uploads files but responds before uploads finish

C. Uses upload.single instead of upload.array for multiple files

D. Does not push URLs to array, so response is empty

Solution

1. Step 1: Check multer usage for multiple files

   upload.array('files') correctly handles multiple files and stores them in req.files array.

2. Step 2: Analyze upload loop and response

   The for loop uses await to upload each file sequentially, pushes each URL to the urls array, then sends JSON response with all URLs.

3. Final Answer:

   Uploads files sequentially, collects URLs, then responds with JSON list -> Option A

4. Quick Check:

   Sequential upload + URL collection = correct response [OK]

Hint: Use upload.array and await loop to collect URLs before response [OK]

Common Mistakes:

• Using upload.single for multiple files
• Responding before uploads finish
• Forgetting to collect URLs in array