Many an update!

server/api/events/[id]/calendar.get.js

@@ -0,0 +1,103 @@
+import Event from "../../../models/event";
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Event ID is required",
+    });
+  }
+
+  try {
+    // Find event by ID or slug
+    const eventData = await Event.findOne({
+      $or: [{ _id: id }, { slug: id }],
+      isVisible: true,
+      isCancelled: { $ne: true },
+    }).select("title slug description startDate endDate location");
+
+    if (!eventData) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Event not found",
+      });
+    }
+
+    // Generate iCal format for single event
+    const ical = generateSingleEventCalendar(eventData);
+
+    // Set headers for download
+    const filename = `${eventData.slug || eventData._id}.ics`;
+    setHeader(event, "Content-Type", "text/calendar; charset=utf-8");
+    setHeader(
+      event,
+      "Content-Disposition",
+      `attachment; filename="${filename}"`
+    );
+    setHeader(event, "Cache-Control", "no-cache");
+
+    return ical;
+  } catch (error) {
+    console.error("Error generating event calendar:", error);
+
+    if (error.statusCode) {
+      throw error;
+    }
+
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to generate calendar file",
+    });
+  }
+});
+
+function generateSingleEventCalendar(evt) {
+  const now = new Date();
+  const timestamp = now
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+
+  const eventStart = new Date(evt.startDate);
+  const eventEnd = new Date(evt.endDate);
+
+  const dtstart = eventStart
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+  const dtend = eventEnd
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d{3}/, "");
+
+  // Clean description for iCal format
+  const description = (evt.description || "")
+    .replace(/\n/g, "\\n")
+    .replace(/,/g, "\\,");
+
+  const eventUrl = `https://ghostguild.org/events/${evt.slug || evt._id}`;
+
+  const ical = [
+    "BEGIN:VCALENDAR",
+    "VERSION:2.0",
+    "PRODID:-//Ghost Guild//Events//EN",
+    "CALSCALE:GREGORIAN",
+    "METHOD:PUBLISH",
+    "BEGIN:VEVENT",
+    `UID:${evt._id}@ghostguild.org`,
+    `DTSTAMP:${timestamp}`,
+    `DTSTART:${dtstart}`,
+    `DTEND:${dtend}`,
+    `SUMMARY:${evt.title}`,
+    `DESCRIPTION:${description}\\n\\nView event: ${eventUrl}`,
+    `LOCATION:${evt.location || "Online"}`,
+    `URL:${eventUrl}`,
+    `STATUS:CONFIRMED`,
+    "END:VEVENT",
+    "END:VCALENDAR",
+  ];
+
+  return ical.join("\r\n");
+}

server/api/events/[id]/cancel-registration.post.js

@@ -1,5 +1,8 @@
 import Event from "../../../models/event";
-import { sendEventCancellationEmail } from "../../../utils/resend.js";
+import {
+  sendEventCancellationEmail,
+  sendWaitlistNotificationEmail,
+} from "../../../utils/resend.js";
 
 export default defineEventHandler(async (event) => {
   const id = getRouterParam(event, "id");
@@ -71,6 +74,39 @@ export default defineEventHandler(async (event) => {
       console.error("Failed to send cancellation email:", emailError);
     }
 
+    // Notify waitlisted users if waitlist is enabled and there are entries
+    if (
+      eventDoc.tickets?.waitlist?.enabled &&
+      eventDoc.tickets.waitlist.entries?.length > 0
+    ) {
+      try {
+        const eventData = {
+          title: eventDoc.title,
+          slug: eventDoc.slug,
+          _id: eventDoc._id,
+          startDate: eventDoc.startDate,
+          endDate: eventDoc.endDate,
+          location: eventDoc.location,
+        };
+
+        // Notify the first person on the waitlist who hasn't been notified yet
+        const waitlistEntry = eventDoc.tickets.waitlist.entries.find(
+          (entry) => !entry.notified
+        );
+
+        if (waitlistEntry) {
+          await sendWaitlistNotificationEmail(waitlistEntry, eventData);
+
+          // Mark as notified
+          waitlistEntry.notified = true;
+          await eventDoc.save();
+        }
+      } catch (waitlistError) {
+        // Log error but don't fail the cancellation
+        console.error("Failed to notify waitlist:", waitlistError);
+      }
+    }
+
     return {
       success: true,
       message: "Registration cancelled successfully",

server/api/events/[id]/waitlist.delete.js

@@ -0,0 +1,59 @@
+import Event from "../../../models/event";
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  const body = await readBody(event);
+
+  const { email } = body;
+
+  if (!email) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Email is required",
+    });
+  }
+
+  try {
+    // Find event by ID or slug
+    const eventData = await Event.findOne({
+      $or: [{ _id: id }, { slug: id }],
+    });
+
+    if (!eventData) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Event not found",
+      });
+    }
+
+    // Find and remove from waitlist
+    const waitlistIndex = eventData.tickets?.waitlist?.entries?.findIndex(
+      (entry) => entry.email.toLowerCase() === email.toLowerCase()
+    );
+
+    if (waitlistIndex === -1 || waitlistIndex === undefined) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "You are not on the waitlist for this event",
+      });
+    }
+
+    eventData.tickets.waitlist.entries.splice(waitlistIndex, 1);
+    await eventData.save();
+
+    return {
+      success: true,
+      message: "You have been removed from the waitlist",
+    };
+  } catch (error) {
+    if (error.statusCode) {
+      throw error;
+    }
+
+    console.error("Error leaving waitlist:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to leave waitlist",
+    });
+  }
+});

server/api/events/[id]/waitlist.post.js

@@ -0,0 +1,119 @@
+import Event from "../../../models/event";
+import Member from "../../../models/member";
+
+export default defineEventHandler(async (event) => {
+  const id = getRouterParam(event, "id");
+  const body = await readBody(event);
+
+  const { name, email, membershipLevel } = body;
+
+  if (!email) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Email is required",
+    });
+  }
+
+  try {
+    // Find event by ID or slug
+    const eventData = await Event.findOne({
+      $or: [{ _id: id }, { slug: id }],
+    });
+
+    if (!eventData) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Event not found",
+      });
+    }
+
+    // Check if waitlist is enabled
+    if (!eventData.tickets?.waitlist?.enabled) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Waitlist is not enabled for this event",
+      });
+    }
+
+    // Check if already on waitlist
+    const existingEntry = eventData.tickets.waitlist.entries?.find(
+      (entry) => entry.email.toLowerCase() === email.toLowerCase()
+    );
+
+    if (existingEntry) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "You are already on the waitlist for this event",
+      });
+    }
+
+    // Check if already registered
+    const existingRegistration = eventData.registrations?.find(
+      (reg) => reg.email?.toLowerCase() === email.toLowerCase() && !reg.cancelledAt
+    );
+
+    if (existingRegistration) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "You are already registered for this event",
+      });
+    }
+
+    // Check waitlist capacity
+    const currentWaitlistSize = eventData.tickets.waitlist.entries?.length || 0;
+    const maxSize = eventData.tickets.waitlist.maxSize;
+
+    if (maxSize && currentWaitlistSize >= maxSize) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "The waitlist is full",
+      });
+    }
+
+    // Get member info if authenticated
+    let memberName = name;
+    let memberLevel = membershipLevel || "non-member";
+
+    // Try to find member by email
+    const member = await Member.findOne({ email: email.toLowerCase() });
+    if (member) {
+      memberName = memberName || member.name;
+      memberLevel = `${member.circle}-${member.contributionTier}`;
+    }
+
+    // Add to waitlist
+    if (!eventData.tickets.waitlist.entries) {
+      eventData.tickets.waitlist.entries = [];
+    }
+
+    eventData.tickets.waitlist.entries.push({
+      name: memberName || "Guest",
+      email: email.toLowerCase(),
+      membershipLevel: memberLevel,
+      addedAt: new Date(),
+      notified: false,
+    });
+
+    await eventData.save();
+
+    // Get position in waitlist
+    const position = eventData.tickets.waitlist.entries.length;
+
+    return {
+      success: true,
+      message: "You have been added to the waitlist",
+      position,
+      totalWaitlisted: position,
+    };
+  } catch (error) {
+    if (error.statusCode) {
+      throw error;
+    }
+
+    console.error("Error joining waitlist:", error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to join waitlist",
+    });
+  }
+});

server/api/events/index.get.js

@@ -1,53 +1,53 @@
-import Event from '../../models/event.js'
-import { connectDB } from '../../utils/mongoose.js'
+import Event from "../../models/event.js";
+import { connectDB } from "../../utils/mongoose.js";
 
 export default defineEventHandler(async (event) => {
   try {
     // Ensure database connection
-    await connectDB()
+    await connectDB();
     // Get query parameters for filtering
-    const query = getQuery(event)
-    const filter = {}
-    
+    const query = getQuery(event);
+    const filter = {};
+
     // Only show visible events on public calendar (unless specifically requested)
-    if (query.includeHidden !== 'true') {
-      filter.isVisible = true
+    if (query.includeHidden !== "true") {
+      filter.isVisible = true;
     }
-    
+
     // Filter for upcoming events only if requested
-    if (query.upcoming === 'true') {
-      filter.startDate = { $gte: new Date() }
+    if (query.upcoming === "true") {
+      filter.startDate = { $gte: new Date() };
     }
-    
+
     // Filter by event type if provided
     if (query.eventType) {
-      filter.eventType = query.eventType
+      filter.eventType = query.eventType;
     }
-    
+
     // Filter for members-only events
     if (query.membersOnly !== undefined) {
-      filter.membersOnly = query.membersOnly === 'true'
+      filter.membersOnly = query.membersOnly === "true";
     }
-    
+
     // Fetch events from database
     const events = await Event.find(filter)
       .sort({ startDate: 1 })
-      .select('-registrations') // Don't expose registration details in list view
-      .lean()
-    
+      .select("-registrations") // Don't expose registration details in list view
+      .lean();
+
     // Add computed fields
-    const eventsWithMeta = events.map(event => ({
+    const eventsWithMeta = events.map((event) => ({
       ...event,
       id: event._id.toString(),
-      registeredCount: event.registrations?.length || 0
-    }))
-    
-    return eventsWithMeta
+      registeredCount: event.registrations?.length || 0,
+    }));
+
+    return eventsWithMeta;
   } catch (error) {
-    console.error('Error fetching events:', error)
+    console.error("Error fetching events:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: 'Failed to fetch events'
-    })
+      statusMessage: "Failed to fetch events",
+    });
   }
-})
+});

server/utils/resend.js

@@ -301,6 +301,185 @@ export async function sendEventCancellationEmail(registration, eventData) {
   }
 }
 
+/**
+ * Send waitlist notification email when a spot opens up
+ */
+export async function sendWaitlistNotificationEmail(waitlistEntry, eventData) {
+  const formatDate = (dateString) => {
+    const date = new Date(dateString);
+    return new Intl.DateTimeFormat("en-US", {
+      weekday: "long",
+      year: "numeric",
+      month: "long",
+      day: "numeric",
+    }).format(date);
+  };
+
+  const formatTime = (startDate, endDate) => {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+
+    const timeFormat = new Intl.DateTimeFormat("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+      timeZoneName: "short",
+    });
+
+    return `${timeFormat.format(start)} - ${timeFormat.format(end)}`;
+  };
+
+  try {
+    const { data, error } = await resend.emails.send({
+      from: "Ghost Guild <events@ghostguild.org>",
+      to: [waitlistEntry.email],
+      subject: `A spot opened up for ${eventData.title}!`,
+      html: `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <style>
+              body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+                line-height: 1.6;
+                color: #333;
+                max-width: 600px;
+                margin: 0 auto;
+                padding: 20px;
+              }
+              .header {
+                background: linear-gradient(135deg, #f59e0b 0%, #d97706 100%);
+                color: #fff;
+                padding: 30px;
+                text-align: center;
+                border-radius: 8px 8px 0 0;
+              }
+              .content {
+                background-color: #f9f9f9;
+                padding: 30px;
+                border-radius: 0 0 8px 8px;
+              }
+              .event-details {
+                background-color: #fff;
+                padding: 20px;
+                border-radius: 8px;
+                margin: 20px 0;
+                border-left: 4px solid #f59e0b;
+              }
+              .detail-row {
+                margin: 10px 0;
+              }
+              .label {
+                font-weight: 600;
+                color: #666;
+                font-size: 14px;
+              }
+              .value {
+                color: #1a1a2e;
+                font-size: 16px;
+              }
+              .button {
+                display: inline-block;
+                background-color: #f59e0b;
+                color: #fff;
+                padding: 14px 32px;
+                text-decoration: none;
+                border-radius: 6px;
+                margin: 20px 0;
+                font-weight: 600;
+                font-size: 16px;
+              }
+              .urgent {
+                background-color: #fef3c7;
+                border: 2px solid #f59e0b;
+                padding: 15px;
+                border-radius: 8px;
+                margin: 20px 0;
+              }
+              .footer {
+                text-align: center;
+                margin-top: 30px;
+                padding-top: 20px;
+                border-top: 1px solid #ddd;
+                color: #666;
+                font-size: 14px;
+              }
+            </style>
+          </head>
+          <body>
+            <div class="header">
+              <h1 style="margin: 0;">A Spot Just Opened Up! 🎉</h1>
+            </div>
+
+            <div class="content">
+              <p>Hi ${waitlistEntry.name},</p>
+
+              <p>Great news! A spot has become available for <strong>${eventData.title}</strong>, and you're on the waitlist.</p>
+
+              <div class="urgent">
+                <p style="margin: 0; font-weight: 600; color: #92400e;">
+                  ⏰ Act fast! Spots are filled on a first-come, first-served basis.
+                </p>
+              </div>
+
+              <div class="event-details">
+                <div class="detail-row">
+                  <div class="label">Event</div>
+                  <div class="value">${eventData.title}</div>
+                </div>
+
+                <div class="detail-row">
+                  <div class="label">Date</div>
+                  <div class="value">${formatDate(eventData.startDate)}</div>
+                </div>
+
+                <div class="detail-row">
+                  <div class="label">Time</div>
+                  <div class="value">${formatTime(eventData.startDate, eventData.endDate)}</div>
+                </div>
+
+                <div class="detail-row">
+                  <div class="label">Location</div>
+                  <div class="value">${eventData.location}</div>
+                </div>
+              </div>
+
+              <center>
+                <a href="${process.env.BASE_URL || "https://ghostguild.org"}/events/${eventData.slug || eventData._id}" class="button">
+                  Register Now →
+                </a>
+              </center>
+
+              <p style="margin-top: 30px; font-size: 14px; color: #666;">
+                If you can no longer attend, no worries! Just ignore this email and the spot will go to the next person on the waitlist.
+              </p>
+            </div>
+
+            <div class="footer">
+              <p>Ghost Guild</p>
+              <p>
+                Questions? Email us at
+                <a href="mailto:events@ghostguild.org">events@ghostguild.org</a>
+              </p>
+            </div>
+          </body>
+        </html>
+      `,
+    });
+
+    if (error) {
+      console.error("Failed to send waitlist notification email:", error);
+      return { success: false, error };
+    }
+
+    return { success: true, data };
+  } catch (error) {
+    console.error("Error sending waitlist notification email:", error);
+    return { success: false, error };
+  }
+}
+
 /**
  * Send series pass confirmation email
  */