How can I optimize resource availability checks in my booking system?

Below is an approach that minimizes unnecessary checks by pre-indexing and sorting your bookings per resource. This lets you quickly search for conflicts (for example, via binary search) rather than checking every single booking for a given resource on every request.

1. Pre-Indexing Bookings

Build a map where each resource ID maps to its sorted bookings array. This way, you avoid filtering the entire booking list for every resource during a booking request.

JAVASCRIPTCopied
// Create a map with resourceId as key and an array of its bookings as value
const resourceBookingsMap = {};

// Initialize the map for each resource
for (const resource of resourceList) {
  resourceBookingsMap[resource.resourceId] = [];
}

// Populate the map using bookingList
for (const booking of bookingList) {
  if (!resourceBookingsMap[booking.resourceId]) {
    resourceBookingsMap[booking.resourceId] = [];
  }
  resourceBookingsMap[booking.resourceId].push({
    start: new Date(booking.startDate),
    end: new Date(booking.endDate)
  });
}

// Sort the booking arrays by start date (helps with binary search later)
for (const id in resourceBookingsMap) {
  resourceBookingsMap[id].sort((a, b) => a.start - b.start);
}

2. Efficient Overlap Check via Binary Search

When checking for a conflict, use a binary search on the sorted booking intervals to pinpoint potential conflicts quickly. The idea is to stop as soon as you find a booking that overlaps the requested interval.

JAVASCRIPTCopied
/**
 * Checks if the requested interval (reqStart, reqEnd) is free in a sorted bookings array.
 * Returns true if no overlap is detected.
 */
function isIntervalAvailable(bookings, reqStart, reqEnd) {
  if (!bookings || bookings.length === 0) return true;

  let left = 0;
  let right = bookings.length - 1;

  // Binary search to locate a potential conflict
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    const booking = bookings[mid];

    // If the current booking ends before the requested start, search right
    if (booking.end < reqStart) {
      left = mid + 1;
    } 
    // If the current booking starts after the requested end, search left
    else if (booking.start > reqEnd) {
      right = mid - 1;
    } 
    else {
      // Overlap detected
      return false;
    }
  }

  return true;
}

3. Using the Optimized Logic for Checking Resource Availability

With the pre-indexed and sorted bookings plus the binary search logic, your booking request check becomes more efficient:

JAVASCRIPTCopied
// Requested dates
const reqStart = new Date("2025-01-15");
const reqEnd = new Date("2025-01-19");

let availableResources = [];
let newBookings = [];
const requiredResources = 1; // Example: needing only one resource

for (const resource of resourceList) {
  // Only check resources marked as "Booked" (or adjust condition as needed)
  if (resource.status === "Booked" && availableResources.length < requiredResources) {
    const bookings = resourceBookingsMap[resource.resourceId];
    if (isIntervalAvailable(bookings, reqStart, reqEnd)) {
      availableResources.push(resource.resourceId);
      newBookings.push({
        resourceId: resource.resourceId,
        startDate: reqStart.toISOString().split("T")[0],
        endDate: reqEnd.toISOString().split("T")[0],
      });
    }
  }
}

Summary

• Pre-Indexing: Building a map reduces the need to filter through all bookings repeatedly.
• Sorting: With sorted bookings per resource, you can apply faster techniques (like binary search) to check date overlaps.
• Binary Search: Quickly finds conflicts in a sorted array without iterating over every booking.

These optimizations should help you reduce unnecessary checks and improve performance as your resources and bookings scale.