Deleting documents in Express - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when this Express route deletes a document?

Consider this Express route that deletes a user by ID from a MongoDB collection using Mongoose. What will the client receive if the user is successfully deleted?

Express

app.delete('/users/:id', async (req, res) => {
  try {
    const result = await User.findByIdAndDelete(req.params.id);
    if (!result) {
      return res.status(404).send('User not found');
    }
    res.send('User deleted');
  } catch (error) {
    res.status(500).send('Server error');
  }
});

A The client receives a JSON object with the deleted user data.

B The client always receives 'User deleted' regardless of user existence.

C The client receives a 404 error even if the user was deleted.

D The client receives 'User deleted' if the user existed and was deleted.

💡 Hint

Look at the condition checking if result is null or not.

The code checks if result is null, which means no user was found. Only if a user was found and deleted does it send 'User deleted'.

📝 Syntax

intermediate

Which option correctly deletes a document by ID in Express with Mongoose?

Choose the correct syntax to delete a document by ID using Mongoose in an Express route.

Express

app.delete('/items/:id', async (req, res) => {
  // delete code here
});

A await Item.findByIdAndRemove(req.params.id); res.send('Deleted');

B await Item.deleteById(req.params.id); res.send('Deleted');

C await Item.deleteOne({_id: req.params.id}); res.send('Deleted');

D await Item.remove({_id: req.params.id}); res.send('Deleted');

💡 Hint

Check the official Mongoose method names for deleting by ID.

findByIdAndRemove is the correct Mongoose method to delete a document by its ID. deleteById does not exist. deleteOne works but requires a filter object. remove is deprecated.

🔧 Debug

advanced

Why does this delete route always return 'User deleted' even if no user exists?

Look at this Express route code. It always sends 'User deleted' even if the user ID does not exist in the database. What is the bug?

Express

app.delete('/users/:id', async (req, res) => {
  try {
    await User.findByIdAndDelete(req.params.id);
    res.send('User deleted');
  } catch (error) {
    res.status(500).send('Server error');
  }
});

A The route should use findOneAndDelete instead of findByIdAndDelete.

B The catch block should send 'User deleted' instead of 'Server error'.

C The code does not check if the user was found before sending the response.

D The route is missing async keyword before the callback.

💡 Hint

Think about what findByIdAndDelete returns when no document is found.

findByIdAndDelete returns null if no document matches. The code does not check this and always sends 'User deleted'.

❓ state_output

advanced

What is the value of deletedCount after this delete operation?

Given this Mongoose delete operation, what will deletedCount be if the document with the given ID exists?

Express

const result = await User.deleteOne({_id: req.params.id});
const deletedCount = result.deletedCount;

A null

B 1

C undefined

D 0

💡 Hint

Check the Mongoose deleteOne result object properties.

If a document is deleted, deletedCount is 1. If none deleted, it is 0.

🧠 Conceptual

expert

Which Express middleware pattern best handles errors during document deletion?

When deleting documents in Express routes, which pattern is best to catch and handle errors globally?

A Use try-catch inside each route and call <code>next(error)</code> on catch to pass errors to error middleware.

B Use only <code>res.status(500).send()</code> inside catch blocks without calling <code>next()</code>.

C Wrap all routes in <code>Promise.resolve()</code> to catch errors automatically.

D Ignore errors and rely on Express default error handler.

💡 Hint

Think about how Express error middleware works with next().

Calling next(error) inside catch blocks passes errors to centralized error middleware, which is best practice for maintainability.

Practice

1. What does the deleteOne() method do in Express when working with a database?

easy

A. Deletes a single document that matches the filter criteria.

B. Deletes all documents in the collection.

C. Updates a document instead of deleting it.

D. Finds a document but does not delete it.

Solution

1. Step 1: Understand deleteOne() purpose

   The deleteOne() method removes only one document that matches the given filter.

2. Step 2: Compare with other methods

   deleteMany() deletes multiple documents, and find() only retrieves data without deleting.

3. Final Answer:

   Deletes a single document that matches the filter criteria. -> Option A

4. Quick Check:

   deleteOne() = deletes one document [OK]

Hint: Remember: deleteOne removes just one matching document [OK]

Common Mistakes:

• Confusing deleteOne with deleteMany
• Thinking deleteOne updates documents
• Assuming deleteOne finds but does not delete

