final touches for beta skymoney (at least i think)

api/src/routes/fixed-plans.ts

@@ -1,6 +1,15 @@
 import { FastifyPluginAsync } from "fastify";
 import { z } from "zod";
 import { prisma } from "../prisma.js";
+import { getUserMidnight, getUserMidnightFromDateOnly } from "../allocator.js";
+import { fromZonedTime, toZonedTime } from "date-fns-tz";
+
+const PaymentSchedule = z.object({
+  frequency: z.enum(["monthly", "weekly", "biweekly", "daily"]),
+  dayOfMonth: z.number().int().min(1).max(31).optional(),
+  dayOfWeek: z.number().int().min(0).max(6).optional(),
+  minFundingPercent: z.number().min(0).max(100).default(100),
+});
 
 const NewPlan = z.object({
   name: z.string().min(1).max(120),
@@ -8,6 +17,9 @@ const NewPlan = z.object({
   fundedCents: z.number().int().min(0).default(0),
   priority: z.number().int().min(0).max(10_000),
   dueOn: z.string().datetime(), // ISO
+  frequency: z.enum(["one-time", "weekly", "biweekly", "monthly"]).optional(),
+  autoPayEnabled: z.boolean().default(false),
+  paymentSchedule: PaymentSchedule.optional(),
 });
 const PatchPlan = NewPlan.partial();
 const IdParam = z.object({ id: z.string().min(1) });
@@ -22,26 +34,81 @@ function validateFunding(total: bigint, funded: bigint) {
   }
 }
 
+function calculateNextPaymentDate(dueDate: Date, schedule: any, timezone: string): Date {
+  const base = getUserMidnightFromDateOnly(timezone, dueDate);
+  const next = toZonedTime(base, timezone);
+
+  switch (schedule.frequency) {
+    case "daily":
+      next.setUTCDate(next.getUTCDate() + 1);
+      break;
+    case "weekly": {
+      const targetDay = schedule.dayOfWeek ?? 0;
+      const currentDay = next.getUTCDay();
+      const daysUntilTarget = (targetDay - currentDay + 7) % 7;
+      next.setUTCDate(next.getUTCDate() + (daysUntilTarget || 7));
+      break;
+    }
+    case "monthly": {
+      const targetDay = schedule.dayOfMonth ?? next.getUTCDate();
+      const nextMonth = next.getUTCMonth() + 1;
+      const nextYear = next.getUTCFullYear() + Math.floor(nextMonth / 12);
+      const nextMonthIndex = nextMonth % 12;
+      const lastDay = new Date(Date.UTC(nextYear, nextMonthIndex + 1, 0)).getUTCDate();
+      next.setUTCFullYear(nextYear, nextMonthIndex, Math.min(targetDay, lastDay));
+      break;
+    }
+    default:
+      next.setUTCDate(next.getUTCDate() + 30); // fallback
+  }
+
+  next.setUTCHours(0, 0, 0, 0);
+  return fromZonedTime(next, timezone);
+}
+
 const plugin: FastifyPluginAsync = async (app) => {
   // CREATE
-  app.post("/api/fixed-plans", async (req, reply) => {
+  app.post("/fixed-plans", async (req, reply) => {
     const userId = req.userId;
     const parsed = NewPlan.safeParse(req.body);
     if (!parsed.success) return reply.status(400).send({ error: "INVALID_BODY", details: parsed.error.flatten() });
+    const userTimezone =
+      (await prisma.user.findUnique({ where: { id: userId }, select: { timezone: true } }))?.timezone ??
+      "America/New_York";
 
     const totalBI = bi(parsed.data.totalCents);
     const fundedBI = bi(parsed.data.fundedCents);
     validateFunding(totalBI, fundedBI);
 
+    // Calculate next payment date if auto-pay is enabled
+    const nextPaymentDate = parsed.data.autoPayEnabled && parsed.data.paymentSchedule
+      ? calculateNextPaymentDate(new Date(parsed.data.dueOn), parsed.data.paymentSchedule, userTimezone)
+      : null;
+
+    // Extract frequency from explicit field or paymentSchedule
+    let frequency = parsed.data.frequency;
+    if (!frequency && parsed.data.paymentSchedule?.frequency) {
+      const scheduleFreq = parsed.data.paymentSchedule.frequency;
+      if (scheduleFreq === "monthly" || scheduleFreq === "weekly" || scheduleFreq === "biweekly") {
+        frequency = scheduleFreq;
+      }
+    }
+
     const rec = await prisma.fixedPlan.create({
       data: {
         userId,
         name: parsed.data.name,
         priority: parsed.data.priority,
-        dueOn: new Date(parsed.data.dueOn),
+        dueOn: getUserMidnightFromDateOnly(userTimezone, new Date(parsed.data.dueOn)),
+        frequency: frequency || null,
         totalCents: totalBI,
         fundedCents: fundedBI,
-        cycleStart: new Date(), // required by your schema
+        currentFundedCents: fundedBI,
+        cycleStart: getUserMidnight(userTimezone, new Date()), // required by your schema
+        autoPayEnabled: parsed.data.autoPayEnabled ?? false,
+        paymentSchedule: parsed.data.paymentSchedule || undefined,
+        nextPaymentDate,
+        lastFundingDate: fundedBI > 0 ? new Date() : null,
       },
       select: { id: true },
     });
@@ -49,12 +116,15 @@ const plugin: FastifyPluginAsync = async (app) => {
   });
 
   // UPDATE
-  app.patch("/api/fixed-plans/:id", async (req, reply) => {
+  app.patch("/fixed-plans/:id", async (req, reply) => {
     const userId = req.userId;
     const pid = IdParam.safeParse(req.params);
     const patch = PatchPlan.safeParse(req.body);
     if (!pid.success) return reply.status(400).send({ error: "INVALID_ID", details: pid.error.flatten() });
     if (!patch.success) return reply.status(400).send({ error: "INVALID_BODY", details: patch.error.flatten() });
+    const userTimezone =
+      (await prisma.user.findUnique({ where: { id: userId }, select: { timezone: true } }))?.timezone ??
+      "America/New_York";
 
     const existing = await prisma.fixedPlan.findFirst({ where: { id: pid.data.id, userId } });
     if (!existing) return reply.status(404).send({ error: "NOT_FOUND" });
@@ -63,22 +133,43 @@ const plugin: FastifyPluginAsync = async (app) => {
     const nextFunded = patch.data.fundedCents !== undefined ? bi(patch.data.fundedCents) : (existing.fundedCents as bigint);
     validateFunding(nextTotal, nextFunded);
 
-    await prisma.fixedPlan.update({
-      where: { id: pid.data.id },
+    // Calculate next payment date if auto-pay settings changed
+    const nextPaymentDate = (patch.data.autoPayEnabled !== undefined || patch.data.paymentSchedule !== undefined)
+      ? ((patch.data.autoPayEnabled ?? existing.autoPayEnabled) && (patch.data.paymentSchedule ?? existing.paymentSchedule))
+        ? calculateNextPaymentDate(
+            patch.data.dueOn ? new Date(patch.data.dueOn) : existing.dueOn,
+            patch.data.paymentSchedule ?? existing.paymentSchedule,
+            userTimezone
+          )
+        : null
+      : undefined;
+
+    const updated = await prisma.fixedPlan.updateMany({
+      where: { id: pid.data.id, userId },
       data: {
         ...(patch.data.name !== undefined ? { name: patch.data.name } : null),
         ...(patch.data.priority !== undefined ? { priority: patch.data.priority } : null),
-        ...(patch.data.dueOn !== undefined ? { dueOn: new Date(patch.data.dueOn) } : null),
+        ...(patch.data.dueOn !== undefined ? { dueOn: getUserMidnightFromDateOnly(userTimezone, new Date(patch.data.dueOn)) } : null),
         ...(patch.data.totalCents !== undefined ? { totalCents: bi(patch.data.totalCents) } : null),
-        ...(patch.data.fundedCents !== undefined ? { fundedCents: bi(patch.data.fundedCents) } : null),
+        ...(patch.data.fundedCents !== undefined
+          ? {
+              fundedCents: bi(patch.data.fundedCents),
+              currentFundedCents: bi(patch.data.fundedCents),
+              lastFundingDate: new Date(),
+            }
+          : null),
+        ...(patch.data.autoPayEnabled !== undefined ? { autoPayEnabled: patch.data.autoPayEnabled } : null),
+        ...(patch.data.paymentSchedule !== undefined ? { paymentSchedule: patch.data.paymentSchedule } : null),
+        ...(nextPaymentDate !== undefined ? { nextPaymentDate } : null),
       },
     });
+    if (updated.count === 0) return reply.status(404).send({ error: "NOT_FOUND" });
 
     return reply.send({ ok: true });
   });
 
   // DELETE
-  app.delete("/api/fixed-plans/:id", async (req, reply) => {
+  app.delete("/fixed-plans/:id", async (req, reply) => {
     const userId = req.userId;
     const pid = IdParam.safeParse(req.params);
     if (!pid.success) return reply.status(400).send({ error: "INVALID_ID", details: pid.error.flatten() });
@@ -86,9 +177,10 @@ const plugin: FastifyPluginAsync = async (app) => {
     const existing = await prisma.fixedPlan.findFirst({ where: { id: pid.data.id, userId } });
     if (!existing) return reply.status(404).send({ error: "NOT_FOUND" });
 
-    await prisma.fixedPlan.delete({ where: { id: pid.data.id } });
+    const deleted = await prisma.fixedPlan.deleteMany({ where: { id: pid.data.id, userId } });
+    if (deleted.count === 0) return reply.status(404).send({ error: "NOT_FOUND" });
     return reply.send({ ok: true });
   });
 };
 
-export default plugin;
+export default plugin;

api/src/routes/income-preview.ts

@@ -1,82 +1,98 @@
 import { FastifyInstance } from "fastify";
 import { z } from "zod";
+import { previewAllocation, previewIrregularAllocation } from "../allocator.js";
 
-const Body = z.object({ amountCents: z.number().int().nonnegative() });
+const Body = z.object({
+  amountCents: z.number().int().nonnegative(),
+  occurredAtISO: z.string().datetime().optional(),
+});
 
 export default async function incomePreviewRoutes(app: FastifyInstance) {
+  type PlanPreview = {
+    id: string;
+    name: string;
+    dueOn: Date;
+    totalCents: number;
+    fundedCents: number;
+    remainingCents: number;
+    daysUntilDue: number;
+    allocatedThisRun: number;
+    isCrisis: boolean;
+  };
+
+  type PreviewResult = {
+    fixedAllocations: Array<{ fixedPlanId: string; amountCents: number; source?: string }>;
+    variableAllocations: Array<{ variableCategoryId: string; amountCents: number }>;
+    planStatesAfter: PlanPreview[];
+    availableBudgetAfterCents: number;
+    remainingUnallocatedCents: number;
+    crisis: { active: boolean; plans: Array<{ id: string; name: string; remainingCents: number; daysUntilDue: number; priority: number; allocatedCents: number }> };
+  };
+
   app.post("/income/preview", async (req, reply) => {
     const parsed = Body.safeParse(req.body);
     if (!parsed.success) return reply.code(400).send({ message: "Invalid amount" });
 
     const userId = req.userId;
-    let remaining = Math.max(0, parsed.data.amountCents | 0);
+    const user = await app.prisma.user.findUnique({
+      where: { id: userId },
+      select: { incomeType: true, fixedExpensePercentage: true },
+    });
 
-    const [plans, cats] = await Promise.all([
-      app.prisma.fixedPlan.findMany({
-        where: { userId },
-        orderBy: [{ priority: "asc" }, { dueOn: "asc" }],
-        select: { id: true, name: true, totalCents: true, fundedCents: true, priority: true, dueOn: true },
-      }),
-      app.prisma.variableCategory.findMany({
-        where: { userId },
-        orderBy: [{ priority: "asc" }, { name: "asc" }],
-        select: { id: true, name: true, percent: true, isSavings: true, priority: true },
-      }),
-    ]);
+    let result: PreviewResult;
 
-    // Fixed pass
-    const fixed: Array<{ id: string; name: string; amountCents: number }> = [];
-    for (const p of plans) {
-      if (remaining <= 0) break;
-      const needBig = (p.totalCents ?? 0n) - (p.fundedCents ?? 0n);
-      const need = Number(needBig > 0n ? needBig : 0n);
-      if (need <= 0) continue;
-      const give = Math.min(need, remaining);
-      fixed.push({ id: p.id, name: p.name, amountCents: give });
-      remaining -= give;
+    if (user?.incomeType === "irregular") {
+      const rawResult = await previewIrregularAllocation(
+        app.prisma,
+        userId,
+        parsed.data.amountCents,
+        user.fixedExpensePercentage ?? 40,
+        parsed.data.occurredAtISO
+      );
+      result = {
+        fixedAllocations: rawResult.fixedAllocations,
+        variableAllocations: rawResult.variableAllocations,
+        planStatesAfter: rawResult.planStatesAfter,
+        availableBudgetAfterCents: rawResult.availableBudgetCents,
+        remainingUnallocatedCents: rawResult.remainingBudgetCents,
+        crisis: rawResult.crisis,
+      };
+    } else {
+      const rawResult = await previewAllocation(
+        app.prisma,
+        userId,
+        parsed.data.amountCents,
+        parsed.data.occurredAtISO
+      );
+      result = {
+        fixedAllocations: rawResult.fixedAllocations,
+        variableAllocations: rawResult.variableAllocations,
+        planStatesAfter: rawResult.planStatesAfter,
+        availableBudgetAfterCents: rawResult.availableBudgetAfterCents,
+        remainingUnallocatedCents: rawResult.remainingUnallocatedCents,
+        crisis: rawResult.crisis,
+      };
     }
 
-    // Variable pass — largest remainder with savings-first tiebreak
-    const variable: Array<{ id: string; name: string; amountCents: number }> = [];
-    if (remaining > 0 && cats.length > 0) {
-      const totalPercent = cats.reduce((s, c) => s + (c.percent || 0), 0);
-      const normCats =
-        totalPercent === 100
-          ? cats
-          : cats.map((c) => ({
-              ...c,
-              percent: totalPercent > 0 ? (c.percent * 100) / totalPercent : 0,
-            }));
+    const fixedPreview = result.planStatesAfter.map((p) => ({
+      id: p.id,
+      name: p.name,
+      dueOn: p.dueOn.toISOString(),
+      totalCents: p.totalCents,
+      fundedCents: p.fundedCents,
+      remainingCents: p.remainingCents,
+      daysUntilDue: p.daysUntilDue,
+      allocatedThisRun: p.allocatedThisRun,
+      isCrisis: p.isCrisis,
+    }));
 
-      const base: number[] = new Array(normCats.length).fill(0);
-      const tie: { idx: number; remainder: number; isSavings: boolean; priority: number; name: string }[] = [];
-      let sumBase = 0;
-
-      normCats.forEach((c, idx) => {
-        const exact = (remaining * c.percent) / 100;
-        const floor = Math.floor(exact);
-        base[idx] = floor;
-        sumBase += floor;
-        tie.push({ idx, remainder: exact - floor, isSavings: !!c.isSavings, priority: c.priority, name: c.name });
-      });
-
-      let leftovers = remaining - sumBase;
-      tie.sort((a, b) => {
-        if (a.isSavings !== b.isSavings) return a.isSavings ? -1 : 1; // savings first
-        if (a.remainder !== b.remainder) return b.remainder - a.remainder;
-        if (a.priority !== b.priority) return a.priority - b.priority;
-        return a.name.localeCompare(b.name);
-      });
-      for (let i = 0; i < tie.length && leftovers > 0; i++, leftovers--) base[tie[i].idx] += 1;
-
-      normCats.forEach((c, idx) => {
-        const give = base[idx] || 0;
-        if (give > 0) variable.push({ id: c.id, name: c.name, amountCents: give });
-      });
-
-      remaining = leftovers;
-    }
-
-    return { fixed, variable, unallocatedCents: Math.max(0, remaining) };
+    return {
+      fixedAllocations: result.fixedAllocations,
+      variableAllocations: result.variableAllocations,
+      fixedPreview,
+      availableBudgetAfterCents: result.availableBudgetAfterCents,
+      crisis: result.crisis,
+      unallocatedCents: result.remainingUnallocatedCents,
+    };
   });
-}
+}

api/src/routes/transactions.ts

@@ -1,6 +1,7 @@
 // api/src/routes/transactions.ts
 import fp from "fastify-plugin";
 import { z } from "zod";
+import { getUserDateRangeFromDateOnly } from "../allocator.js";
 
 const Query = z.object({
   from: z
@@ -19,10 +20,13 @@ const Query = z.object({
 
 export default fp(async function transactionsRoute(app) {
   app.get("/transactions", async (req, reply) => {
-    const userId =
-      typeof req.userId === "string"
-        ? req.userId
-        : String(req.userId ?? "demo-user-1");
+    if (typeof req.userId !== "string") {
+      return reply.code(401).send({ message: "Unauthorized" });
+    }
+    const userId = req.userId;
+    const userTimezone =
+      (await app.prisma.user.findUnique({ where: { id: userId }, select: { timezone: true } }))?.timezone ??
+      "America/New_York";
 
     const parsed = Query.safeParse(req.query);
     if (!parsed.success) {
@@ -34,9 +38,7 @@ export default fp(async function transactionsRoute(app) {
 
     const where: any = { userId };
     if (from || to) {
-      where.occurredAt = {};
-      if (from) where.occurredAt.gte = new Date(`${from}T00:00:00.000Z`);
-      if (to) where.occurredAt.lte = new Date(`${to}T23:59:59.999Z`);
+      where.occurredAt = getUserDateRangeFromDateOnly(userTimezone, from, to);
     }
     if (kind) where.kind = kind;
 

api/src/routes/variable-categories.ts

@@ -13,6 +13,39 @@ const NewCat = z.object({
 const PatchCat = NewCat.partial();
 const IdParam = z.object({ id: z.string().min(1) });
 
+function computeBalanceTargets(
+  categories: Array<{ id: string; percent: number }>,
+  totalBalance: number
+) {
+  const percentTotal = categories.reduce((sum, c) => sum + (c.percent || 0), 0);
+  if (percentTotal <= 0) {
+    return { ok: false as const, reason: "no_percent" };
+  }
+
+  const targets = categories.map((cat) => {
+    const raw = (totalBalance * cat.percent) / percentTotal;
+    const floored = Math.floor(raw);
+    return {
+      id: cat.id,
+      target: floored,
+      frac: raw - floored,
+    };
+  });
+
+  let remainder = totalBalance - targets.reduce((sum, t) => sum + t.target, 0);
+  targets
+    .slice()
+    .sort((a, b) => b.frac - a.frac)
+    .forEach((t) => {
+      if (remainder > 0) {
+        t.target += 1;
+        remainder -= 1;
+      }
+    });
+
+  return { ok: true as const, targets };
+}
+
 async function assertPercentTotal100(tx: Prisma.TransactionClient, userId: string) {
   const g = await tx.variableCategory.groupBy({
     by: ["userId"],
@@ -20,66 +53,135 @@ async function assertPercentTotal100(tx: Prisma.TransactionClient, userId: strin
     _sum: { percent: true },
   });
   const sum = g[0]?._sum.percent ?? 0;
-  if (sum !== 100) {
-    const err: any = new Error(`Percents must sum to 100 (got ${sum}).`);
+  
+  // Allow partial states during onboarding (< 100%), but enforce exact 100% when sum would be >= 100%
+  if (sum > 100) {
+    const err = new Error(`Percents cannot exceed 100 (got ${sum}).`) as any;
     err.statusCode = 400;
-    err.code = "PERCENT_TOTAL_NOT_100";
+    err.code = "PERCENT_TOTAL_OVER_100";
     throw err;
   }
+  
+  // For now, allow partial completion during onboarding
+  // The frontend will ensure 100% total before finishing onboarding
 }
 
 const plugin: FastifyPluginAsync = async (app) => {
   // CREATE
-  app.post("/api/variable-categories", async (req, reply) => {
+  app.post("/variable-categories", async (req, reply) => {
     const userId = req.userId;
     const body = NewCat.safeParse(req.body);
     if (!body.success) return reply.status(400).send({ error: "INVALID_BODY", details: body.error.flatten() });
 
-    const created = await prisma.$transaction(async (tx) => {
-      const rec = await tx.variableCategory.create({
-        data: { ...body.data, userId },
+    const normalizedName = body.data.name.trim().toLowerCase();
+    try {
+      const result = await prisma.variableCategory.create({
+        data: { ...body.data, userId, name: normalizedName },
         select: { id: true },
       });
-      await assertPercentTotal100(tx, userId);
-      return rec;
-    });
-
-    return reply.status(201).send(created);
+      return reply.status(201).send(result);
+    } catch (error: any) {
+      if (error.code === 'P2002') {
+        return reply.status(400).send({ error: 'DUPLICATE_NAME', message: `Category name '${body.data.name}' already exists` });
+      }
+      throw error;
+    }
   });
 
   // UPDATE
-  app.patch("/api/variable-categories/:id", async (req, reply) => {
+  app.patch("/variable-categories/:id", async (req, reply) => {
     const userId = req.userId;
     const pid = IdParam.safeParse(req.params);
     const patch = PatchCat.safeParse(req.body);
     if (!pid.success) return reply.status(400).send({ error: "INVALID_ID", details: pid.error.flatten() });
     if (!patch.success) return reply.status(400).send({ error: "INVALID_BODY", details: patch.error.flatten() });
 
-    await prisma.$transaction(async (tx) => {
-      const exists = await tx.variableCategory.findFirst({ where: { id: pid.data.id, userId } });
-      if (!exists) return reply.status(404).send({ error: "NOT_FOUND" });
-      await tx.variableCategory.update({ where: { id: pid.data.id }, data: patch.data });
-      await assertPercentTotal100(tx, userId);
+    const exists = await prisma.variableCategory.findFirst({ where: { id: pid.data.id, userId } });
+    if (!exists) return reply.status(404).send({ error: "NOT_FOUND" });
+    
+    const updateData = {
+      ...patch.data,
+      ...(patch.data.name !== undefined ? { name: patch.data.name.trim().toLowerCase() } : {}),
+    };
+    const updated = await prisma.variableCategory.updateMany({
+      where: { id: pid.data.id, userId },
+      data: updateData,
     });
-
+    if (updated.count === 0) return reply.status(404).send({ error: "NOT_FOUND" });
     return reply.send({ ok: true });
   });
 
+
+
   // DELETE
-  app.delete("/api/variable-categories/:id", async (req, reply) => {
+  app.delete("/variable-categories/:id", async (req, reply) => {
     const userId = req.userId;
     const pid = IdParam.safeParse(req.params);
     if (!pid.success) return reply.status(400).send({ error: "INVALID_ID", details: pid.error.flatten() });
 
-    await prisma.$transaction(async (tx) => {
-      const exists = await tx.variableCategory.findFirst({ where: { id: pid.data.id, userId } });
-      if (!exists) return reply.status(404).send({ error: "NOT_FOUND" });
-      await tx.variableCategory.delete({ where: { id: pid.data.id } });
-      await assertPercentTotal100(tx, userId);
+    const exists = await prisma.variableCategory.findFirst({ where: { id: pid.data.id, userId } });
+    if (!exists) return reply.status(404).send({ error: "NOT_FOUND" });
+    
+    const deleted = await prisma.variableCategory.deleteMany({
+      where: { id: pid.data.id, userId },
     });
+    if (deleted.count === 0) return reply.status(404).send({ error: "NOT_FOUND" });
 
     return reply.send({ ok: true });
   });
+
+  // REBALANCE balances based on current percents
+  app.post("/variable-categories/rebalance", async (req, reply) => {
+    const userId = req.userId;
+    const categories = await prisma.variableCategory.findMany({
+      where: { userId },
+      select: { id: true, percent: true, balanceCents: true },
+      orderBy: [{ priority: "asc" }, { name: "asc" }],
+    });
+
+    if (categories.length === 0) {
+      return reply.send({ ok: true, applied: false });
+    }
+
+    const hasNegative = categories.some(
+      (c) => Number(c.balanceCents ?? 0n) < 0
+    );
+    if (hasNegative) {
+      return reply.code(400).send({
+        ok: false,
+        code: "NEGATIVE_BALANCE",
+        message: "Cannot rebalance while a category has a negative balance.",
+      });
+    }
+
+    const totalBalance = categories.reduce(
+      (sum, c) => sum + Number(c.balanceCents ?? 0n),
+      0
+    );
+    if (totalBalance <= 0) {
+      return reply.send({ ok: true, applied: false });
+    }
+
+    const targetResult = computeBalanceTargets(categories, totalBalance);
+    if (!targetResult.ok) {
+      return reply.code(400).send({
+        ok: false,
+        code: "NO_PERCENT",
+        message: "No percent totals available to rebalance.",
+      });
+    }
+
+    await prisma.$transaction(
+      targetResult.targets.map((t) =>
+        prisma.variableCategory.update({
+          where: { id: t.id },
+          data: { balanceCents: BigInt(t.target) },
+        })
+      )
+    );
+
+    return reply.send({ ok: true, applied: true, totalBalance });
+  });
 };
 
-export default plugin;
+export default plugin;