feat: initial FE+BE wiring

Author: megany128

.prettierignore

@@ -2,3 +2,5 @@ node_modules
 dist
 pnpm-lock.yaml
 convex/_generated
+apps/dashboard/test-results
+apps/dashboard/playwright-report

apps/dashboard/.gitignore

@@ -1,2 +1,6 @@
 
 .env.local
+
+# Playwright artifacts
+test-results/
+playwright-report/

apps/dashboard/convex/_generated/api.d.ts

@@ -9,7 +9,16 @@
  */
 
 import type * as auth from "../auth.js";
+import type * as bookmarks from "../bookmarks.js";
+import type * as dev from "../dev.js";
+import type * as events from "../events.js";
+import type * as follows from "../follows.js";
 import type * as http from "../http.js";
+import type * as orgs from "../orgs.js";
+import type * as rsvps from "../rsvps.js";
+import type * as seed from "../seed.js";
+import type * as seedData from "../seedData.js";
+import type * as users from "../users.js";
 
 import type {
   ApiFromModules,
@@ -19,7 +28,16 @@ import type {
 
 declare const fullApi: ApiFromModules<{
   auth: typeof auth;
+  bookmarks: typeof bookmarks;
+  dev: typeof dev;
+  events: typeof events;
+  follows: typeof follows;
   http: typeof http;
+  orgs: typeof orgs;
+  rsvps: typeof rsvps;
+  seed: typeof seed;
+  seedData: typeof seedData;
+  users: typeof users;
 }>;
 
 /**

apps/dashboard/convex/auth.ts

@@ -1,6 +1,35 @@
 import Google from "@auth/core/providers/google";
 import { convexAuth } from "@convex-dev/auth/server";
+import { ConvexError } from "convex/values";
+
+const ALLOWED_EMAIL_DOMAIN = "@cornell.edu";
 
 export const { auth, signIn, signOut, store, isAuthenticated } = convexAuth({
   providers: [Google],
+  callbacks: {
+    async createOrUpdateUser(ctx, args) {
+      const email = args.profile.email;
+      if (
+        typeof email !== "string" ||
+        !email.toLowerCase().endsWith(ALLOWED_EMAIL_DOMAIN)
+      ) {
+        throw new ConvexError({
+          code: "NON_CORNELL_EMAIL",
+          message: "Loop is open to Cornell students only.",
+        });
+      }
+      if (args.existingUserId) {
+        return args.existingUserId;
+      }
+      const name =
+        typeof args.profile.name === "string" ? args.profile.name : undefined;
+      const image =
+        typeof args.profile.image === "string" ? args.profile.image : undefined;
+      return await ctx.db.insert("users", {
+        email: email.toLowerCase(),
+        name,
+        image,
+      });
+    },
+  },
 });

apps/dashboard/convex/bookmarks.ts

@@ -0,0 +1,145 @@
+import { ConvexError, v } from "convex/values";
+import { paginationOptsValidator } from "convex/server";
+import { getAuthUserId } from "@convex-dev/auth/server";
+import type { Doc, Id } from "./_generated/dataModel";
+import {
+  mutation,
+  query,
+  type MutationCtx,
+  type QueryCtx,
+} from "./_generated/server";
+
+type HydratedBookmark = {
+  bookmark: Doc<"bookmarks">;
+  event: Doc<"events">;
+  orgs: Doc<"orgs">[];
+};
+
+type BookmarkPage = {
+  page: HydratedBookmark[];
+  isDone: boolean;
+  continueCursor: string;
+};
+
+async function loadOrgsForEvent(
+  ctx: QueryCtx,
+  eventId: Id<"events">,
+): Promise<Doc<"orgs">[]> {
+  const joins = await ctx.db
+    .query("eventOrgs")
+    .withIndex("by_event", (q) => q.eq("eventId", eventId))
+    .take(8);
+
+  const orgs: Doc<"orgs">[] = [];
+  for (const join of joins) {
+    const org = await ctx.db.get(join.orgId);
+    if (org !== null) {
+      orgs.push(org);
+    }
+  }
+  return orgs;
+}
+
+async function findBookmark(
+  ctx: QueryCtx | MutationCtx,
+  userId: Id<"users">,
+  eventId: Id<"events">,
+): Promise<Doc<"bookmarks"> | null> {
+  return await ctx.db
+    .query("bookmarks")
+    .withIndex("by_user_and_event", (q) =>
+      q.eq("userId", userId).eq("eventId", eventId),
+    )
+    .unique();
+}
+
+export const bookmark = mutation({
+  args: { eventId: v.id("events") },
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (userId === null) {
+      throw new ConvexError({
+        code: "UNAUTHENTICATED",
+        message: "You must be signed in to bookmark an event.",
+      });
+    }
+
+    const existing = await findBookmark(ctx, userId, args.eventId);
+    if (existing !== null) {
+      // Idempotent: already bookmarked.
+      return null;
+    }
+
+    await ctx.db.insert("bookmarks", {
+      userId,
+      eventId: args.eventId,
+      createdAt: Date.now(),
+    });
+    return null;
+  },
+});
+
+export const unbookmark = mutation({
+  args: { eventId: v.id("events") },
+  handler: async (ctx, args) => {
+    const userId = await getAuthUserId(ctx);
+    if (userId === null) {
+      throw new ConvexError({
+        code: "UNAUTHENTICATED",
+        message: "You must be signed in to remove a bookmark.",
+      });
+    }
+
+    const existing = await findBookmark(ctx, userId, args.eventId);
+    if (existing !== null) {
+      await ctx.db.delete(existing._id);
+    }
+    return null;
+  },
+});
+
+export const isBookmarked = query({
+  args: { eventId: v.id("events") },
+  handler: async (ctx, args): Promise<boolean> => {
+    const userId = await getAuthUserId(ctx);
+    if (userId === null) {
+      return false;
+    }
+    const existing = await findBookmark(ctx, userId, args.eventId);
+    return existing !== null;
+  },
+});
+
+export const myBookmarks = query({
+  args: { paginationOpts: paginationOptsValidator },
+  handler: async (ctx, args): Promise<BookmarkPage> => {
+    const userId = await getAuthUserId(ctx);
+    if (userId === null) {
+      return {
+        page: [],
+        isDone: true,
+        continueCursor: "",
+      };
+    }
+
+    const result = await ctx.db
+      .query("bookmarks")
+      .withIndex("by_user", (q) => q.eq("userId", userId))
+      .order("desc")
+      .paginate(args.paginationOpts);
+
+    const hydrated: HydratedBookmark[] = [];
+    for (const row of result.page) {
+      const event = await ctx.db.get(row.eventId);
+      if (event === null) continue;
+      const orgs = await loadOrgsForEvent(ctx, event._id);
+      hydrated.push({ bookmark: row, event, orgs });
+    }
+
+    return {
+      page: hydrated,
+      isDone: result.isDone,
+      continueCursor: result.continueCursor,
+    };
+  },
+});