// First, query clusters for the specified location

    // Query clusters with a LEFT JOIN on recording patterns to avoid N+1 queries

    const clusterResults = await db.select({

    const joinedResults = await db.select({
      // Cluster fields

      sampleRate: cluster.sampleRate

      sampleRate: cluster.sampleRate,
      // Recording pattern fields
      recordS: cyclicRecordingPattern.recordS,
      sleepS: cyclicRecordingPattern.sleepS

    .where(eq(cluster.locationId, locationId));

    .leftJoin(
      cyclicRecordingPattern, 
      eq(cluster.cyclicRecordingPatternId, cyclicRecordingPattern.id)
    )
    .where(eq(cluster.locationId, locationId))
    .orderBy(cluster.name);

    console.log("Found", clusterResults.length, "clusters for location", locationId);

    console.log("Found", joinedResults.length, "clusters for location", locationId);

    // For each cluster, fetch its cyclic recording pattern if it has one
    const enrichedResults = await Promise.all(
      clusterResults.map(async (clusterData) => {
        if (clusterData.cyclicRecordingPatternId) {
          try {
            // Fetch the recording pattern
            const recordingPattern = await db.select({
              recordS: cyclicRecordingPattern.recordS,
              sleepS: cyclicRecordingPattern.sleepS
            })
            .from(cyclicRecordingPattern)
            .where(eq(cyclicRecordingPattern.id, clusterData.cyclicRecordingPatternId))
            .then(results => results[0]);
            
            // Add the recording pattern details to the cluster data
            return {
              ...clusterData,
              recordingPattern: recordingPattern || null
            };
          } catch (patternError) {
            console.error("Error fetching recording pattern for cluster:", clusterData.id, patternError);
            // Return cluster without pattern data if there was an error
            return {
              ...clusterData,
              recordingPattern: null
            };
          }
        } else {
          // Return cluster without pattern data if it doesn't have a pattern ID
          return {
            ...clusterData,
            recordingPattern: null
          };
        }
      })
    );

    // Transform results to match the expected structure
    const enrichedResults = joinedResults.map(row => ({
      id: row.id,
      datasetId: row.datasetId,
      locationId: row.locationId,
      name: row.name,
      description: row.description,
      createdBy: row.createdBy,
      createdAt: row.createdAt,
      lastModified: row.lastModified,
      modifiedBy: row.modifiedBy,
      active: row.active,
      timezoneId: row.timezoneId,
      cyclicRecordingPatternId: row.cyclicRecordingPatternId,
      sampleRate: row.sampleRate,
      recordingPattern: (row.recordS !== null && row.sleepS !== null) ? {
        recordS: row.recordS,
        sleepS: row.sleepS
      } : null
    }));