feat: implement A/B testing for link placements (#687)

Author: Dev1822

app/[username]/page.tsx

@@ -7,6 +7,22 @@ import { ProfileCard } from "./ProfileCard";
 import { ProfileFooter } from "./ProfileFooter";
 import { resolveUserByUsername } from "@/lib/userLookup";
 import { ShareProfileButton } from "./ShareProfileButton";
+import { cookies } from "next/headers";
+import type { Link } from "./types/type";
+
+interface ABTestSlot {
+  __abTestSlot: string;
+}
+
+function getDeterministicVariant(visitorId: string, parentId: string): "A" | "B" {
+  let hash = 0;
+  const str = visitorId + parentId;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash) % 2 === 0 ? "A" : "B";
+}
 
 export async function generateMetadata({ params }: { params: Promise<{ username: string }> }) {
     try {
@@ -118,12 +134,96 @@ export default async function PublicProfile({
     bgStyle.backgroundImage = "linear-gradient(180deg, #09090b 0%, #1e1b4b 100%)";
   }
 
+  const cookieStore = await cookies();
+
   const now = new Date();
-  const activeLinks = (user.links || []).filter((link: { startDate?: Date | null; endDate?: Date | null }) => {
-    if (link.startDate && new Date(link.startDate) > now) return false;
-    if (link.endDate && new Date(link.endDate) < now) return false;
+  const isActive = (l: Link) => {
+    if (l.startDate && new Date(l.startDate) > now) return false;
+    if (l.endDate && new Date(l.endDate) < now) return false;
     return true;
-  });
+  };
+
+  const selectVariant = (parentId: string, variants: Link[], visitorId: string): Link => {
+    const cookieVal = cookieStore.get(`abTest_${parentId}`)?.value;
+    if (cookieVal === "A" || cookieVal === "B") {
+      const picked = variants.find((v) => v.abTestVariant === cookieVal);
+      if (picked) return picked;
+    }
+    const chosenVariant = getDeterministicVariant(visitorId, parentId);
+    return variants.find((v) => v.abTestVariant === chosenVariant) || variants[0];
+  };
+
+  const visitorId = cookieStore.get("visitor_id")?.value || "default-visitor";
+
+  const rawLinks = (user.links || []) as Link[];
+  const abTestGroups = new Map<string, Link[]>();
+  const preFilteredLinks: (Link | ABTestSlot)[] = [];
+
+  for (const link of rawLinks) {
+    if (link.abTestParentId) {
+      if (!abTestGroups.has(link.abTestParentId)) {
+        abTestGroups.set(link.abTestParentId, []);
+        preFilteredLinks.push({ __abTestSlot: link.abTestParentId });
+      }
+      abTestGroups.get(link.abTestParentId)!.push(link);
+    } else if (link.isGroup) {
+      const children = (link.children || []) as Link[];
+      const newChildren: (Link | ABTestSlot)[] = [];
+      const childrenGroups = new Map<string, Link[]>();
+      
+      for (const child of children) {
+        if (child.abTestParentId) {
+          if (!childrenGroups.has(child.abTestParentId)) {
+            childrenGroups.set(child.abTestParentId, []);
+            newChildren.push({ __abTestSlot: child.abTestParentId });
+          }
+          childrenGroups.get(child.abTestParentId)!.push(child);
+        } else {
+          newChildren.push(child);
+        }
+      }
+      
+      for (const [parentId, variants] of childrenGroups.entries()) {
+        const activeVariants = variants.filter(isActive);
+        const slot = newChildren.findIndex((l) => "__abTestSlot" in l && (l as any).__abTestSlot === parentId);
+        if (activeVariants.length === 0) {
+          if (slot !== -1) {
+            newChildren.splice(slot, 1);
+          }
+        } else {
+          const picked = selectVariant(parentId, activeVariants, visitorId);
+          if (slot !== -1) {
+            newChildren.splice(slot, 1, picked);
+          } else {
+            newChildren.push(picked);
+          }
+        }
+      }
+      
+      preFilteredLinks.push({ ...link, children: newChildren as Link[] });
+    } else {
+      preFilteredLinks.push(link);
+    }
+  }
+
+  for (const [parentId, variants] of abTestGroups.entries()) {
+    const activeVariants = variants.filter(isActive);
+    const slot = preFilteredLinks.findIndex((l) => "__abTestSlot" in l && (l as any).__abTestSlot === parentId);
+    if (activeVariants.length === 0) {
+      if (slot !== -1) {
+        preFilteredLinks.splice(slot, 1);
+      }
+    } else {
+      const picked = selectVariant(parentId, activeVariants, visitorId);
+      if (slot !== -1) {
+        preFilteredLinks.splice(slot, 1, picked);
+      } else {
+        preFilteredLinks.push(picked);
+      }
+    }
+  }
+
+  const activeLinks = (preFilteredLinks as Link[]).filter(isActive);
 
   return (
     <main className={`min-h-screen relative px-4 py-16 theme-${user.theme || "default"}`}>

app/[username]/types/type.d.ts

@@ -16,7 +16,8 @@ export type Link = {
     startDate?: Date | null;
     endDate?: Date | null;
     updatedAt?: Date;
-    userId: string;
+    abTestVariant?: "A" | "B" | null;
+    abTestParentId?: string | null;
 }
 
 export type PlatformParams = {

app/api/links/[id]/route.ts

@@ -2,6 +2,16 @@ import { NextResponse } from "next/server";
 import { getServerSession } from "next-auth";
 import { authOptions } from "@/lib/auth";
 import prisma from "@/lib/prisma";
+
+const getMembership = async (userId: string, workspaceId: string) => {
+  return await prisma.workspaceMember.findFirst({
+    where: { userId, workspaceId },
+  });
+};
+
+
+
+
 import { Prisma } from "@prisma/client";
 
 import { validatePlatformUrl, detectPlatform, slugifyPlatform, isKnownPlatform, type Platform } from "@/lib/platforms";
@@ -53,12 +63,25 @@ export async function PUT(
     ? rawExplicitPlatform as Platform
     : null;
 
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email },
+    select: { id: true },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
   const link = await prisma.link.findUnique({
     where: { id },
-    include: { user: true },
   });
 
-  if (!link || link.user.email !== session.user.email) {
+  if (!link) {
+    return NextResponse.json({ error: "Not Found" }, { status: 404 });
+  }
+
+  const membership = await getMembership(user.id, link.workspaceId);
+  if (!membership) {
     return NextResponse.json({ error: "Forbidden" }, { status: 403 });
   }
 
@@ -76,7 +99,7 @@ export async function PUT(
       data.parentId = null;
     } else {
       const parentGroup = await prisma.link.findFirst({
-        where: { id: parentId, userId: link.userId, isGroup: true },
+        where: { id: parentId, workspaceId: link.workspaceId, isGroup: true },
       });
       if (!parentGroup) {
         return NextResponse.json(
@@ -197,7 +220,7 @@ export async function PUT(
             const proposedRoute = link.alias || data.platform;
             const existingLink = await tx.link.findFirst({
                 where: {
-                    userId: link.userId,
+                    workspaceId: link.workspaceId,
                     id: { not: link.id },
                     isGroup: false,
                     OR: [
@@ -277,12 +300,25 @@ export async function DELETE(
     // No body is fine for regular link deletion
   }
 
+  const user = await prisma.user.findUnique({
+    where: { email: session.user.email },
+    select: { id: true },
+  });
+
+  if (!user) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
   const link = await prisma.link.findUnique({
     where: { id },
-    include: { user: true },
   });
 
-  if (!link || link.user.email !== session.user.email) {
+  if (!link) {
+    return NextResponse.json({ error: "Not Found" }, { status: 404 });
+  }
+
+  const membership = await getMembership(user.id, link.workspaceId);
+  if (!membership) {
     return NextResponse.json({ error: "Forbidden" }, { status: 403 });
   }
 
@@ -292,17 +328,17 @@ export async function DELETE(
       if (deleteChildren) {
         // Delete all children first, then the group
         await tx.link.deleteMany({
-          where: { parentId: id, userId: link.userId },
+          where: { parentId: id, workspaceId: link.workspaceId },
         });
       } else {
         // Ungroup: set children's parentId to null and reassign positions
         const children = await tx.link.findMany({
-            where: { parentId: id, userId: link.userId },
+            where: { parentId: id, workspaceId: link.workspaceId },
             orderBy: { position: 'asc' },
         });
 
         const maxOrder = await tx.link.aggregate({
-            where: { userId: link.userId, parentId: null },
+            where: { workspaceId: link.workspaceId, parentId: null },
             _max: { position: true },
         });
 
@@ -321,13 +357,47 @@ export async function DELETE(
     return NextResponse.json({ success: true });
   }
 
+  // A/B test variant reversion logic
+  if (link.abTestParentId) {
+    const parentId = link.abTestParentId;
+    await prisma.$transaction(async (tx) => {
+      // Find the sibling variant
+      const sibling = await tx.link.findFirst({
+        where: {
+          abTestParentId: parentId,
+          id: { not: id },
+        },
+      });
+
+      if (sibling) {
+        // Revert sibling to a standard link
+        let cleanPlatform = sibling.platform;
+        if (cleanPlatform.endsWith("__ab_b")) {
+          cleanPlatform = cleanPlatform.replace(/__ab_b$/, "");
+        }
+        await tx.link.update({
+          where: { id: sibling.id },
+          data: {
+            abTestVariant: null,
+            abTestParentId: null,
+            platform: cleanPlatform,
+          },
+        });
+      }
+
+      // Delete the requested link
+      await tx.link.delete({
+        where: { id },
+      });
+    });
+
+    return NextResponse.json({ success: true });
+  }
+
   // Regular link deletion
   await prisma.link.delete({
     where: { id },
   });
 
   return NextResponse.json({ success: true });
 }
-
-
-