diff --git a/CLAUDE.md b/CLAUDE.md index 11d4c61..6651997 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -104,7 +104,7 @@ Despite `next.config.ts`'s `output: "standalone"` and the original stack researc **Runs as 3 load-balanced replicas, not a single container (since 2026-08-16, Gitea #26).** `docker/docker-compose.yml` defines `pawfeed-1`/`pawfeed-2`/`pawfeed-3` (via the `x-pawfeed-common` YAML anchor) instead of one `pawfeed` service — Next.js standalone output is single-process (`node server.js`), so one container only ever used one CPU core regardless of how many the NAS has. A load test on 2026-08-15 hit a hard ceiling at ~60–65 req/sec with one core pegged at 133% while 3 cores sat idle; splitting into 3 replicas fixed it (confirmed via a follow-up load test showing ~100% CPU spread evenly across all three). Nginx Proxy Manager (container `nginx-app-1` on this NAS, admin UI at `192.168.1.222:81`) load-balances across them via a `least_conn` upstream block — that block lives in `/Docker-Data/nginxproxymanager/data/nginx/custom/http_top.conf` on the NAS host (an nginx `upstream {}` is only valid in the `http{}` context, which NPM's per-host "Custom Nginx Configuration" field can't reach — that field only writes into the `server{}`/`location{}` context, and holds the `proxy_pass http://pawfeed_upstream;` override for the `pawfeed.org` Proxy Host instead). Full runbook, decisions, and risk notes: `docker/SCALING-ROADMAP.md`. **Deploying a config or code change means rebuilding all 3 replicas** — there is no separate single-container path anymore, and NPM's proxy target is `pawfeed_upstream`, not a bare `pawfeed:3000` hostname. Use `./docker/rolling-deploy.sh` for deploys against the live site — it rebuilds the shared `pawfeed:latest` image once, then restarts `pawfeed-1`/`2`/`3` one at a time, gated on each becoming `healthy` per the Docker `healthcheck` (`GET /api/health`, a dependency-free liveness check — see `src/app/api/health/route.ts`) before moving to the next, so at least 2 replicas always serve traffic. Verified zero-downtime on 2026-08-16 (continuous curl monitoring showed unbroken HTTP 200 through a full rolling deploy). `docker compose up -d --build` (`start.sh`) still works but restarts all 3 at once — only use it for first-time setup or when a brief outage is acceptable. `src/lib/prisma.ts`'s Prisma pg pool size is capped per-replica via `DB_POOL_MAX` (compose sets `10`) so 3 replicas stay well under the Supabase pooler's client-connection limit. -`src/app/api/cron/trim-feeds/route.ts` trims each pet's Redis feed sorted set to the 90-day retention window and expects a `CRON_SECRET` bearer token. `vercel.json`'s `crons` array that points at it is **inert** on this self-hosted deployment — nothing calls this route yet. It needs an external trigger (e.g. a NAS-side cron job hitting the route with the secret header) before it actually runs. +**Cron jobs run from the NAS crontab** (user `daniel`, `crontab -l`), not from `vercel.json` (whose `crons` array is inert here). Each entry calls `docker/run-cron.sh /api/cron/`, which reads `CRON_SECRET` from `docker/.env`, hits the route with the bearer token via the DDNS host (`--resolve` to localhost — plain `pawfeed.org` fails TLS from the NAS) and logs every run with status + body to `docker/cron.log`. Current schedule: `trim-feeds` 04:00 (Redis feeds → 90 days), `cleanup-stories` 04:30 (deletes stories older than 7 days incl. views, paws, comments, Supabase image and Mux asset — `src/lib/story-cleanup.ts`, max 200 per run), `anniversaries` 08:00, `pet-suggestions` Mondays 09:00, plus `docker/backup-db.sh` 03:00. A new cron route needs a new crontab line on the NAS — it does not run otherwise. ### Directories that are not app code diff --git a/mobile/found.md b/mobile/found.md index 3b0a6e4..932119d 100644 --- a/mobile/found.md +++ b/mobile/found.md @@ -159,7 +159,7 @@ Neu 7: - [x] Nutzerfeedback - Story löschbar ? wie kann man die story löschen, falls man mal was falsches in die story geladen hat ? → Gab es bisher nirgends. Neu: Server `stories.delete` (nur Owner; löscht Aufrufe — `StoryView` hat bewusst kein Cascade —, dann die Story, Pfoten/Kommentare per Cascade; danach Bild in Supabase Storage bzw. Mux-Asset best-effort). Web: Papierkorb neben der Zuschauerzahl in der eigenen Story + Rückfrage (`AlertDialog`), Bild-Timer pausiert während der Rückfrage, gelöscht wird die beim Antippen gemerkte Story-ID. App: gleicher Papierkorb + native Rückfrage, Timer pausiert. Nach dem Löschen springt der Viewer zur nächsten Story bzw. schließt, wenn keine mehr da ist. 5 neue Tests in `src/__tests__/stories.test.ts`. Nicht auf einem Gerät getestet. Commit `81d9c6d`, live (Web + OTA Runtime 1.0.6: Android `49757586-c443-4952-a679-c66a4225ef82`, iOS `48d22b11-abc9-4c75-be52-a122b0130c5e`). - [ ] Storys nur für Ersteller länger einsehbar wegen den Kommentaren (7Tage) - → Noch offen. Befund: abgelaufene Storys werden nie gelöscht (Einträge, Bilder, Mux-Videos bleiben liegen) — Vorschlag: grauer Ring "Deine Story" 7 Tage für den Ersteller, danach Aufräum-Cron (braucht einen Auslöser auf dem NAS, die bestehenden Cron-Routen haben keinen) + Satz unter "Speicherdauer" in der Datenschutzerklärung. + → Noch offen. Befund: abgelaufene Storys werden nie gelöscht (Einträge, Bilder, Mux-Videos bleiben liegen) — Vorschlag: grauer Ring "Deine Story" 7 Tage für den Ersteller, danach Aufräum-Cron (braucht einen Auslöser auf dem NAS, die bestehenden Cron-Routen haben keinen) + Satz unter "Speicherdauer" in der Datenschutzerklärung. **Teil erledigt (02.10.):** Aufräum-Job gebaut — `/api/cron/cleanup-stories` löscht Storys älter als 7 Tage komplett (Aufrufe, Pfoten, Kommentare, Bild, Mux-Video; gemeinsame Funktion `src/lib/story-cleanup.ts`, auch von „Story löschen“ genutzt), täglich 04:30 über die bestehende NAS-Crontab (`docker/run-cron.sh`, Log in `docker/cron.log`); Datenschutzerklärung Abschnitt 6 ergänzt. Offen bleibt nur die 7-Tage-Ansicht für den Ersteller. diff --git a/src/__tests__/cleanup-stories-cron.test.ts b/src/__tests__/cleanup-stories-cron.test.ts new file mode 100644 index 0000000..83d8987 --- /dev/null +++ b/src/__tests__/cleanup-stories-cron.test.ts @@ -0,0 +1,69 @@ +/** + * /api/cron/cleanup-stories — löscht Storys, die älter als 7 Tage sind. + */ + +import { describe, it, expect, vi, beforeEach } from "vitest"; + +vi.mock("server-only", () => ({})); +const mockDeleteFiles = vi.fn().mockResolvedValue(undefined); +vi.mock("@/lib/supabase-storage", () => ({ deleteFiles: (...a: unknown[]) => mockDeleteFiles(...a) })); +const mockMuxDelete = vi.fn().mockResolvedValue(undefined); +vi.mock("@/lib/mux", () => ({ mux: { video: { assets: { delete: (...a: unknown[]) => mockMuxDelete(...a) } } } })); + +import { createMockPrisma } from "@/__tests__/helpers/prisma-mock"; + +const mockPrisma = createMockPrisma(); +// Getter: vi.mock wird nach oben gehoben, mockPrisma existiert erst beim Zugriff. +vi.mock("@/lib/prisma", () => ({ + get prisma() { + return mockPrisma; + }, +})); + +import { GET } from "@/app/api/cron/cleanup-stories/route"; + +const request = (auth?: string) => + new Request("https://pawfeed.org/api/cron/cleanup-stories", { headers: auth ? { authorization: auth } : {} }); + +beforeEach(() => { + vi.clearAllMocks(); + process.env.CRON_SECRET = "test-secret"; + mockPrisma.$transaction.mockResolvedValue([]); +}); + +describe("GET /api/cron/cleanup-stories", () => { + it("rejects requests without the cron secret", async () => { + expect((await GET(request())).status).toBe(401); + expect((await GET(request("Bearer wrong"))).status).toBe(401); + expect(mockPrisma.story.findMany).not.toHaveBeenCalled(); + }); + + it("deletes stories older than 7 days with their media", async () => { + mockPrisma.story.findMany.mockResolvedValue([ + { id: "old-photo", storageKey: "stories/a.jpg", muxAssetId: null }, + { id: "old-video", storageKey: null, muxAssetId: "asset-1" }, + ]); + + const res = await GET(request("Bearer test-secret")); + + expect(await res.json()).toEqual({ ok: true, deleted: 2, failed: 0, more: false }); + const where = mockPrisma.story.findMany.mock.calls[0][0].where; + const cutoffAgeDays = (Date.now() - where.createdAt.lt.getTime()) / (24 * 60 * 60 * 1000); + expect(Math.round(cutoffAgeDays)).toBe(7); + expect(mockPrisma.storyView.deleteMany).toHaveBeenCalledWith({ where: { storyId: "old-photo" } }); + expect(mockDeleteFiles).toHaveBeenCalledWith(["stories/a.jpg"]); + expect(mockMuxDelete).toHaveBeenCalledWith("asset-1"); + }); + + it("keeps going when one story fails and reports it", async () => { + mockPrisma.story.findMany.mockResolvedValue([ + { id: "s1", storageKey: null, muxAssetId: null }, + { id: "s2", storageKey: null, muxAssetId: null }, + ]); + mockPrisma.$transaction.mockRejectedValueOnce(new Error("db hiccup")).mockResolvedValueOnce([]); + + const body = await (await GET(request("Bearer test-secret"))).json(); + + expect(body).toEqual({ ok: false, deleted: 1, failed: 1, more: false }); + }); +}); diff --git a/src/app/api/cron/cleanup-stories/route.ts b/src/app/api/cron/cleanup-stories/route.ts new file mode 100644 index 0000000..f0c1728 --- /dev/null +++ b/src/app/api/cron/cleanup-stories/route.ts @@ -0,0 +1,50 @@ +import { NextResponse } from "next/server"; +import { prisma } from "@/lib/prisma"; +import { timingSafeStringEqual } from "@/lib/timing-safe-compare"; +import { STORY_RETENTION_DAYS, deleteStoryWithMedia } from "@/lib/story-cleanup"; + +const DAY_MS = 24 * 60 * 60 * 1000; +// Pro Lauf begrenzt: run-cron.sh bricht nach 60 s ab, und jede Story kostet +// bis zu zwei externe Löschaufrufe (Supabase, Mux). Ein Rückstand wird über +// die folgenden Tage abgebaut. +const BATCH_SIZE = 200; + +function authorized(req: Request): boolean { + const secret = process.env.CRON_SECRET; + if (!secret) return false; + return timingSafeStringEqual(req.headers.get("authorization") ?? "", `Bearer ${secret}`); +} + +/** + * Löscht Storys, die älter als STORY_RETENTION_DAYS sind, endgültig — vorher + * blieben abgelaufene Storys samt Bildern und Mux-Videos für immer liegen + * („lazy delete“ hat sie nur ausgeblendet). Ausgelöst täglich vom NAS-Crontab + * über docker/run-cron.sh. + */ +export async function GET(req: Request) { + if (!authorized(req)) { + return NextResponse.json({ error: "Unauthorized" }, { status: 401 }); + } + + const cutoff = new Date(Date.now() - STORY_RETENTION_DAYS * DAY_MS); + const stories = await prisma.story.findMany({ + where: { createdAt: { lt: cutoff } }, + select: { id: true, storageKey: true, muxAssetId: true }, + orderBy: { createdAt: "asc" }, + take: BATCH_SIZE, + }); + + let deleted = 0; + let failed = 0; + for (const story of stories) { + try { + await deleteStoryWithMedia(prisma, story); + deleted++; + } catch (err) { + failed++; + console.error("[cron/cleanup-stories] delete failed", story.id, err); + } + } + + return NextResponse.json({ ok: failed === 0, deleted, failed, more: stories.length === BATCH_SIZE }); +} diff --git a/src/app/datenschutz/page.tsx b/src/app/datenschutz/page.tsx index 323dacc..3db459c 100644 --- a/src/app/datenschutz/page.tsx +++ b/src/app/datenschutz/page.tsx @@ -217,6 +217,11 @@ export default function DatenschutzPage() { keine gesetzlichen Aufbewahrungspflichten entgegenstehen. Kontodaten werden nach Löschung des Kontos innerhalb von 30 Tagen gelöscht.

+

+ Storys sind 24 Stunden für andere sichtbar. Spätestens 7 Tage nach dem Veröffentlichen + löschen wir sie automatisch endgültig, zusammen mit Bild bzw. Video, Aufrufen, Pfoten und + Kommentaren. Sie können eine eigene Story jederzeit vorher selbst löschen. +

Technische Fehlerberichte (Absturz-/Fehlerdaten inkl. IP-Adresse, siehe Abschnitt 2) werden automatisiert nach 30 Tagen gelöscht. Dieser Zeitraum ist nach unserer Erfahrung diff --git a/src/lib/gdpr-export.ts b/src/lib/gdpr-export.ts index b53e82e..b969366 100644 --- a/src/lib/gdpr-export.ts +++ b/src/lib/gdpr-export.ts @@ -38,7 +38,7 @@ export async function buildDataExport(prisma: PrismaClient, ownerId: string) { include: { images: true, milestone: true }, orderBy: { createdAt: "asc" }, }, - stories: { orderBy: { createdAt: "asc" } }, // only currently-active ones remain (lazy-delete) + stories: { orderBy: { createdAt: "asc" } }, // max. 7 Tage alt — ältere löscht /api/cron/cleanup-stories comments: { orderBy: { createdAt: "asc" } }, reactions: true, reposts: true, @@ -173,7 +173,7 @@ export async function buildDataExport(prisma: PrismaClient, ownerId: string) { images: post.images.map((img) => getMediaUrl(img.storageKey)), milestone: post.milestone, })), - activeStories: pet.stories.map((s) => ({ + stories: pet.stories.map((s) => ({ mediaUrl: getMediaUrl(s.storageKey), createdAt: s.createdAt, expiresAt: s.expiresAt, diff --git a/src/lib/story-cleanup.ts b/src/lib/story-cleanup.ts new file mode 100644 index 0000000..6960b9f --- /dev/null +++ b/src/lib/story-cleanup.ts @@ -0,0 +1,38 @@ +import "server-only"; +import type { PrismaClient } from "@prisma/client"; +import { deleteFiles } from "@/lib/supabase-storage"; +import { mux } from "@/lib/mux"; + +/** + * Wie lange eine Story insgesamt gespeichert bleibt: 24 h für alle sichtbar, + * danach nur noch für den Ersteller (geplant, siehe mobile/found.md), nach + * 7 Tagen löscht /api/cron/cleanup-stories sie endgültig. Steht so auch in + * der Datenschutzerklärung (Abschnitt 6 „Speicherdauer“). + */ +export const STORY_RETENTION_DAYS = 7; + +export type DeletableStory = { + id: string; + storageKey: string | null; + muxAssetId: string | null; +}; + +/** + * Löscht eine Story vollständig: Aufrufe (StoryView hat bewusst kein + * onDelete: Cascade, D-08), dann die Story — Pfoten und Kommentare hängen per + * Cascade dran. Bild in Supabase Storage und Mux-Asset danach best-effort: + * ein Fehler dort wird geloggt, lässt das Löschen aber nicht scheitern. + */ +export async function deleteStoryWithMedia(prisma: PrismaClient, story: DeletableStory): Promise { + await prisma.$transaction([ + prisma.storyView.deleteMany({ where: { storyId: story.id } }), + prisma.story.delete({ where: { id: story.id } }), + ]); + + if (story.storageKey) { + await deleteFiles([story.storageKey]).catch((err) => console.error("[stories] storage delete failed", err)); + } + if (story.muxAssetId) { + await mux.video.assets.delete(story.muxAssetId).catch((err) => console.error("[stories] mux delete failed", err)); + } +} diff --git a/src/trpc/routers/stories.ts b/src/trpc/routers/stories.ts index f5ca1f3..d6292d9 100644 --- a/src/trpc/routers/stories.ts +++ b/src/trpc/routers/stories.ts @@ -7,8 +7,8 @@ import { createSignedUploadUrl, ALLOWED_CONTENT_TYPES, MAX_FILE_SIZE, - deleteFiles, } from "@/lib/supabase-storage"; +import { deleteStoryWithMedia } from "@/lib/story-cleanup"; import { randomUUID } from "crypto"; import { petIdentitySelect } from "@/repositories/pet-repository"; import { assertPetOwnership } from "@/lib/assert-pet-ownership"; @@ -444,11 +444,8 @@ export const storiesRouter = router({ }), /** - * Owner löscht eine eigene Story (auch eine abgelaufene). Entfernt Aufrufe - * (StoryView hat bewusst kein onDelete: Cascade, D-08), dann die Story — - * Pfoten und Kommentare hängen per Cascade dran. Bild in Supabase Storage - * und Mux-Asset werden danach best-effort gelöscht: ein Fehler dort darf - * das Löschen für den Nutzer nicht scheitern lassen (nur geloggt). + * Owner löscht eine eigene Story (auch eine abgelaufene) — samt Aufrufen, + * Pfoten, Kommentaren, Bild und Mux-Asset, siehe deleteStoryWithMedia(). */ delete: protectedProcedure .use(rateLimited("stories.delete", 20, 60)) @@ -461,17 +458,7 @@ export const storiesRouter = router({ if (!story) throw new TRPCError({ code: "NOT_FOUND" }); await assertPetOwnership(ctx.prisma, story.petId, ctx.userId); - await ctx.prisma.$transaction([ - ctx.prisma.storyView.deleteMany({ where: { storyId: story.id } }), - ctx.prisma.story.delete({ where: { id: story.id } }), - ]); - - if (story.storageKey) { - await deleteFiles([story.storageKey]).catch((err) => console.error("[stories] storage delete failed", err)); - } - if (story.muxAssetId) { - await mux.video.assets.delete(story.muxAssetId).catch((err) => console.error("[stories] mux delete failed", err)); - } + await deleteStoryWithMedia(ctx.prisma, story); return { deleted: true }; }),