User: Task: "Create Handle Recurring Bookings Api"
    Description: "Generate a Node.js Handle Recurring Bookings Api with given dependenceis"
    Requirements:
    - Database: mongoose
    - Authentication: None specified
    - Output needed: Return only the function code as specified in dependencies
    - Dependencies: Create a function to manage recurring bookings. Export: exports.createRecurringBooking = async () => {...}, 
Accept parameters: startDate, endDate, frequency (e.g., weekly, monthly), roomId., 
Validate required fields: Ensure startDate, endDate, frequency, and roomId are provided., 
Use a scheduling library (e.g., node-cron) to generate recurring booking dates based on the frequency., 
Check availability for each recurring date using the checkAvailability function., 
Create bookings for each recurring date and link them to the same user or service., 
Respond with a success message containing the booking details for each occurrence., 
Handle errors like conflicting bookings, invalid parameters, or database issues.
    - Previous Code 
const mongoose = require('mongoose');
const Booking = require('./models/Booking'); // Assuming Booking model is in models/Booking.js

exports.checkAvailability = async (checkInDate, checkOutDate, roomId) => {
  // Validate required fields
  if (!checkInDate || !checkOutDate || !roomId) {
    throw new Error("Missing required parameters: checkInDate, checkOutDate, roomId are required.");
  }

  // Convert dates to proper Date objects
  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  // Validate date formats
  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }
  
  try {
    // Query the Booking model to find existing bookings within date range
    const existingBookings = await Booking.find({
      roomId: roomId,
      $or: [
        { checkInDate: { $lt: checkOut, $gte: checkIn } },
        { checkOutDate: { $gt: checkIn, $lte: checkOut } },
        { checkInDate: { $lte: checkIn }, checkOutDate: { $gte: checkOut } }
      ]
    });

    // Ensure no double booking
    if (existingBookings.length > 0) {
      return { available: false, message: "Room/service is already booked for these dates." };
    }

    // If no conflicting bookings found
    return { available: true, message: "Room/service is available for booking." };

  } catch (error) {
    // Handle database connection errors
    throw new Error("Database error: " + error.message);
  }
};

exports.manageTimeSlots = async ({ date, serviceId, availableSlots }) => {
  // Validate required fields
  if (!date || !serviceId || !Array.isArray(availableSlots) || availableSlots.length === 0) {
    throw new Error("Missing required parameters: date, serviceId, and availableSlots are required.");
  }

  // Convert date to a Date object
  const validDate = new Date(date);
  if (isNaN(validDate.getTime())) {
    throw new Error("Invalid date format provided.");
  }

  try {
    // Check for overlapping slots
    const overlappingSlots = await TimeSlot.find({
      serviceId: serviceId,
      date: validDate,
      time: { $in: availableSlots }
    });

    if (overlappingSlots.length > 0) {
      throw new Error("Some time slots are overlapping with existing bookings.");
    }

    // Create or update time slots
    await Promise.all(availableSlots.map(async (slot) => {
      await TimeSlot.updateOne(
        { serviceId: serviceId, date: validDate, time: slot },
        { $set: { serviceId, date: validDate, time: slot } },
        { upsert: true }
      );
    }));

    return { success: true, message: "Available time slots have been successfully managed." };

  } catch (error) {
    // Handle database errors
    throw new Error("Database error: " + error.message);
  }
};

exports.createRecurringBooking = async ({ startDate, endDate, frequency, roomId }) => {
  // Validate required fields
  if (!startDate || !endDate || !frequency || !roomId) {
    throw new Error("Missing required parameters: startDate, endDate, frequency, roomId are required.");
  }

  // Convert input dates to Date objects
  const start = new Date(startDate);
  const end = new Date(endDate);

  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  // Function to determine the next booking date based on frequency
  const getNextBookingDate = (currentDate) => {
    switch (frequency) {
      case 'weekly':
        return new Date(currentDate.setDate(currentDate.getDate() + 7));
      case 'monthly':
        return new Date(currentDate.setMonth(currentDate.getMonth() + 1));
      default:
        throw new Error("Invalid frequency. Supported values are: weekly, monthly.");
    }
  };

  try {
    let currentBookingDate = new Date(start);
    const bookings = [];

    // Loop through the dates based on the frequency until end date is reached
    while (currentBookingDate <= end) {
      // Check availability for the current booking date
      const { available, message } = await exports.checkAvailability(currentBookingDate, new Date(currentBookingDate), roomId);

      if (!available) {
        throw new Error(`Conflict: ${message} on ${currentBookingDate.toISOString().split('T')[0]}`);
      }

      // Create booking for the current date
      const booking = new Booking({
        checkInDate: currentBookingDate,
        checkOutDate: new Date(currentBookingDate), // assuming single-day booking for simplicity
        roomId
      });
      await booking.save();

      bookings.push(booking);

      // Get the next booking date
      currentBookingDate = getNextBookingDate(currentBookingDate);
    }

    return { success: true, bookings, message: "All recurring bookings have been successfully created." };

  } catch (error) {
    // Handle errors
    throw new Error("Error creating recurring bookings: " + error.message);
  }
};

// Exported async function to add a user to the waitlist
exports.addToWaitlist = async (userId, checkInDate, checkOutDate, roomId) => {
  // Step 1: Validate required fields
  if (!userId || !checkInDate || !checkOutDate || !roomId) {
    throw new Error("Missing required parameters: userId, checkInDate, checkOutDate, and roomId are required.");
  }

  // Step 2: Convert dates to Date objects
  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  // Step 3: Validate date formats
  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  try {
    // Step 4: Query Bookings to check if requested date is fully booked
    const existingBookings = await Booking.find({
      roomId: roomId,
      $or: [
        { checkInDate: { $lt: checkOut, $gte: checkIn } },
        { checkOutDate: { $gt: checkIn, $lte: checkOut } },
        { checkInDate: { $lte: checkIn }, checkOutDate: { $gte: checkOut } }
      ]
    });

    if (existingBookings.length === 0) {
      return { message: "Room/service is available. You don't need to join the waitlist." };
    }

    // Step 5: Add user to the waitlist
    const priorityLevel = existingBookings.length + 1;
    const newWaitlistEntry = new Waitlist({
      userId: userId,
      checkInDate: checkIn,
      checkOutDate: checkOut,
      roomId: roomId,
      priorityLevel: priorityLevel
    });

    await newWaitlistEntry.save();

    // Step 6: Respond with success message
    return { success: true, message: "User has been successfully added to the waitlist." };

  } catch (error) {
    // Handle potential errors such as database issues
    throw new Error("Error adding user to waitlist: " + error.message);
  }
};

    - Supporting data 
    - Updating File undefined
    
    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: