feat: add event service, dashboard activity, rsvp tracking, and date packages

package.json

@@ -63,13 +63,16 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
+    "date-fns": "^4.1.0",
+    "date-fns-tz": "^3.2.0",
     "fuse.js": "^7.1.0",
     "jspdf": "^4.0.0",
     "jspdf-autotable": "^5.0.7",
     "lucide-react": "^0.555.0",
     "next": "^16.1.6",
     "next-themes": "^0.4.6",
     "react": "^19.2.1",
+    "react-day-picker": "^9.14.0",
     "react-dom": "^19.2.1",
     "resend": "^6.9.4",
     "server-only": "^0.0.1",

src/actions/event.ts

@@ -0,0 +1,147 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { verifySession } from "@/lib/dal";
+import { CreateEventSchema, UpdateEventSchema, RsvpSchema } from "@/schema/event";
+import {
+  createEvent,
+  updateEvent,
+  deleteEvent,
+  getEventById,
+  isEventOwner,
+  rsvpToEvent,
+  getEventRsvps,
+  getUpcomingEvents,
+} from "@/services/event";
+import { getRecentActivity } from "@/services/dashboard";
+import { getAllMessageHistory } from "@/services/message";
+import { getAllMembers } from "@/lib/api/member-api";
+import { transformError } from "@/utils/errors";
+import type { ActionResult } from "@/lib/action-types";
+import type { EventWithRsvpCount, RsvpDetail, EventSummary } from "@/services/event";
+import type { ActivityItem } from "@/services/dashboard";
+import type { MessageHistoryItem } from "@/services/message";
+
+export async function createEventAction(input: {
+  title: string;
+  description?: string | null;
+  location?: string | null;
+  startDate: string | Date;
+  endDate: string | Date;
+  rsvpDeadline?: string | Date | null;
+  eventType: string;
+  groupId?: number | null;
+}): Promise<ActionResult<{ id: number }>> {
+  try {
+    const session = await verifySession();
+    const validated = CreateEventSchema.parse(input);
+    const event = await createEvent(validated, session.ownerid);
+
+    revalidatePath("/events");
+    revalidatePath("/home");
+    return { success: true, data: { id: event.id } };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function updateEventAction(eventId: number, input: Record<string, unknown>): Promise<ActionResult> {
+  try {
+    const session = await verifySession();
+
+    if (!session.isAdmin && !(await isEventOwner(eventId, session.ownerid))) {
+      return { success: false, error: "You do not have permission to edit this event" };
+    }
+
+    const validated = UpdateEventSchema.parse(input);
+    await updateEvent(eventId, validated);
+
+    revalidatePath(`/events`);
+    revalidatePath("/home");
+    return { success: true };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function deleteEventAction(eventId: number): Promise<ActionResult> {
+  try {
+    const session = await verifySession();
+
+    if (!session.isAdmin && !(await isEventOwner(eventId, session.ownerid))) {
+      return { success: false, error: "You do not have permission to delete this event" };
+    }
+
+    await deleteEvent(eventId);
+
+    revalidatePath("/events");
+    revalidatePath("/home");
+    return { success: true };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function rsvpAction(input: { eventId: number; status: string }): Promise<ActionResult> {
+  try {
+    const session = await verifySession();
+    const validated = RsvpSchema.parse(input);
+    await rsvpToEvent(validated.eventId, session.ownerid, validated.status);
+
+    revalidatePath("/events");
+    return { success: true };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export async function fetchEventDetail(
+  eventId: number,
+): Promise<ActionResult<{ event: EventWithRsvpCount; rsvps: RsvpDetail[] }>> {
+  try {
+    await verifySession();
+    const event = await getEventById(eventId);
+    const rsvps = await getEventRsvps(eventId);
+    return { success: true, data: { event, rsvps } };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}
+
+export interface DashboardData {
+  totalMembers: number;
+  upcomingEvents: EventSummary[];
+  recentActivity: ActivityItem[];
+  recentMessages: MessageHistoryItem[];
+}
+
+export async function fetchDashboardData(): Promise<ActionResult<DashboardData>> {
+  try {
+    await verifySession();
+
+    const [memberList, upcomingEvents, recentActivity, recentMessages] = await Promise.all([
+      getAllMembers(),
+      getUpcomingEvents(4),
+      getRecentActivity(3),
+      getAllMessageHistory({ limit: 1 }),
+    ]);
+
+    return {
+      success: true,
+      data: {
+        totalMembers: memberList.length,
+        upcomingEvents,
+        recentActivity,
+        recentMessages,
+      },
+    };
+  } catch (error) {
+    const appError = transformError(error);
+    return { success: false, error: appError.message };
+  }
+}

src/schema/event.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+export const CreateEventSchema = z.object({
+  title: z.string().min(1).max(200),
+  description: z.string().max(5000).nullish(),
+  location: z.string().max(200).nullish(),
+  startDate: z.coerce.date(),
+  endDate: z.coerce.date(),
+  rsvpDeadline: z.coerce.date().nullish(),
+  eventType: z.enum(["social", "networking", "volunteer", "meeting"]),
+  groupId: z.number().int().positive().nullish(),
+});
+
+export const UpdateEventSchema = CreateEventSchema.partial();
+
+export const RsvpSchema = z.object({
+  eventId: z.number().int().positive(),
+  status: z.enum(["going", "maybe", "declined"]),
+});
+
+export type CreateEvent = z.infer<typeof CreateEventSchema>;
+export type UpdateEvent = z.infer<typeof UpdateEventSchema>;
+export type Rsvp = z.infer<typeof RsvpSchema>;

src/services/dashboard.ts

@@ -0,0 +1,43 @@
+import "server-only";
+import prisma from "@/lib/db";
+import { transformError } from "@/utils/errors";
+
+export interface ActivityItem {
+  type: "message_sent" | "event_created";
+  title: string;
+  timestamp: Date;
+}
+
+export async function getRecentActivity(limit: number = 5): Promise<ActivityItem[]> {
+  try {
+    const [recentMessages, recentEvents] = await Promise.all([
+      prisma.message.findMany({
+        select: { subject: true, sentAt: true, emailCount: true },
+        orderBy: { sentAt: "desc" },
+        take: limit,
+      }),
+      prisma.event.findMany({
+        select: { title: true, createdAt: true },
+        orderBy: { createdAt: "desc" },
+        take: limit,
+      }),
+    ]);
+
+    const items: ActivityItem[] = [
+      ...recentMessages.map((m) => ({
+        type: "message_sent" as const,
+        title: `Message sent to ${m.emailCount} Members`,
+        timestamp: m.sentAt,
+      })),
+      ...recentEvents.map((e) => ({
+        type: "event_created" as const,
+        title: `Event Created: ${e.title}`,
+        timestamp: e.createdAt,
+      })),
+    ];
+
+    return items.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()).slice(0, limit);
+  } catch (error) {
+    throw transformError(error);
+  }
+}