fix: invalidate Redis cache on link/pixel update + delete

Address Greptile review feedback on umami-software#4245.

- deleteLink and deletePixel now redis.client.del('link:slug' / 'pixel:slug')
  using the slug returned by Prisma's delete(). Previously the row was hard-
  deleted but the Redis cache (24h TTL) kept serving the slug, so /q/<slug>
  and /p/<slug> kept firing for up to a day after deletion.
- updateLink and updatePixel now invalidate the cache for the current slug,
  and additionally for the previous slug if the slug was changed. Previously
  changing a link's destination URL or slug left the public cache stale.
- Cloud-mode link.updateMany and pixel.updateMany in deleteUser now spread
  ownedFilter (which is { userId } in cloud mode) instead of hardcoding
  { userId }, so the cleanup intent stays consistent if ownedFilter ever
  evolves.

Verified empirically against a Docker Postgres + Redis: deleted link's
/q/<slug> returns 404 immediately (was: still redirected to old URL for 24h);
slug rename invalidates both old and new cache keys.

Author: anvme

src/queries/prisma/link.ts

@@ -1,5 +1,6 @@
 import type { Prisma } from '@/generated/prisma/client';
 import prisma from '@/lib/prisma';
+import redis from '@/lib/redis';
 import type { QueryFilters } from '@/lib/types';
 
 export async function findLink(criteria: Prisma.LinkFindUniqueArgs) {
@@ -59,9 +60,25 @@ 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 link = await prisma.client.link.delete({ where: { id: linkId } });
+  if (redis.enabled) {
+    await redis.client.del(`link:${link.slug}`);
+  }
+  return link;
 }

src/queries/prisma/pixel.ts

@@ -1,5 +1,6 @@
 import type { Prisma } from '@/generated/prisma/client';
 import prisma from '@/lib/prisma';
+import redis from '@/lib/redis';
 import type { QueryFilters } from '@/lib/types';
 
 export async function findPixel(criteria: Prisma.PixelFindUniqueArgs) {
@@ -54,9 +55,25 @@ 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 pixel = await prisma.client.pixel.delete({ where: { id: pixelId } });
+  if (redis.enabled) {
+    await redis.client.del(`pixel:${pixel.slug}`);
+  }
+  return pixel;
 }

src/queries/prisma/user.ts

@@ -180,13 +180,15 @@ export async function deleteUser(userId: string) {
       }),
       client.share.deleteMany({ where: { entityId: { in: entityIds } } }),
       // deletedAt: null avoids restamping rows that were already soft-deleted earlier.
+      // Spread `ownedFilter` (which is `{ userId }` in cloud mode) for consistency
+      // with everything else in the function.
       client.link.updateMany({
         data: { deletedAt: new Date() },
-        where: { userId, deletedAt: null },
+        where: { ...ownedFilter, deletedAt: null },
       }),
       client.pixel.updateMany({
         data: { deletedAt: new Date() },
-        where: { userId, deletedAt: null },
+        where: { ...ownedFilter, deletedAt: null },
       }),
       client.board.deleteMany({ where: { userId } }),
     ]).then(async result => {