Minigames System

convex/
├── schema.ts                     # MODIFY — add guestProfiles, guestReactions, challengeConfig,
│                                 #   photoSubmissions, photoLikes, spinPrizes, spinResults,
│                                 #   challengeSubmissions + orderItems comp fields
└── functions/
    ├── profiles.ts               # CREATE — profile CRUD, reactions
    └── challenges.ts             # CREATE — photo wall, spin, Google review mutations/queries

apps/frontend/
├── lib/
│   └── schemas/
│       └── minigames.ts          # CREATE — Zod schemas for all minigame inputs
├── app/[locale]/
│   ├── onboard/
│   │   └── page.tsx             # CREATE — profile creation with OAuth (SSG: uses nuqs)
│   ├── table/
│   │   └── page.tsx             # MODIFY — profile-gated, add minigame tabs (nuqs)
│   ├── wall/
│   │   └── page.tsx             # CREATE — shared display wall (auto-cycle, nuqs)
│   └── admin/
│       └── challenges/
│           └── page.tsx          # CREATE — challenge configuration (admin)
└── components/
    ├── profile/
    │   ├── profile-form.tsx      # CREATE — nickname, origin, mood tags form
    │   ├── oauth-buttons.tsx     # CREATE — Google/Facebook OAuth (simulated)
    │   ├── mood-selector.tsx     # CREATE — mood tag multi-select
    │   └── guest-wall.tsx        # CREATE — who's here tonight + reactions (PWA tab)
    ├── minigames/
    │   ├── photo-wall.tsx        # CREATE — photo submission + like UI
    │   ├── spin-wheel.tsx        # CREATE — animated prize wheel (framer-motion)
    │   └── google-review.tsx     # CREATE — step-by-step + screenshot upload
    └── wall/
        ├── photo-grid.tsx        # CREATE — live photo grid for wall
        ├── spin-feed.tsx         # CREATE — recent spins for wall
        └── guest-grid.tsx        # CREATE — tonight's guests for wall

cat convex/schema.ts

  guestProfiles: defineTable({
    reservationId: v.optional(v.id("reservations")),
    tableId: v.id("tables"),
    token: v.string(),
 
    googleId: v.optional(v.string()),
    facebookId: v.optional(v.string()),
    email: v.optional(v.string()),
    avatarUrl: v.optional(v.string()),
 
    nickname: v.string(),
    origin: v.string(),
    moodTags: v.array(v.string()),
    bio: v.optional(v.string()),
 
    showDate: v.string(),
    checkedIn: v.boolean(),
 
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_reservation", ["reservationId"])
    .index("by_show_date", ["showDate"])
    .index("by_token", ["token"])
    .index("by_google_id", ["googleId"])
    .index("by_facebook_id", ["facebookId"]),

  guestReactions: defineTable({
    fromProfileId: v.id("guestProfiles"),
    toProfileId: v.id("guestProfiles"),
    reactionType: v.union(v.literal("WAVE"), v.literal("CHEERS"), v.literal("HEART")),
    showDate: v.string(),
    createdAt: v.number(),
  })
    .index("by_to_profile", ["toProfileId"])
    .index("by_from_profile", ["fromProfileId"])
    .index("by_show_date", ["showDate"]),

  challengeConfig: defineTable({
    challengeType: v.union(
      v.literal("PHOTO_WALL"),
      v.literal("LUCKY_SPIN"),
      v.literal("GOOGLE_REVIEW")
    ),
    enabled: v.boolean(),
    maxValue: v.optional(v.number()),
    prizeDescription: v.optional(v.string()),
    steps: v.array(v.object({
      order: v.number(),
      text: v.string(),
      imageUrl: v.optional(v.string()),
    })),
    activeForDates: v.array(v.string()),
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_type", ["challengeType"]),

  photoSubmissions: defineTable({
    profileId: v.id("guestProfiles"),
    orderId: v.id("orders"),
    tableId: v.id("tables"),
    imageUrl: v.string(),
    caption: v.optional(v.string()),
    likeCount: v.number(),
    status: v.union(v.literal("ACTIVE"), v.literal("HIDDEN")),
    winner: v.boolean(),
    showDate: v.string(),
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_show_date", ["showDate"])
    .index("by_profile", ["profileId"])
    .index("by_status", ["status"])
    .index("by_likes", ["likeCount", "status"])
    .index("by_table_show", ["tableId", "showDate"]),

  photoLikes: defineTable({
    submissionId: v.id("photoSubmissions"),
    profileId: v.id("guestProfiles"),
    createdAt: v.number(),
  })
    .index("by_submission", ["submissionId"])
    .index("by_profile_submission", ["profileId", "submissionId"])
    .index("by_profile", ["profileId"]),

  spinPrizes: defineTable({
    label: v.string(),
    prizeType: v.union(v.literal("MENU_ITEM"), v.literal("DISCOUNT"), v.literal("FREE_ITEM")),
    menuItemId: v.optional(v.id("menuItems")),
    discountPercent: v.optional(v.number()),
    weight: v.number(),
    enabled: v.boolean(),
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_enabled", ["enabled"]),

  spinResults: defineTable({
    profileId: v.id("guestProfiles"),
    orderId: v.id("orders"),
    tableId: v.id("tables"),
    prizeId: v.id("spinPrizes"),
    displayText: v.string(),
    showDate: v.string(),
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_show_date", ["showDate"])
    .index("by_table_show", ["tableId", "showDate"])
    .index("by_profile", ["profileId"]),

  challengeSubmissions: defineTable({
    profileId: v.id("guestProfiles"),
    orderId: v.id("orders"),
    tableId: v.id("tables"),
    challengeType: v.literal("GOOGLE_REVIEW"),
    screenshotUrl: v.string(),
    status: v.union(v.literal("PENDING"), v.literal("APPROVED"), v.literal("REJECTED")),
    rewardMenuItemId: v.optional(v.id("menuItems")),
    reviewedBy: v.optional(v.id("users")),
    reviewedAt: v.optional(v.number()),
    notes: v.optional(v.string()),
    showDate: v.string(),
    createdAt: v.number(),
    updatedAt: v.number(),
  })
    .index("by_status", ["status"])
    .index("by_show_date", ["showDate"])
    .index("by_table_show", ["tableId", "showDate"]),

    isComp: v.boolean(),
    compSource: v.optional(v.union(
      v.literal("SPIN"),
      v.literal("PHOTO_WIN"),
      v.literal("GOOGLE_REVIEW")
    )),

npx convex codegen

git add convex/schema.ts
git commit -m "feat(minigames): add guest profiles and minigames schema"

import { query, mutation } from "../_generated/server";
import { v } from "convex/values";
import { Id } from "../_generated/dataModel";
import { MINIGAME_ERROR_CODES } from "~/lib/schemas/minigames";
import { consola } from "consola";
 
export const getById = query({
  args: { id: v.id("guestProfiles") },
  handler: async (ctx, { id }) => {
    const profile = await ctx.db.get(id);
    if (!profile) return null;
    const { googleId, facebookId, ...rest } = profile;
    return rest;
  },
});
 
export const getTonightsGuests = query({
  args: { showDate: v.string() },
  handler: async (ctx, { showDate }) => {
    const guests = await ctx.db
      .query("guestProfiles")
      .withIndex("by_show_date", (q) => q.eq("showDate", showDate))
      .collect();
    return guests.map(({ googleId, facebookId, ...rest }) => rest);
  },
});
 
export const getReactionsReceived = query({
  args: { profileId: v.id("guestProfiles"), showDate: v.string() },
  handler: async (ctx, { profileId, showDate }) => {
    const reactions = await ctx.db
      .query("guestReactions")
      .withIndex("by_to_profile", (q) => q.eq("toProfileId", profileId))
      .collect();
    const counts = { WAVE: 0, CHEERS: 0, HEART: 0 };
    for (const r of reactions) {
      if (r.showDate === showDate) counts[r.reactionType]++;
    }
    return counts;
  },
});
 
export const getOrCreateProfile = mutation({
  args: { tableId: v.id("tables"), token: v.string() },
  handler: async (ctx, { tableId, token }) => {
    const existing = await ctx.db
      .query("guestProfiles")
      .withIndex("by_token", (q) => q.eq("token", token))
      .first();
    if (existing) return existing;
    const showDate = new Date().toISOString().split("T")[0];
    const id = await ctx.db.insert("guestProfiles", {
      tableId,
      token,
      showDate,
      checkedIn: false,
      nickname: "",
      origin: "",
      moodTags: [],
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
    return await ctx.db.get(id);
  },
});
 
export const completeProfile = mutation({
  args: {
    profileId: v.id("guestProfiles"),
    nickname: v.string(),
    origin: v.string(),
    moodTags: v.array(v.string()),
    googleId: v.optional(v.string()),
    facebookId: v.optional(v.string()),
    email: v.optional(v.string()),
    avatarUrl: v.optional(v.string()),
    bio: v.optional(v.string()),
  },
  handler: async (ctx, args) => {
    const { profileId, ...updates } = args;
    if (updates.nickname.length < 2 || updates.nickname.length > 20) {
      throw new Error(
        `${MINIGAME_ERROR_CODES.INVALID_NICKNAME}: Nickname must be 2-20 characters`,
      );
    }
    await ctx.db.patch(profileId, { ...updates, updatedAt: Date.now() });
    return profileId;
  },
});
 
export const sendReaction = mutation({
  args: {
    fromProfileId: v.id("guestProfiles"),
    toProfileId: v.id("guestProfiles"),
    reactionType: v.union(
      v.literal("WAVE"),
      v.literal("CHEERS"),
      v.literal("HEART"),
    ),
    showDate: v.string(),
  },
  handler: async (
    ctx,
    { fromProfileId, toProfileId, reactionType, showDate },
  ) => {
    if (fromProfileId === toProfileId) {
      throw new Error(
        `${MINIGAME_ERROR_CODES.CANNOT_REACT_SELF}: Cannot react to yourself`,
      );
    }
    const existing = await ctx.db
      .query("guestReactions")
      .withIndex("by_from_profile", (q) =>
        q.eq("fromProfileId", fromProfileId).eq("toProfileId", toProfileId),
      )
      .first();
    if (existing) {
      await ctx.db.delete(existing._id);
      return { reacted: false };
    }
    await ctx.db.insert("guestReactions", {
      fromProfileId,
      toProfileId,
      reactionType,
      showDate,
      createdAt: Date.now(),
    });
    consola.info("Reaction sent", {
      fromProfileId: fromProfileId.toString(),
      toProfileId: toProfileId.toString(),
      reactionType,
      showDate,
    });
    return { reacted: true };
  },
});

git add convex/functions/profiles.ts
git commit -m "feat(profiles): add guest profile functions"

import { query, mutation } from "../_generated/server";
import { v } from "convex/values";
import { Id } from "../_generated/dataModel";
import { MINIGAME_ERROR_CODES } from "~/lib/schemas/minigames";
import { consola } from "consola";
 
// ─── Anti-cheat: cryptographically secure weighted random ─────────────────────
function secureWeightedRandom<T extends { weight: number }>(items: T[]): T {
  const totalWeight = items.reduce((sum, p) => sum + p.weight, 0);
  const randomBytes = new Uint32Array(1);
  crypto.getRandomValues(randomBytes);
  let random = (randomBytes[0] / 0xffffffff) * totalWeight;
  for (const prize of items) {
    random -= prize.weight;
    if (random <= 0) return prize;
  }
  return items[items.length - 1];
}
 
// ─── Photo Wall ────────────────────────────────────────────────────────────────
 
export const submitPhoto = mutation({
  args: {
    orderId: v.id("orders"),
    profileId: v.id("guestProfiles"),
    tableId: v.id("tables"),
    imageUrl: v.string(),
    caption: v.optional(v.string()),
    showDate: v.string(),
  },
  handler: async (ctx, args) => {
    const existing = await ctx.db
      .query("photoSubmissions")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", args.tableId).eq("showDate", args.showDate),
      )
      .first();
    if (existing) {
      await ctx.db.patch(existing._id, {
        profileId: args.profileId,
        imageUrl: args.imageUrl,
        caption: args.caption ?? undefined,
        likeCount: 0,
        updatedAt: Date.now(),
      });
      return existing._id;
    }
    const newId = await ctx.db.insert("photoSubmissions", {
      ...args,
      likeCount: 0,
      status: "ACTIVE",
      winner: false,
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
    consola.info("Photo submitted", {
      submissionId: newId.toString(),
      profileId: args.profileId.toString(),
      tableId: args.tableId.toString(),
      showDate: args.showDate,
    });
    return newId;
  },
});
 
export const likePhoto = mutation({
  args: {
    submissionId: v.id("photoSubmissions"),
    profileId: v.id("guestProfiles"),
  },
  handler: async (ctx, { submissionId, profileId }) => {
    const existing = await ctx.db
      .query("photoLikes")
      .withIndex("by_profile_submission", (q) =>
        q.eq("profileId", profileId).eq("submissionId", submissionId),
      )
      .first();
    if (existing) {
      await ctx.db.delete(existing._id);
      const sub = await ctx.db.get(submissionId);
      await ctx.db.patch(submissionId, {
        likeCount: Math.max(0, (sub?.likeCount ?? 0) - 1),
        updatedAt: Date.now(),
      });
      return { liked: false };
    }
    await ctx.db.insert("photoLikes", {
      submissionId,
      profileId,
      createdAt: Date.now(),
    });
    const sub = await ctx.db.get(submissionId);
    await ctx.db.patch(submissionId, {
      likeCount: (sub?.likeCount ?? 0) + 1,
      updatedAt: Date.now(),
    });
    return { liked: true };
  },
});
 
export const getWallPhotos = query({
  args: { showDate: v.string() },
  handler: async (ctx, { showDate }) => {
    const photos = await ctx.db
      .query("photoSubmissions")
      .withIndex("by_status", (q) => q.eq("status", "ACTIVE"))
      .collect();
    return photos
      .filter((p) => p.showDate === showDate)
      .sort((a, b) => b.likeCount - a.likeCount);
  },
});
 
export const getTablePhoto = query({
  args: { tableId: v.id("tables"), showDate: v.string() },
  handler: async (ctx, { tableId, showDate }) => {
    return await ctx.db
      .query("photoSubmissions")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", tableId).eq("showDate", showDate),
      )
      .first();
  },
});
 
export const hasLikedPhoto = query({
  args: {
    submissionId: v.id("photoSubmissions"),
    profileId: v.id("guestProfiles"),
  },
  handler: async (ctx, { submissionId, profileId }) => {
    const like = await ctx.db
      .query("photoLikes")
      .withIndex("by_profile_submission", (q) =>
        q.eq("profileId", profileId).eq("submissionId", submissionId),
      )
      .first();
    return !!like;
  },
});
 
export const declarePhotoWinner = mutation({
  args: { submissionId: v.id("photoSubmissions") },
  handler: async (ctx, { submissionId }) => {
    const submission = await ctx.db.get(submissionId);
    if (!submission)
      throw new Error(
        `${MINIGAME_ERROR_CODES.SUBMISSION_NOT_FOUND}: Submission not found`,
      );
    const allActive = await ctx.db
      .query("photoSubmissions")
      .withIndex("by_status", (q) => q.eq("status", "ACTIVE"))
      .collect();
    for (const p of allActive) {
      if (p.winner && p.showDate === submission.showDate) {
        await ctx.db.patch(p._id, { winner: false, updatedAt: Date.now() });
      }
    }
    await ctx.db.patch(submissionId, { winner: true, updatedAt: Date.now() });
    consola.info("Photo winner declared", {
      submissionId: submissionId.toString(),
      showDate: submission.showDate,
    });
    return submissionId;
  },
});
 
// ─── Lucky Spin ────────────────────────────────────────────────────────────────
 
export const spin = mutation({
  args: {
    orderId: v.id("orders"),
    profileId: v.id("guestProfiles"),
    tableId: v.id("tables"),
    showDate: v.string(),
  },
  handler: async (ctx, { orderId, profileId, tableId, showDate }) => {
    const existing = await ctx.db
      .query("spinResults")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", tableId).eq("showDate", showDate),
      )
      .first();
    if (existing)
      throw new Error(
        `${MINIGAME_ERROR_CODES.TABLE_ALREADY_SPUN}: Table has already spun`,
      );
 
    const prizes = await ctx.db
      .query("spinPrizes")
      .withIndex("by_enabled", (q) => q.eq("enabled", true))
      .collect();
    if (prizes.length === 0)
      throw new Error(
        `${MINIGAME_ERROR_CODES.NO_PRIZES}: No prizes configured`,
      );
 
    const selectedPrize = secureWeightedRandom(prizes);
    const table = await ctx.db.get(tableId);
    const displayText = `Table ${table?.name ?? tableId} won ${selectedPrize.label}!`;
 
    const resultId = await ctx.db.insert("spinResults", {
      orderId,
      profileId,
      tableId,
      prizeId: selectedPrize._id,
      displayText,
      showDate,
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
 
    if (selectedPrize.prizeType === "MENU_ITEM" && selectedPrize.menuItemId) {
      const menuItem = await ctx.db.get(selectedPrize.menuItemId);
      if (menuItem) {
        await ctx.db.insert("orderItems", {
          orderId,
          menuItemId: selectedPrize.menuItemId,
          quantity: 1,
          unitPrice: 0,
          status: "SERVED",
          station: menuItem.station ?? "BAR",
          isComp: true,
          compSource: "SPIN",
          createdAt: Date.now(),
          updatedAt: Date.now(),
        });
        consola.info("Comp item added from spin", {
          orderItemId: resultId.toString(),
          orderId: orderId.toString(),
          compSource: "SPIN",
          menuItemId: selectedPrize.menuItemId.toString(),
          value: menuItem.price,
        });
      }
    }
 
    consola.info("Spin executed", {
      resultId: resultId.toString(),
      profileId: profileId.toString(),
      tableId: tableId.toString(),
      prizeLabel: selectedPrize.label,
      prizeType: selectedPrize.prizeType,
      showDate,
    });
 
    return { prize: selectedPrize, displayText, resultId };
  },
});
 
export const getRecentSpins = query({
  args: { showDate: v.string(), limit: v.optional(v.number()) },
  handler: async (ctx, { showDate, limit = 10 }) => {
    const results = await ctx.db
      .query("spinResults")
      .withIndex("by_show_date", (q) => q.eq("showDate", showDate))
      .collect();
    return results.sort((a, b) => b.createdAt - a.createdAt).slice(0, limit);
  },
});
 
export const hasSpun = query({
  args: { tableId: v.id("tables"), showDate: v.string() },
  handler: async (ctx, { tableId, showDate }) => {
    const result = await ctx.db
      .query("spinResults")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", tableId).eq("showDate", showDate),
      )
      .first();
    return !!result;
  },
});
 
export const getTableSpin = query({
  args: { tableId: v.id("tables"), showDate: v.string() },
  handler: async (ctx, { tableId, showDate }) => {
    return await ctx.db
      .query("spinResults")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", tableId).eq("showDate", showDate),
      )
      .first();
  },
});
 
// ─── Google Maps Review ────────────────────────────────────────────────────────
 
export const submitGoogleReview = mutation({
  args: {
    orderId: v.id("orders"),
    profileId: v.id("guestProfiles"),
    tableId: v.id("tables"),
    screenshotUrl: v.string(),
    showDate: v.string(),
  },
  handler: async (ctx, args) => {
    const existing = await ctx.db
      .query("challengeSubmissions")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", args.tableId).eq("showDate", args.showDate),
      )
      .first();
    if (existing)
      throw new Error(
        `${MINIGAME_ERROR_CODES.ALREADY_SUBMITTED}: Table has already submitted a review`,
      );
    const newId = await ctx.db.insert("challengeSubmissions", {
      ...args,
      challengeType: "GOOGLE_REVIEW",
      status: "PENDING",
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
    consola.info("Google review submitted", {
      submissionId: newId.toString(),
      profileId: args.profileId.toString(),
      tableId: args.tableId.toString(),
      showDate: args.showDate,
    });
    return newId;
  },
});
 
export const approveGoogleReview = mutation({
  args: {
    submissionId: v.id("challengeSubmissions"),
    rewardMenuItemId: v.id("menuItems"),
  },
  handler: async (ctx, { submissionId, rewardMenuItemId }) => {
    const submission = await ctx.db.get(submissionId);
    if (!submission)
      throw new Error(
        `${MINIGAME_ERROR_CODES.SUBMISSION_NOT_FOUND}: Submission not found`,
      );
    if (submission.status !== "PENDING")
      throw new Error(`${MINIGAME_ERROR_CODES.NOT_PENDING}: Already reviewed`);
    const menuItem = await ctx.db.get(rewardMenuItemId);
    if (!menuItem)
      throw new Error(
        `${MINIGAME_ERROR_CODES.MENU_ITEM_NOT_FOUND}: Menu item not found`,
      );
    const config = await ctx.db
      .query("challengeConfig")
      .withIndex("by_type", (q) => q.eq("challengeType", "GOOGLE_REVIEW"))
      .first();
    const maxValue = config?.maxValue ?? 200000;
    if (menuItem.price > maxValue) {
      throw new Error(
        `${MINIGAME_ERROR_CODES.DESSERT_VALUE_EXCEEDED}: Dessert price exceeds cap of ${maxValue.toLocaleString()}đ`,
      );
    }
    const identity = await ctx.auth.getUserIdentity();
    if (!identity)
      throw new Error(`${MINIGAME_ERROR_CODES.NOT_AUTHORIZED}: Not authorized`);
    const reviewedById = identity.subject as Id<"users">;
    await ctx.db.patch(submissionId, {
      status: "APPROVED",
      rewardMenuItemId,
      reviewedAt: Date.now(),
      reviewedBy: reviewedById,
      updatedAt: Date.now(),
    });
    await ctx.db.insert("orderItems", {
      orderId: submission.orderId,
      menuItemId: rewardMenuItemId,
      quantity: 1,
      unitPrice: 0,
      status: "SERVED",
      station: menuItem.station ?? "BAR",
      isComp: true,
      compSource: "GOOGLE_REVIEW",
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
    consola.info("Google review approved", {
      submissionId: submissionId.toString(),
      reviewedBy: reviewedById.toString(),
      rewardMenuItemId: rewardMenuItemId.toString(),
      showDate: submission.showDate,
    });
    return submissionId;
  },
});
 
export const rejectGoogleReview = mutation({
  args: {
    submissionId: v.id("challengeSubmissions"),
    notes: v.optional(v.string()),
  },
  handler: async (ctx, { submissionId, notes }) => {
    const submission = await ctx.db.get(submissionId);
    if (!submission)
      throw new Error(
        `${MINIGAME_ERROR_CODES.SUBMISSION_NOT_FOUND}: Submission not found`,
      );
    if (submission.status !== "PENDING")
      throw new Error(`${MINIGAME_ERROR_CODES.NOT_PENDING}: Already reviewed`);
    const identity = await ctx.auth.getUserIdentity();
    if (!identity)
      throw new Error(`${MINIGAME_ERROR_CODES.NOT_AUTHORIZED}: Not authorized`);
    const reviewedById = identity.subject as Id<"users">;
    await ctx.db.patch(submissionId, {
      status: "REJECTED",
      reviewedAt: Date.now(),
      reviewedBy: reviewedById,
      notes: notes ?? undefined,
      updatedAt: Date.now(),
    });
    consola.warn("Google review rejected", {
      submissionId: submissionId.toString(),
      reviewedBy: reviewedById.toString(),
      notes: notes ?? "none",
    });
    return submissionId;
  },
});
 
export const getPendingReviews = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db
      .query("challengeSubmissions")
      .withIndex("by_status", (q) => q.eq("status", "PENDING"))
      .collect();
  },
});
 
export const getTableReviewSubmission = query({
  args: { tableId: v.id("tables"), showDate: v.string() },
  handler: async (ctx, { tableId, showDate }) => {
    return await ctx.db
      .query("challengeSubmissions")
      .withIndex("by_table_show", (q) =>
        q.eq("tableId", tableId).eq("showDate", showDate),
      )
      .first();
  },
});
 
// ─── Challenge Config ─────────────────────────────────────────────────────────
 
export const getConfig = query({
  args: {
    challengeType: v.union(
      v.literal("PHOTO_WALL"),
      v.literal("LUCKY_SPIN"),
      v.literal("GOOGLE_REVIEW"),
    ),
  },
  handler: async (ctx, { challengeType }) => {
    return await ctx.db
      .query("challengeConfig")
      .withIndex("by_type", (q) => q.eq("challengeType", challengeType))
      .first();
  },
});
 
export const updateConfig = mutation({
  args: {
    challengeType: v.union(
      v.literal("PHOTO_WALL"),
      v.literal("LUCKY_SPIN"),
      v.literal("GOOGLE_REVIEW"),
    ),
    enabled: v.optional(v.boolean()),
    maxValue: v.optional(v.number()),
    prizeDescription: v.optional(v.string()),
    steps: v.optional(
      v.array(
        v.object({
          order: v.number(),
          text: v.string(),
          imageUrl: v.optional(v.string()),
        }),
      ),
    ),
  },
  handler: async (ctx, args) => {
    const { challengeType, ...updates } = args;
    const existing = await ctx.db
      .query("challengeConfig")
      .withIndex("by_type", (q) => q.eq("challengeType", challengeType))
      .first();
    if (existing) {
      await ctx.db.patch(existing._id, { ...updates, updatedAt: Date.now() });
      return existing._id;
    }
    return await ctx.db.insert("challengeConfig", {
      challengeType,
      enabled: updates.enabled ?? false,
      maxValue: updates.maxValue,
      prizeDescription: updates.prizeDescription,
      steps: updates.steps ?? [],
      activeForDates: [],
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
  },
});
 
export const getSpinPrizes = query({
  args: {},
  handler: async (ctx) => {
    return await ctx.db
      .query("spinPrizes")
      .withIndex("by_enabled", (q) => q.eq("enabled", true))
      .collect();
  },
});
 
export const upsertSpinPrize = mutation({
  args: {
    id: v.optional(v.id("spinPrizes")),
    label: v.string(),
    prizeType: v.union(
      v.literal("MENU_ITEM"),
      v.literal("DISCOUNT"),
      v.literal("FREE_ITEM"),
    ),
    menuItemId: v.optional(v.id("menuItems")),
    discountPercent: v.optional(v.number()),
    weight: v.number(),
    enabled: v.boolean(),
  },
  handler: async (ctx, args) => {
    const { id, ...updates } = args;
    if (id) {
      await ctx.db.patch(id, { ...updates, updatedAt: Date.now() });
      return id;
    }
    return await ctx.db.insert("spinPrizes", {
      ...updates,
      createdAt: Date.now(),
      updatedAt: Date.now(),
    });
  },
});

git add convex/functions/challenges.ts
git commit -m "feat(minigames): add challenge functions (photo wall, spin, review)"

cd apps/frontend && npm install nuqs

"use client";
 
import { Suspense, useEffect, useState, useTransition } from "react";
import { useRouter } from "next/navigation";
import { useQuery, useMutation } from "convex/react";
import { api } from "~/convex/_generated/api";
import { useTranslations } from "next-intl";
import { useQueryState } from "nuqs";
import { ProfileForm } from "~/components/profile/profile-form";
import { Id } from "~/convex/_generated/dataModel";
 
function OnboardContent({ tableId, token }: { tableId: string; token: string }) {
  const t = useTranslations("onboard");
  const router = useRouter();
  const [isPending, startTransition] = useTransition();
  const getOrCreate = useMutation(api.profiles.getOrCreateProfile);
  const [profileId, setProfileId] = useState<Id<"guestProfiles"> | null>(null);
 
  useEffect(() => {
    if (!token || !tableId) return;
    getOrCreate({ tableId, token }).then((p) => {
      if (p) setProfileId(p._id as Id<"guestProfiles">);
    });
  }, [token, tableId, getOrCreate]);
 
  const profile = useQuery(
    api.profiles.getById,
    profileId ? { id: profileId } : "skip",
  );
 
  if (profile && profile.nickname.length >= 2) {
    startTransition(() => {
      router.push(`/table?tableId=${tableId}&token=${token}&profileId=${profileId}`);
    });
    return null;
  }
 
  return (
    <div className="min-h-screen bg-[#1a1a1a] text-[#e6e6e6] flex flex-col">
      <header className="p-6 text-center">
        <h1 className="font-serif text-[#C5A059] text-2xl">{t("welcomeTitle")}</h1>
        <p className="text-sm text-[#808080] mt-1">{t("welcomeSubtitle")}</p>
      </header>
      <main className="flex-1 px-6 pb-6">
        {profileId && (
          <ProfileForm
            profileId={profileId}
            onComplete={() => {
              startTransition(() => {
                router.push(`/table?tableId=${tableId}&token=${token}&profileId=${profileId}`);
              });
            }}
          />
        )}
      </main>
    </div>
  );
}
 
export default function OnboardPage() {
  const t = useTranslations("onboard");
  const [tableId] = useQueryState("tableId");
  const [token] = useQueryState("token");
 
  if (!tableId || !token) {
    return (
      <div className="min-h-screen flex items-center justify-center bg-[#1a1a1a]">
        <p className="text-[#808080]">{t("loading")}</p>
      </div>
    );
  }
 
  return (
    <Suspense fallback={
      <div className="min-h-screen flex items-center justify-center bg-[#1a1a1a]">
        <p className="text-[#808080]">{t("loading")}</p>
      </div>
    }>
      <OnboardContent tableId={tableId} token={token} />
    </Suspense>
  );
}

"use client";
 
import { useState, useTransition } from "react";
import { useMutation } from "convex/react";
import { api } from "~/convex/_generated/api";
import { useTranslations } from "next-intl";
import { Id } from "~/convex/_generated/dataModel";
import { MoodSelector } from "./mood-selector";
import { OAuthButtons } from "./oauth-buttons";
import { CompleteProfileInputSchema } from "~/lib/schemas/minigames";
import { consola } from "consola";
 
export function ProfileForm({
  profileId,
  onComplete,
}: {
  profileId: Id<"guestProfiles">;
  onComplete: () => void;
}) {
  const t = useTranslations("profile");
  const [nickname, setNickname] = useState("");
  const [origin, setOrigin] = useState("");
  const [moodTags, setMoodTags] = useState<string[]>([]);
  const [bio, setBio] = useState("");
  const [oauthData, setOauthData] = useState<{
    googleId?: string; facebookId?: string; email?: string; avatarUrl?: string;
  }>({});
  const [isPending, startTransition] = useTransition();
  const completeProfile = useMutation(api.profiles.completeProfile);
 
  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    const input = { profileId, nickname, origin, moodTags, ...oauthData, bio: bio || undefined };
    const parsed = CompleteProfileInputSchema.safeParse(input);
    if (!parsed.success) {
      consola.warn("Profile validation failed", { errors: parsed.error.errors });
      return;
    }
    startTransition(async () => {
      try {
        await completeProfile(input);
        onComplete();
      } catch (err) {
        consola.error("Profile creation failed", { error: err instanceof Error ? err.message : String(err) });
      }
    });
  }
 
  function handleOAuthSuccess(data: typeof oauthData) {
    setOauthData(data);
    if (data.nickname) setNickname(data.nickname);
    if (data.origin) setOrigin(data.origin);
  }
 
  return (
    <form onSubmit={handleSubmit} className="space-y-6">
      <OAuthButtons onSuccess={handleOAuthSuccess} />
      <div className="border-t border-[#4d4d4d] pt-6 space-y-4">
        <div>
          <label className="block text-sm text-[#808080] mb-1">{t("nicknameLabel")}</label>
          <input type="text" value={nickname} onChange={(e) => setNickname(e.target.value)}
            placeholder={t("nicknamePlaceholder")} maxLength={20}
            className="w-full bg-[#2E2E2E] border border-[#4d4d4d] rounded px-4 py-3 text-[#e6e6e6]" />
        </div>
        <div>
          <label className="block text-sm text-[#808080] mb-1">{t("originLabel")}</label>
          <input type="text" value={origin} onChange={(e) => setOrigin(e.target.value)}
            placeholder={t("originPlaceholder")} maxLength={100}
            className="w-full bg-[#2E2E2E] border border-[#4d4d4d] rounded px-4 py-3 text-[#e6e6e6]" />
        </div>
        <MoodSelector selected={moodTags} onChange={setMoodTags} />
        <div>
          <label className="block text-sm text-[#808080] mb-1">{t("bioLabel")} ({t("optional")})</label>
          <textarea value={bio} onChange={(e) => setBio(e.target.value)}
            placeholder={t("bioPlaceholder")} maxLength={280} rows={3}
            className="w-full bg-[#2E2E2E] border border-[#4d4d4d] rounded px-4 py-3 text-[#e6e6e6] resize-none" />
        </div>
      </div>
      <button type="submit" disabled={isPending}
        className="w-full bg-[#C5A059] text-[#1a1a1a] py-4 rounded-lg font-bold text-lg disabled:opacity-50 transition-opacity">
        {isPending ? t("creating") : t("createButton")}
      </button>
    </form>
  );
}

"use client";
 
import { useState, useTransition } from "react";
import { useTranslations } from "next-intl";
import { IconSymbol } from "~/components/ui/iconSymbol";
import { consola } from "consola";
 
interface OAuthSuccessData {
  googleId?: string; facebookId?: string; email?: string; avatarUrl?: string; nickname?: string;
}
 
export function OAuthButtons({ onSuccess }: { onSuccess: (data: OAuthSuccessData) => void }) {
  const t = useTranslations("profile.oauth");
  const [isLoading, setIsLoading] = useState<string | null>(null);
  const [, startTransition] = useTransition();
 
  async function handleGoogle() {
    setIsLoading("google");
    startTransition(async () => {
      try {
        // [P0 GAP] Clerk OAuth not implemented — simulation only
        consola.info("OAuth simulation: Google");
        onSuccess({ googleId: `simulated_${crypto.randomUUID()}`, email: "guest@example.com", avatarUrl: "", nickname: "" });
      } catch (err) {
        consola.error("Google OAuth failed", { error: err instanceof Error ? err.message : String(err) });
      } finally {
        setIsLoading(null);
      }
    });
  }
 
  async function handleFacebook() {
    setIsLoading("facebook");
    startTransition(async () => {
      try {
        // [P0 GAP] Clerk OAuth not implemented — simulation only
        consola.info("OAuth simulation: Facebook");
        onSuccess({ facebookId: `simulated_${crypto.randomUUID()}`, email: "guest@example.com", avatarUrl: "", nickname: "" });
      } catch (err) {
        consola.error("Facebook OAuth failed", { error: err instanceof Error ? err.message : String(err) });
      } finally {
        setIsLoading(null);
      }
    });
  }
 
  return (
    <div className="space-y-3">
      <button type="button" onClick={handleGoogle} disabled={!!isLoading}
        className="w-full flex items-center justify-center gap-3 bg-white text-gray-800 py-3 rounded-lg font-medium border border-gray-300 disabled:opacity-50">
        <IconSymbol name="google" size={20} />
        {isLoading === "google" ? t("loading") : t("continueWithGoogle")}
      </button>
      <button type="button" onClick={handleFacebook} disabled={!!isLoading}
        className="w-full flex items-center justify-center gap-3 bg-blue-600 text-white py-3 rounded-lg font-medium disabled:opacity-50">
        <IconSymbol name="facebook" size={20} />
        {isLoading === "facebook" ? t("loading") : t("continueWithFacebook")}
      </button>
      <div className="flex items-center gap-3">
        <div className="flex-1 border-t border-[#4d4d4d]" />
        <span className="text-xs text-[#808080]">{t("orContinue")}</span>
        <div className="flex-1 border-t border-[#4d4d4d]" />
      </div>
    </div>
  );
}