fix: clean up ClickHouse analytics rows on user/team/website/link/pixel deletion

src/app/(collect)/p/[slug]/route.ts

@@ -21,6 +21,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ slug
         return findPixel({
           where: {
             slug,
+            deletedAt: null,
           },
         });
       },
@@ -34,6 +35,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ slug
     pixel = await findPixel({
       where: {
         slug,
+        deletedAt: null,
       },
     });
 

src/app/(collect)/q/[slug]/route.ts

@@ -19,6 +19,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ slug
         return findLink({
           where: {
             slug,
+            deletedAt: null,
           },
         });
       },
@@ -32,6 +33,7 @@ export async function GET(request: Request, { params }: { params: Promise<{ slug
     link = await findLink({
       where: {
         slug,
+        deletedAt: null,
       },
     });
 

src/lib/clickhouse.ts

@@ -421,6 +421,32 @@ async function insert(table: string, values: any[]) {
   return clickhouse.insert({ table, values, format: 'JSONEachRow' });
 }
 
+async function deleteByWebsiteIds(websiteIds: string[]) {
+  if (!enabled || websiteIds.length === 0) return;
+
+  await connect();
+
+  // MV target tables need explicit DELETE — CH MVs don't cascade mutations.
+  const tables = [
+    'website_event',
+    'event_data',
+    'session_data',
+    'session_replay',
+    'website_revenue',
+    'website_event_stats_hourly',
+    'event_data_pivot',
+  ];
+
+  await Promise.all(
+    tables.map(table =>
+      clickhouse.command({
+        query: `ALTER TABLE ${table} DELETE WHERE website_id IN {websiteIds:Array(UUID)}`,
+        query_params: { websiteIds },
+      }),
+    ),
+  );
+}
+
 async function findUnique(data: any[]) {
   if (data.length > 1) {
     throw `${data.length} records found when expecting 1.`;
@@ -458,4 +484,5 @@ export default {
   findFirst,
   rawQuery,
   insert,
+  deleteByWebsiteIds,
 };

src/queries/prisma/link.ts

@@ -1,5 +1,7 @@
 import type { Prisma } from '@/generated/prisma/client';
+import clickhouse from '@/lib/clickhouse';
 import prisma from '@/lib/prisma';
+import redis from '@/lib/redis';
 import type { QueryFilters } from '@/lib/types';
 
 export async function findLink(criteria: Prisma.LinkFindUniqueArgs) {
@@ -47,6 +49,7 @@ export async function getTeamLinks(teamId: string, filters?: QueryFilters) {
     {
       where: {
         teamId,
+        deletedAt: null,
       },
     },
     filters,
@@ -58,9 +61,29 @@ export async function createLink(data: Prisma.LinkUncheckedCreateInput) {
 }
 
 export async function updateLink(linkId: string, data: any) {
-  return prisma.client.link.update({ where: { id: linkId }, data });
+  // Fetch the old slug so we can invalidate its cache entry if the slug changes.
+  const previous = await prisma.client.link.findUnique({
+    where: { id: linkId },
+    select: { slug: true },
+  });
+  const link = await prisma.client.link.update({ where: { id: linkId }, data });
+  if (redis.enabled) {
+    await redis.client.del(`link:${link.slug}`);
+    if (previous && previous.slug !== link.slug) {
+      await redis.client.del(`link:${previous.slug}`);
+    }
+  }
+  return link;
 }
 
 export async function deleteLink(linkId: string) {
-  return prisma.client.link.delete({ where: { id: linkId } });
+  const cloudMode = !!process.env.CLOUD_MODE;
+  const link = await prisma.client.link.delete({ where: { id: linkId } });
+  if (redis.enabled) {
+    await redis.client.del(`link:${link.slug}`);
+  }
+  if (!cloudMode) {
+    await clickhouse.deleteByWebsiteIds([link.id]);
+  }
+  return link;
 }

src/queries/prisma/pixel.ts

@@ -1,5 +1,7 @@
 import type { Prisma } from '@/generated/prisma/client';
+import clickhouse from '@/lib/clickhouse';
 import prisma from '@/lib/prisma';
+import redis from '@/lib/redis';
 import type { QueryFilters } from '@/lib/types';
 
 export async function findPixel(criteria: Prisma.PixelFindUniqueArgs) {
@@ -30,6 +32,7 @@ export async function getUserPixels(userId: string, filters?: QueryFilters) {
     {
       where: {
         userId,
+        deletedAt: null,
       },
     },
     filters,
@@ -41,6 +44,7 @@ export async function getTeamPixels(teamId: string, filters?: QueryFilters) {
     {
       where: {
         teamId,
+        deletedAt: null,
       },
     },
     filters,
@@ -52,9 +56,29 @@ export async function createPixel(data: Prisma.PixelUncheckedCreateInput) {
 }
 
 export async function updatePixel(pixelId: string, data: any) {
-  return prisma.client.pixel.update({ where: { id: pixelId }, data });
+  // Fetch the old slug so we can invalidate its cache entry if the slug changes.
+  const previous = await prisma.client.pixel.findUnique({
+    where: { id: pixelId },
+    select: { slug: true },
+  });
+  const pixel = await prisma.client.pixel.update({ where: { id: pixelId }, data });
+  if (redis.enabled) {
+    await redis.client.del(`pixel:${pixel.slug}`);
+    if (previous && previous.slug !== pixel.slug) {
+      await redis.client.del(`pixel:${previous.slug}`);
+    }
+  }
+  return pixel;
 }
 
 export async function deletePixel(pixelId: string) {
-  return prisma.client.pixel.delete({ where: { id: pixelId } });
+  const cloudMode = !!process.env.CLOUD_MODE;
+  const pixel = await prisma.client.pixel.delete({ where: { id: pixelId } });
+  if (redis.enabled) {
+    await redis.client.del(`pixel:${pixel.slug}`);
+  }
+  if (!cloudMode) {
+    await clickhouse.deleteByWebsiteIds([pixel.id]);
+  }
+  return pixel;
 }

src/queries/prisma/team.ts

@@ -1,7 +1,9 @@
 import { Prisma, type Team } from '@/generated/prisma/client';
+import clickhouse from '@/lib/clickhouse';
 import { ROLES } from '@/lib/constants';
 import { uuid } from '@/lib/crypto';
 import prisma from '@/lib/prisma';
+import redis from '@/lib/redis';
 import type { PageResult, QueryFilters } from '@/lib/types';
 
 import TeamFindManyArgs = Prisma.TeamFindManyArgs;
@@ -144,6 +146,44 @@ export async function deleteTeam(teamId: string) {
   const { client, transaction } = prisma;
   const cloudMode = !!process.env.CLOUD_MODE;
 
+  const [links, pixels, boards, websites] = await Promise.all([
+    client.link.findMany({
+      where: { teamId },
+      select: { id: true, slug: true, deletedAt: true },
+    }),
+    client.pixel.findMany({
+      where: { teamId },
+      select: { id: true, slug: true, deletedAt: true },
+    }),
+    client.board.findMany({ where: { teamId }, select: { id: true } }),
+    client.website.findMany({ where: { teamId }, select: { id: true, deletedAt: true } }),
+  ]);
+  const websiteIds = websites.map(w => w.id);
+  const linkIds = links.map(l => l.id);
+  const pixelIds = pixels.map(p => p.id);
+  const entityIds = [
+    ...linkIds,
+    ...pixelIds,
+    ...boards.map(b => b.id),
+    ...websiteIds,
+  ];
+  // Boards have no CH events; /api/send writes link/pixel ids as website_id.
+  const clickhouseIds = [...websiteIds, ...linkIds, ...pixelIds];
+  // Only invalidate Redis cache for slugs/keys that are still live (not already soft-deleted).
+  const linkSlugs = links.filter(l => !l.deletedAt).map(l => l.slug);
+  const pixelSlugs = pixels.filter(p => !p.deletedAt).map(p => p.slug);
+  const liveWebsiteIds = websites.filter(w => !w.deletedAt).map(w => w.id);
+
+  const invalidateRedis = async () => {
+    if (redis.enabled && (linkSlugs.length || pixelSlugs.length || liveWebsiteIds.length)) {
+      await Promise.all([
+        ...linkSlugs.map(slug => redis.client.del(`link:${slug}`)),
+        ...pixelSlugs.map(slug => redis.client.del(`pixel:${slug}`)),
+        ...liveWebsiteIds.map(id => redis.client.del(`website:${id}`)),
+      ]);
+    }
+  };
+
   if (cloudMode) {
     return transaction([
       client.team.update({
@@ -154,7 +194,25 @@ export async function deleteTeam(teamId: string) {
           id: teamId,
         },
       }),
-    ]);
+      client.share.deleteMany({ where: { entityId: { in: entityIds } } }),
+      // deletedAt: null avoids restamping rows that were already soft-deleted earlier.
+      client.link.updateMany({
+        data: { deletedAt: new Date() },
+        where: { teamId, deletedAt: null },
+      }),
+      client.pixel.updateMany({
+        data: { deletedAt: new Date() },
+        where: { teamId, deletedAt: null },
+      }),
+      client.board.deleteMany({ where: { teamId } }),
+      client.website.updateMany({
+        data: { deletedAt: new Date() },
+        where: { teamId, deletedAt: null },
+      }),
+    ]).then(async result => {
+      await invalidateRedis();
+      return result;
+    });
   }
 
   return transaction([
@@ -163,10 +221,29 @@ export async function deleteTeam(teamId: string) {
         teamId,
       },
     }),
+    client.share.deleteMany({ where: { entityId: { in: entityIds } } }),
+    client.link.deleteMany({ where: { teamId } }),
+    client.pixel.deleteMany({ where: { teamId } }),
+    client.board.deleteMany({ where: { teamId } }),
+    // Mirror deleteWebsite cleanup order for team-owned websites:
+    client.sessionReplaySaved.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.sessionReplay.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.revenue.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.eventData.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.sessionData.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.websiteEvent.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.session.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.report.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.segment.deleteMany({ where: { websiteId: { in: websiteIds } } }),
+    client.website.deleteMany({ where: { id: { in: websiteIds } } }),
     client.team.delete({
       where: {
         id: teamId,
       },
     }),
-  ]);
+  ]).then(async result => {
+    await invalidateRedis();
+    await clickhouse.deleteByWebsiteIds(clickhouseIds);
+    return result;
+  });
 }