User: Task: "Bulk delete Todo Item"
    Description: "Generate a Node.js controller function to create a new todo item using the Mongoose Todo model."
    Requirements:
    - Database: mongoose
    - Authentication: user
    - Output needed: Return only the function code.
    - Dependencies: Create a function to delete multiple todo items. Export the function itself. Function mode: exports.functionName = async () => {...}, 
Accept parameter: an array of ids from the request body., 
Validate required field: Ensure the ids array is provided and not empty., 
Use the Todo model to delete all records in the database that match the provided ids., 
Respond with a success message indicating how many items were deleted., 
Handle errors, such as empty or invalid ids array, and return appropriate error messages.
    - Previous Code 
const mongoose = require('mongoose');
const Todo = require('../models/Todo');
exports.createTodoItem = async (req, res) => {
    try {
        // Extract parameters from the request body
        const { title, description, status, priority, dueDate } = req.body;
        
        // Validate required fields
        if (!title || !status) {
            return res.status(400).json({ error: 'Title and status are required.' });
        }

        // Create a new Todo item using the Todo model
        const newTodo = new Todo({
            title,
            description,
            status,
            priority,
            dueDate
        });

        // Save the new Todo item to the database
        const createdTodo = await newTodo.save();

        // Respond with the created todo details and a success message
        res.status(201).json({
            message: 'Todo item created successfully.',
            todo: createdTodo
        });
    } catch (error) {
        // Handle and return appropriate error messages
        res.status(500).json({ error: 'An error occurred while creating the todo item.' });
    }
};

exports.updateTodoItem = async (req, res) => {
    try {
        // Extract the ID from the URL parameters
        const { id } = req.params;

        // Extract the fields to be updated from the request body
        const { title, description, status, priority, dueDate } = req.body;

        // Validate that the ID is provided
        if (!id || !mongoose.Types.ObjectId.isValid(id)) {
            return res.status(400).json({ error: 'A valid ID is required.' });
        }

        // Validate that required fields (if necessary) are provided
        if (!title && !description && !status && !priority && !dueDate) {
            return res.status(400).json({ error: 'At least one field to update must be provided.' });
        }

        // Construct the update data object
        const updateData = {};
        if (title) updateData.title = title;
        if (description) updateData.description = description;
        if (status) updateData.status = status;
        if (priority) updateData.priority = priority;
        if (dueDate) updateData.dueDate = dueDate;

        // Find the todo item by its ID and update it in the database
        const updatedTodo = await Todo.findByIdAndUpdate(id, updateData, { new: true });

        // Handle the case where the item wasn't found
        if (!updatedTodo) {
            return res.status(404).json({ error: 'Todo item not found.' });
        }

        // Respond with the updated todo details and a success message
        res.status(200).json({
            message: 'Todo item updated successfully.',
            todo: updatedTodo
        });
    } catch (error) {
        // Handle and return appropriate error messages
        res.status(500).json({ error: 'An error occurred while updating the todo item.' });
    }
};

exports.deleteTodoItem = async (req, res) => {
    try {
        // Extract the ID from the URL parameters
        const { id } = req.params;

        // Validate that the ID is provided and is a valid MongoDB ObjectId
        if (!id || !mongoose.Types.ObjectId.isValid(id)) {
            return res.status(400).json({ error: 'A valid ID is required.' });
        }

        // Attempt to find and delete the todo item by its ID
        const deletedTodo = await Todo.findByIdAndDelete(id);

        // Handle the case where the item wasn't found
        if (!deletedTodo) {
            return res.status(404).json({ error: 'Todo item not found.' });
        }

        // Respond with a success message
        res.status(200).json({ message: 'Todo item deleted successfully.' });
    } catch (error) {
        // Handle and return appropriate error messages
        res.status(500).json({ error: 'An error occurred while deleting the todo item.' });
    }
};

exports.bulkDeleteTodoItems = async (req, res) => {
    try {
        // Extract the ids array from the request body
        const { ids } = req.body;
        
        // Validate that the ids array is provided and is not empty
        if (!Array.isArray(ids) || ids.length === 0) {
            return res.status(400).json({ error: 'An array of valid todo item IDs is required.' });
        }

        // Validate each ID in the ids array
        for (const id of ids) {
            if (!mongoose.Types.ObjectId.isValid(id)) {
                return res.status(400).json({ error: `Invalid ID: ${id}. All IDs must be valid MongoDB ObjectIds.` });
            }
        }

        // Use the Todo model to delete all records in the database that match the provided ids
        const result = await Todo.deleteMany({ _id: { $in: ids } });

        // Respond with a success message indicating how many items were deleted
        res.status(200).json({ message: `${result.deletedCount} todo items deleted successfully.` });
    } catch (error) {
        // Handle and return appropriate error messages
        res.status(500).json({ error: 'An error occurred while deleting the todo items.' });
    }
};

    - Supporting data 
    - Updating File "src/controllers/TodoController.js"
    
    Please generate the code for this task, following the instructions and including comments for clarity.
    While creating router for specifict file your have to read supporing file data and create for that 

    **Output Formats**: 

Return dependencies like this `const bcrypt = require('bcrypt');`  in this formate
```dependencies
const bcrypt = require('bcrypt');
```

Ensure this format is consistently followed in responses.
    
User: 


    
Assistant: