Initial commit: FPT Financial Planning Tool

src/app/api/phases/[phaseId]/route.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { prisma } from "@/lib/db";
+import { phaseInclude } from "@/lib/queries";
+
+const incomeEntrySchema = z.object({
+  personId: z.string().nullable().optional(),
+  label: z.string().nullable().optional(),
+  amount: z.number(),
+});
+const expenseEntrySchema = z.object({
+  label: z.string().nullable().optional(),
+  amount: z.number(),
+});
+const securitySchema = z.object({
+  name: z.string().min(1),
+  startValue: z.number(),
+  expectedReturn: z.number(),
+  annualContribution: z.number(),
+  ownerTag: z.enum(["PERSON_A", "PERSON_B", "HOUSEHOLD"]),
+  saleTaxRate: z.number().min(0).max(100),
+});
+const realEstateSchema = z.object({
+  name: z.string().min(1),
+  marketValue: z.number(),
+  mortgage: z.number(),
+  valueGrowth: z.number(),
+  amortization: z.number(),
+  salePrice: z.number().nullable().optional(),
+  saleTaxRate: z.number().min(0).max(100),
+});
+const oneTimeEventSchema = z.object({
+  type: z.enum(["INCOME", "EXPENSE"]),
+  amount: z.number(),
+  description: z.string().nullable().optional(),
+});
+const retirementInfoSchema = z.object({
+  personId: z.string().min(1),
+  ahvAmount: z.number().min(0),
+  pkPensionAmount: z.number().min(0),
+  lumpSumAmount: z.number().min(0),
+  lumpSumTaxRate: z.number().min(0).max(100),
+});
+
+const updatePhaseSchema = z.object({
+  name: z.string().min(1).max(120),
+  durationYears: z.number().int().min(1).max(80),
+  inflationRate: z.number().min(-20).max(50).nullable().optional(),
+  incomeMode: z.enum(["PER_PERSON", "HOUSEHOLD"]),
+  incomeEntries: z.array(incomeEntrySchema).default([]),
+  expenseEntries: z.array(expenseEntrySchema).default([]),
+  securities: z.array(securitySchema).default([]),
+  realEstates: z.array(realEstateSchema).default([]),
+  oneTimeEvents: z.array(oneTimeEventSchema).default([]),
+  retirementInfos: z.array(retirementInfoSchema).default([]),
+});
+
+// Ersetzt eine Phase vollstaendig (Basisfelder + alle Unter-Sammlungen). Fuer ein
+// Single-User-Tool ohne nennenswerte Nebenlaeufigkeit ist ein "delete + recreate" der
+// Kindobjekte einfacher und robuster als granulares Diffing pro Zeile.
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: Promise<{ phaseId: string }> }
+) {
+  const { phaseId } = await params;
+  const body = await request.json();
+  const parsed = updatePhaseSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+  const data = parsed.data;
+
+  const existing = await prisma.phase.findUnique({ where: { id: phaseId } });
+  if (!existing) {
+    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
+  }
+
+  const phase = await prisma.$transaction(async (tx) => {
+    await Promise.all([
+      tx.incomeEntry.deleteMany({ where: { phaseId } }),
+      tx.expenseEntry.deleteMany({ where: { phaseId } }),
+      tx.security.deleteMany({ where: { phaseId } }),
+      tx.realEstate.deleteMany({ where: { phaseId } }),
+      tx.oneTimeEvent.deleteMany({ where: { phaseId } }),
+      tx.retirementInfo.deleteMany({ where: { phaseId } }),
+    ]);
+
+    return tx.phase.update({
+      where: { id: phaseId },
+      data: {
+        name: data.name,
+        durationYears: data.durationYears,
+        inflationRate: data.inflationRate ?? null,
+        incomeMode: data.incomeMode,
+        incomeEntries: { create: data.incomeEntries.map((e) => ({ ...e, label: e.label ?? null, personId: e.personId ?? null })) },
+        expenseEntries: { create: data.expenseEntries.map((e) => ({ ...e, label: e.label ?? null })) },
+        securities: { create: data.securities },
+        realEstates: { create: data.realEstates.map((re) => ({ ...re, salePrice: re.salePrice ?? null })) },
+        oneTimeEvents: { create: data.oneTimeEvents.map((e) => ({ ...e, description: e.description ?? null })) },
+        retirementInfos: { create: data.retirementInfos },
+      },
+      include: phaseInclude,
+    });
+  });
+
+  return NextResponse.json({ phase });
+}
+
+// Eine Phase kann nur geloescht werden, wenn sie die letzte in der Kette ist -- so
+// bleibt die Verkettung (Schlussvermoegen = Startvermoegen der Folgephase) immer intakt.
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ phaseId: string }> }
+) {
+  const { phaseId } = await params;
+  const phase = await prisma.phase.findUnique({ where: { id: phaseId } });
+  if (!phase) {
+    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
+  }
+
+  const laterPhase = await prisma.phase.findFirst({
+    where: { planId: phase.planId, sequenceNumber: { gt: phase.sequenceNumber } },
+  });
+  if (laterPhase) {
+    return NextResponse.json(
+      { error: "Nur die letzte Phase eines Plans kann geloescht werden." },
+      { status: 400 }
+    );
+  }
+
+  await prisma.phase.delete({ where: { id: phaseId } });
+  return NextResponse.json({ ok: true });
+}