2. Which of the following is the correct syntax to delete a document by its ID using Mongoose in Express?

easy

A. Model.findByIdAndDelete(id, callback);

B. Model.deleteById(id);

C. Model.removeById(id);

D. Model.deleteOneById(id);

Solution

1. Step 1: Recall Mongoose method for deleting by ID

   The correct method is findByIdAndDelete() which deletes a document by its ID.

2. Step 2: Check syntax correctness

   Only Model.findByIdAndDelete(id, callback); matches the official Mongoose syntax.

3. Final Answer:

   Model.findByIdAndDelete(id, callback); -> Option A

4. Quick Check:

   Use findByIdAndDelete to delete by ID [OK]

Hint: Use findByIdAndDelete to remove by ID [OK]

Common Mistakes:

• Using non-existent methods like deleteById
• Confusing deleteOne with findByIdAndDelete
• Missing callback or async handling

3. What will be the output of this code snippet in Express using Mongoose?

Model.deleteMany({ status: 'inactive' })
  .then(result => console.log(result.deletedCount))
  .catch(err => console.error(err));

medium

A. An error because deleteMany does not return deletedCount.

B. The entire deleted documents array.

C. Number of documents deleted with status 'inactive'.

D. Undefined because deleteMany returns nothing.

Solution

1. Step 1: Understand deleteMany return value

   deleteMany() returns an object with deletedCount indicating how many documents were deleted.

2. Step 2: Analyze the console.log statement

   The code logs result.deletedCount, so it outputs the number of deleted documents matching the filter.

3. Final Answer:

   Number of documents deleted with status 'inactive'. -> Option C

4. Quick Check:

   deleteMany() returns deletedCount [OK]

Hint: deleteMany returns deletedCount in result object [OK]

Common Mistakes:

• Expecting deleted documents array
• Assuming deleteMany returns nothing
• Confusing deletedCount with total documents

4. Identify the error in this Express Mongoose code snippet for deleting a document:

Model.deleteOne({ _id: id }, (err, doc) => {
  if (err) console.log(err);
  else console.log(doc);
});

medium

A. The filter object is missing required fields.

B. The deleteOne method does not accept a callback.

C. The method should be deleteMany to delete one document.

D. The callback parameter doc should be result to access deletion info.

Solution

1. Step 1: Check callback parameters for deleteOne

   The second callback parameter is a result object, not the deleted document itself.

2. Step 2: Understand what doc represents

   It should be named result or similar to reflect it contains deletion info like deletedCount, not the document.

3. Final Answer:

   The callback parameter doc should be result to access deletion info. -> Option D

4. Quick Check:

   Callback gets result info, not deleted doc [OK]

Hint: Callback second param is result info, not deleted doc [OK]

Common Mistakes:

• Expecting deleted document in callback
• Using deleteMany when only one document needed
• Assuming deleteOne does not accept callbacks

5. You want to delete all documents where the field active is false, but only if the user confirms. Which Express code snippet correctly handles this with error checking?

hard

A. Model.deleteMany({ active: false }, (err, res) => {
if (err) throw err;
console.log(res);
});

B. if(confirm) {
Model.deleteMany({ active: false })
.then(res => console.log(`${res.deletedCount} deleted`))
.catch(err => console.error(err));
}

C. if(confirm) {
Model.deleteOne({ active: false })
.then(res => console.log(res))
.catch(err => console.error(err));
}

D. Model.deleteMany({ active: false })
.then(res => console.log(res.deletedCount))
.catch(err => console.error(err));

Solution

1. Step 1: Check user confirmation before deleting

   if(confirm) { Model.deleteMany({ active: false }) .then(res => console.log(`${res.deletedCount} deleted`)) .catch(err => console.error(err)); } uses an if(confirm) check to ensure deletion only happens after user confirmation.

2. Step 2: Verify deletion and error handling

   It uses deleteMany to delete all matching documents, logs the count, and catches errors properly.

3. Final Answer:

   if(confirm) { Model.deleteMany({ active: false }) .then(res => console.log(`${res.deletedCount} deleted`)) .catch(err => console.error(err)); } -> Option B

4. Quick Check:

   Confirm before delete, handle errors [OK]

Hint: Check confirm before deleteMany, handle errors in promise [OK]

Common Mistakes:

• Using deleteOne instead of deleteMany for multiple docs
• Not checking user confirmation before deleting
• Throwing errors instead of catching them