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 to user with a success message containing the booking details for each occurrence., 
Handle errors like conflicting bookings, invalid parameters, or database issues.
    - Previous Code 
// Dependencies
const mongoose = require('mongoose');
const Booking = require('../models/Booking'); // Assuming Booking model is in models/Booking.js

// Exported function to check room/service availability
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 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 check for existing bookings during the specified 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);
  }
// Exported function to manage time slots
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
    const results = await Promise.all(availableSlots.map(async (slot) => {
      return await TimeSlot.updateOne(
        { serviceId: serviceId, date: validDate, time: slot },
        { $set: { serviceId, date: validDate, time: slot } },
        { upsert: true }
      );
    }));

    // Check if all updates/inserts were successful
    if (results.every(result => result.ok)) {
      return { success: true, message: "Available time slots have been successfully managed." };
    } else {
      throw new Error("Some time slots could not be managed due to database issues.");
    }
  } 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);
  }
};

exports.createRecurringBooking = async ({ startDate, endDate, frequency, roomId }) => {
  // Validate required fields
  if (!startDate || !endDate || !frequency || !roomId) {
    throw new Error("Missing required parameters: startDate, endDate, frequency, and 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.");
  }

  // Determine frequency interval
  const getFrequencyInterval = (frequency) => {
    switch (frequency) {
      case 'weekly':
        return 7; // 7 days for weekly
      case 'monthly':
        return 30; // Approximate average of 30 days for monthly
      default:
        throw new Error("Invalid frequency. Supported values are: weekly, monthly.");
    }
  };

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

    // Loop through the dates based on the frequency until end date is reached
    while (currentBookingDate <= end) {
      const checkOutDate = new Date(currentBookingDate);
      checkOutDate.setDate(checkOutDate.getDate() + intervalDays);

      // Check availability for the current booking date
      const { available, message } = await exports.checkAvailability(currentBookingDate, checkOutDate, 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,
        roomId
      });
      await booking.save();
      
      bookings.push(booking);

      // Move to the next booking date
      currentBookingDate.setDate(currentBookingDate.getDate() + intervalDays);
    }

    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);
  }
};

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

  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }
  
  try {
    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 { available: false, message: "Room/service is already booked for these dates." };
    }

    return { available: true, message: "Room/service is available for booking." };

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

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

  const start = new Date(startDate);
  const end = new Date(endDate);

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

  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 = [];

    while (currentBookingDate <= end) {
      const { available, message } = await exports.checkAvailability(currentBookingDate, currentBookingDate, roomId);

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

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

      bookings.push(booking);

      currentBookingDate = getNextBookingDate(currentBookingDate);
    }

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

  } catch (error) {
    throw new Error("Error creating recurring bookings: " + 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: