Block 8 complete: streaks, notifications, referrals, premium identity, gamification

src/app/api/referrals/claim/route.ts

@@ -0,0 +1,110 @@
+import { NextRequest, NextResponse } from "next/server";
+import { prisma } from "@/lib/prisma";
+
+// Decode a base62 referral code back to a userId prefix for lookup
+function decodeBase62Lookup(code: string): number {
+  const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  let hash = 0;
+  for (const ch of code) {
+    const idx = chars.indexOf(ch);
+    if (idx === -1) return -1;
+    hash = hash * 62 + idx;
+  }
+  return hash >>> 0;
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { code } = body;
+
+    if (!code || typeof code !== "string") {
+      return NextResponse.json(
+        { error: "Referral code is required" },
+        { status: 400 }
+      );
+    }
+
+    // In a real system, you'd look up the referrer by their stored referral code.
+    // For simplicity, we encode the userId in the code. We need to find the user
+    // whose userId produces this code. Since encodeBase62 uses a hash, we
+    // can't reverse it perfectly. Instead, we iterate active users.
+    // A production approach: store referral codes in a dedicated table or column.
+    // For now, we'll iterate through users and find a match.
+    const users = await prisma.user.findMany({
+      select: { id: true },
+    });
+
+    // Recreate the encode logic to find the matching user
+    function encodeForMatch(id: string): string {
+      const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+      let hash = 0;
+      for (let i = 0; i < Math.min(id.length, 10); i++) {
+        hash = (hash * 31 + id.charCodeAt(i)) >>> 0;
+      }
+      let result = "";
+      let h = hash;
+      while (result.length < 6) {
+        result = chars[h % 62] + result;
+        h = Math.floor(h / 62);
+        if (h === 0 && result.length < 6) {
+          h = Math.floor(Math.random() * 62 ** (6 - result.length));
+        }
+      }
+      return result;
+    }
+
+    let referrerId: string | null = null;
+    for (const u of users) {
+      if (encodeForMatch(u.id) === code) {
+        referrerId = u.id;
+        break;
+      }
+    }
+
+    if (!referrerId) {
+      return NextResponse.json(
+        { error: "Invalid referral code" },
+        { status: 400 }
+      );
+    }
+
+    // Save the referral code in a cookie/localStorage so when user registers,
+    // the newly created user can be linked. For now, we just create a placeholder
+    // "pending" referral. The actual linking happens when the user registers
+    // and passes the referral code again (to be paired via the referred user's ID).
+    // Since we don't have a "referredId" yet, we store a temporary token.
+    const tempToken = `pending_${referrerId}_${Date.now()}`;
+
+    // Check if this referrer already has a pending referral with this temp token
+    const existing = await prisma.referral.findFirst({
+      where: { referrerId, status: "pending" },
+      orderBy: { createdAt: "desc" },
+    });
+
+    // Store in a lightweight way — we'll use the Referral model with a placeholder referredId
+    // The referredId will be updated when registration completes.
+    // For production, a ReferralClaimToken model would be better.
+    const referral = await prisma.referral.create({
+      data: {
+        referrerId,
+        referredId: `pending_${tempToken}`, // placeholder, will be updated on registration
+        status: "pending",
+        rewardFlh: 0,
+      },
+    });
+
+    return NextResponse.json({
+      success: true,
+      message: "Referral code applied! You'll get 1000 FLH when you sign up.",
+      referralId: referral.id,
+      tempToken,
+    });
+  } catch (error) {
+    console.error("Referral claim error:", error);
+    return NextResponse.json(
+      { error: "Failed to claim referral" },
+      { status: 500 }
+    );
+  }
+}