chore(style): repo-wide prettier sweep before v1.4.6 tag

Long-overdue prettier sweep; prettier had drifted vs. checked-in code
across ~130 files (mostly long-argument line-break wrapping in TS and
table-padding in markdown). Pure formatting — no semantic changes —
and required to clear the v1.4.6 release gate's `pnpm format:check`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Marc-André BombeckandClaude Opus 4.7 committed 2026-05-09 02:27:17 +02:00
1 parent 67575180b8
commit 02b99553b9
135 files changed
+2159 -1583

No files matched your search

+130 -126
View File
@@ -14,164 +14,168 @@ function medicationScope(medicationId: string): string {
return `medication:${medicationId}:ingest`;
}
export const GET = apiHandler(async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
if (!(await isApiGloballyEnabled())) {
return apiError("API is globally disabled", 403);
}
export const GET = apiHandler(
async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
if (!(await isApiGloballyEnabled())) {
return apiError("API is globally disabled", 403);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const scope = medicationScope(id);
const now = new Date();
const scope = medicationScope(id);
const now = new Date();
const activeTokenCount = await prisma.apiToken.count({
where: {
userId: user.id,
revoked: false,
permissions: { has: scope },
OR: [{ expiresAt: null }, { expiresAt: { gt: now } }],
},
});
annotate({
action: {
name: "medication.api_endpoint.get",
entity_type: "medication",
entity_id: id,
},
meta: { active_token_count: activeTokenCount },
});
return apiSuccess({
enabled: activeTokenCount > 0,
activeTokenCount,
});
});
export const PUT = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
if (!(await isApiGloballyEnabled())) {
return apiError("API is globally disabled", 403);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
let enabled = false;
try {
const body = await request.json();
enabled = body?.enabled === true;
} catch {
return apiError("Invalid request", 422);
}
const scope = medicationScope(id);
if (enabled) {
const existing = await prisma.apiToken.count({
const activeTokenCount = await prisma.apiToken.count({
where: {
userId: user.id,
revoked: false,
permissions: { has: scope },
OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
OR: [{ expiresAt: null }, { expiresAt: { gt: now } }],
},
});
if (existing > 0) {
annotate({
action: {
name: "medication.api_endpoint.get",
entity_type: "medication",
entity_id: id,
},
meta: { active_token_count: activeTokenCount },
});
return apiSuccess({
enabled: activeTokenCount > 0,
activeTokenCount,
});
},
);
export const PUT = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
if (!(await isApiGloballyEnabled())) {
return apiError("API is globally disabled", 403);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
let enabled = false;
try {
const body = await request.json();
enabled = body?.enabled === true;
} catch {
return apiError("Invalid request", 422);
}
const scope = medicationScope(id);
if (enabled) {
const existing = await prisma.apiToken.count({
where: {
userId: user.id,
revoked: false,
permissions: { has: scope },
OR: [{ expiresAt: null }, { expiresAt: { gt: new Date() } }],
},
});
if (existing > 0) {
annotate({
action: {
name: "medication.api_endpoint.enable",
entity_type: "medication",
entity_id: id,
},
meta: { already_enabled: true, active_token_count: existing },
});
return apiSuccess({
enabled: true,
activeTokenCount: existing,
token: null,
created: false,
});
}
const rawToken = `hlk_${randomBytes(32).toString("hex")}`;
const tokenHashValue = hashToken(rawToken);
await prisma.apiToken.create({
data: {
userId: user.id,
name: `API Endpoint: ${medication.name}`,
tokenHash: tokenHashValue,
permissions: ["medication:ingest", scope],
expiresAt: null,
},
});
await auditLog("medication.api_endpoint.enable", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, medicationName: medication.name },
});
annotate({
action: {
name: "medication.api_endpoint.enable",
entity_type: "medication",
entity_id: id,
},
meta: { already_enabled: true, active_token_count: existing },
meta: { created: true },
});
return apiSuccess({
enabled: true,
activeTokenCount: existing,
token: null,
created: false,
});
return apiSuccess(
{
enabled: true,
activeTokenCount: 1,
token: rawToken,
created: true,
},
201,
);
}
const rawToken = `hlk_${randomBytes(32).toString("hex")}`;
const tokenHashValue = hashToken(rawToken);
await prisma.apiToken.create({
data: {
const revoked = await prisma.apiToken.updateMany({
where: {
userId: user.id,
name: `API Endpoint: ${medication.name}`,
tokenHash: tokenHashValue,
permissions: ["medication:ingest", scope],
expiresAt: null,
revoked: false,
permissions: { has: scope },
},
data: { revoked: true },
});
await auditLog("medication.api_endpoint.enable", {
await auditLog("medication.api_endpoint.disable", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, medicationName: medication.name },
details: {
medicationId: id,
medicationName: medication.name,
revokedTokens: revoked.count,
},
});
annotate({
action: {
name: "medication.api_endpoint.enable",
name: "medication.api_endpoint.disable",
entity_type: "medication",
entity_id: id,
},
meta: { created: true },
meta: { revoked_token_count: revoked.count },
});
return apiSuccess(
{
enabled: true,
activeTokenCount: 1,
token: rawToken,
created: true,
},
201,
);
}
const revoked = await prisma.apiToken.updateMany({
where: {
userId: user.id,
revoked: false,
permissions: { has: scope },
},
data: { revoked: true },
});
await auditLog("medication.api_endpoint.disable", {
userId: user.id,
ipAddress: getClientIp(request),
details: {
medicationId: id,
medicationName: medication.name,
revokedTokens: revoked.count,
},
});
annotate({
action: {
name: "medication.api_endpoint.disable",
entity_type: "medication",
entity_id: id,
},
meta: { revoked_token_count: revoked.count },
});
return apiSuccess({
enabled: false,
revokedTokenCount: revoked.count,
});
});
return apiSuccess({
enabled: false,
revokedTokenCount: revoked.count,
});
},
);
+117 -115
View File
@@ -10,124 +10,126 @@ import type { DailyComplianceEntry } from "@/lib/analytics/compliance";
type RouteParams = { params: Promise<{ id: string }> };
export const GET = apiHandler(async (_request: Request, { params }: RouteParams) => {
const { user } = await requireAuth();
export const GET = apiHandler(
async (_request: Request, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
include: { schedules: true },
});
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
include: { schedules: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const events = await prisma.medicationIntakeEvent.findMany({
where: { medicationId: id, userId: user.id },
orderBy: { scheduledFor: "desc" },
});
const mapped = events.map((e) => ({
takenAt: e.takenAt,
skipped: e.skipped,
scheduledFor: e.scheduledFor,
}));
const createdAt = medication.createdAt;
const compliance7 = calculateCompliance(
mapped,
medication.schedules,
7,
createdAt,
);
const compliance30 = calculateCompliance(
mapped,
medication.schedules,
30,
createdAt,
);
// Build daily compliance map for heatmap/line chart (90 days)
const now = new Date();
const schedulesPerDay = medication.schedules.length;
const dailyCompliance: Record<string, DailyComplianceEntry> = {};
for (let d = 0; d < 90; d++) {
const dayStart = new Date(now.getTime() - (d + 1) * 24 * 60 * 60 * 1000);
const dayEnd = new Date(now.getTime() - d * 24 * 60 * 60 * 1000);
// Skip days before medication was created
if (dayEnd <= createdAt) continue;
const dateKey = dayStart.toISOString().slice(0, 10);
const dayEvents = mapped.filter(
(e) => e.scheduledFor >= dayStart && e.scheduledFor < dayEnd,
);
const takenEvents = dayEvents.filter(
(e) => e.takenAt !== null && !e.skipped,
);
// Classify timing for each taken event against the best-matching schedule
let onTime = 0;
let late = 0;
let veryLate = 0;
for (const evt of takenEvents) {
if (medication.schedules.length === 0) {
// No schedule info: treat all taken as on_time
onTime++;
continue;
}
// Match event to the closest schedule window by scheduledFor time
const evtHour = evt.scheduledFor.getUTCHours();
const evtMin = evt.scheduledFor.getUTCMinutes();
let bestSchedule = medication.schedules[0];
let bestDist = Infinity;
for (const sched of medication.schedules) {
const [sh, sm] = sched.windowStart.split(":").map(Number);
const dist = Math.abs(evtHour * 60 + evtMin - (sh * 60 + sm));
if (dist < bestDist) {
bestDist = dist;
bestSchedule = sched;
}
}
const timing = classifyIntakeTiming(
evt.takenAt,
bestSchedule.windowStart,
bestSchedule.windowEnd,
dayStart, // the scheduled date
);
if (timing === "on_time") onTime++;
else if (timing === "late") late++;
else veryLate++;
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
dailyCompliance[dateKey] = {
expected: schedulesPerDay,
taken: takenEvents.length,
skipped: dayEvents.filter((e) => e.skipped).length,
onTime,
late,
veryLate,
};
}
const events = await prisma.medicationIntakeEvent.findMany({
where: { medicationId: id, userId: user.id },
orderBy: { scheduledFor: "desc" },
});
annotate({
action: {
name: "medication.compliance",
entity_type: "medication",
entity_id: id,
},
meta: { compliance7: compliance7.rate, compliance30: compliance30.rate },
});
const mapped = events.map((e) => ({
takenAt: e.takenAt,
skipped: e.skipped,
scheduledFor: e.scheduledFor,
}));
return apiSuccess({ compliance7, compliance30, dailyCompliance });
});
const createdAt = medication.createdAt;
const compliance7 = calculateCompliance(
mapped,
medication.schedules,
7,
createdAt,
);
const compliance30 = calculateCompliance(
mapped,
medication.schedules,
30,
createdAt,
);
// Build daily compliance map for heatmap/line chart (90 days)
const now = new Date();
const schedulesPerDay = medication.schedules.length;
const dailyCompliance: Record<string, DailyComplianceEntry> = {};
for (let d = 0; d < 90; d++) {
const dayStart = new Date(now.getTime() - (d + 1) * 24 * 60 * 60 * 1000);
const dayEnd = new Date(now.getTime() - d * 24 * 60 * 60 * 1000);
// Skip days before medication was created
if (dayEnd <= createdAt) continue;
const dateKey = dayStart.toISOString().slice(0, 10);
const dayEvents = mapped.filter(
(e) => e.scheduledFor >= dayStart && e.scheduledFor < dayEnd,
);
const takenEvents = dayEvents.filter(
(e) => e.takenAt !== null && !e.skipped,
);
// Classify timing for each taken event against the best-matching schedule
let onTime = 0;
let late = 0;
let veryLate = 0;
for (const evt of takenEvents) {
if (medication.schedules.length === 0) {
// No schedule info: treat all taken as on_time
onTime++;
continue;
}
// Match event to the closest schedule window by scheduledFor time
const evtHour = evt.scheduledFor.getUTCHours();
const evtMin = evt.scheduledFor.getUTCMinutes();
let bestSchedule = medication.schedules[0];
let bestDist = Infinity;
for (const sched of medication.schedules) {
const [sh, sm] = sched.windowStart.split(":").map(Number);
const dist = Math.abs(evtHour * 60 + evtMin - (sh * 60 + sm));
if (dist < bestDist) {
bestDist = dist;
bestSchedule = sched;
}
}
const timing = classifyIntakeTiming(
evt.takenAt,
bestSchedule.windowStart,
bestSchedule.windowEnd,
dayStart, // the scheduled date
);
if (timing === "on_time") onTime++;
else if (timing === "late") late++;
else veryLate++;
}
dailyCompliance[dateKey] = {
expected: schedulesPerDay,
taken: takenEvents.length,
skipped: dayEvents.filter((e) => e.skipped).length,
onTime,
late,
veryLate,
};
}
annotate({
action: {
name: "medication.compliance",
entity_type: "medication",
entity_id: id,
},
meta: { compliance7: compliance7.rate, compliance30: compliance30.rate },
});
return apiSuccess({ compliance7, compliance30, dailyCompliance });
},
);
@@ -2,101 +2,102 @@ import { prisma } from "@/lib/db";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { annotate } from "@/lib/logging/context";
import { auditLog } from "@/lib/auth/audit";
import { apiSuccess, apiError, getClientIp, safeJson } from "@/lib/api-response";
import {
apiSuccess,
apiError,
getClientIp,
safeJson,
} from "@/lib/api-response";
import { updateIntakeEventSchema } from "@/lib/validations/medication";
import { NextRequest } from "next/server";
type RouteParams = { params: Promise<{ id: string; eventId: string }> };
export const PUT = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const PUT = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id, eventId } = await params;
const { id, eventId } = await params;
const event = await prisma.medicationIntakeEvent.findUnique({
where: { id: eventId },
});
const event = await prisma.medicationIntakeEvent.findUnique({
where: { id: eventId },
});
if (
!event ||
event.userId !== user.id ||
event.medicationId !== id
) {
return apiError("Intake not found", 404);
}
if (!event || event.userId !== user.id || event.medicationId !== id) {
return apiError("Intake not found", 404);
}
const { data: body, error: jsonError } = await safeJson(request);
const { data: body, error: jsonError } = await safeJson(request);
if (jsonError) return jsonError;
const parsed = updateIntakeEventSchema.safeParse(body);
if (!parsed.success) {
return apiError(parsed.error.issues[0].message, 422);
}
if (jsonError) return jsonError;
const parsed = updateIntakeEventSchema.safeParse(body);
if (!parsed.success) {
return apiError(parsed.error.issues[0].message, 422);
}
const data = parsed.data;
const updated = await prisma.medicationIntakeEvent.update({
where: { id: eventId },
data: {
...(data.takenAt !== undefined && { takenAt: data.takenAt }),
...(data.skipped !== undefined && { skipped: data.skipped }),
...(data.scheduledFor !== undefined && {
scheduledFor: data.scheduledFor,
}),
},
});
const data = parsed.data;
const updated = await prisma.medicationIntakeEvent.update({
where: { id: eventId },
data: {
...(data.takenAt !== undefined && { takenAt: data.takenAt }),
...(data.skipped !== undefined && { skipped: data.skipped }),
...(data.scheduledFor !== undefined && {
scheduledFor: data.scheduledFor,
}),
},
});
await auditLog("medication.intake.update", {
userId: user.id,
ipAddress: getClientIp(request),
details: { eventId, medicationId: id },
});
await auditLog("medication.intake.update", {
userId: user.id,
ipAddress: getClientIp(request),
details: { eventId, medicationId: id },
});
annotate({
action: {
name: "medication.intake.update",
entity_type: "intake_event",
entity_id: eventId,
},
meta: { medication_id: id },
});
annotate({
action: {
name: "medication.intake.update",
entity_type: "intake_event",
entity_id: eventId,
},
meta: { medication_id: id },
});
return apiSuccess(updated);
});
return apiSuccess(updated);
},
);
export const DELETE = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const DELETE = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id, eventId } = await params;
const { id, eventId } = await params;
const event = await prisma.medicationIntakeEvent.findUnique({
where: { id: eventId },
});
const event = await prisma.medicationIntakeEvent.findUnique({
where: { id: eventId },
});
if (
!event ||
event.userId !== user.id ||
event.medicationId !== id
) {
return apiError("Intake not found", 404);
}
if (!event || event.userId !== user.id || event.medicationId !== id) {
return apiError("Intake not found", 404);
}
await prisma.medicationIntakeEvent.delete({ where: { id: eventId } });
await prisma.medicationIntakeEvent.delete({ where: { id: eventId } });
const ip = getClientIp(request) ?? "unknown";
await auditLog("medication.intake.delete", {
userId: user.id,
ipAddress: ip,
details: { eventId, medicationId: id },
});
const ip = getClientIp(request) ?? "unknown";
await auditLog("medication.intake.delete", {
userId: user.id,
ipAddress: ip,
details: { eventId, medicationId: id },
});
annotate({
action: {
name: "medication.intake.delete",
entity_type: "intake_event",
entity_id: eventId,
},
meta: { medication_id: id },
});
annotate({
action: {
name: "medication.intake.delete",
entity_type: "intake_event",
entity_id: eventId,
},
meta: { medication_id: id },
});
return apiSuccess({ deleted: true });
});
return apiSuccess({ deleted: true });
},
);
@@ -2,7 +2,12 @@ import { prisma } from "@/lib/db";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { annotate } from "@/lib/logging/context";
import { auditLog } from "@/lib/auth/audit";
import { apiSuccess, apiError, getClientIp, safeJson } from "@/lib/api-response";
import {
apiSuccess,
apiError,
getClientIp,
safeJson,
} from "@/lib/api-response";
import { NextRequest } from "next/server";
import { z } from "zod/v4";
@@ -16,97 +21,101 @@ const importSchema = z.array(importEntrySchema).min(1).max(1000);
type RouteParams = { params: Promise<{ id: string }> };
export const POST = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const POST = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { data: body, error: jsonError } = await safeJson(request);
if (jsonError) return jsonError;
// Support both direct arrays and object-with-array payloads
const payload = Array.isArray(body)
? body
: typeof body === "object" && body !== null
? Object.values(body).find((value) => Array.isArray(value))
: null;
const parsed = importSchema.safeParse(payload);
if (!parsed.success) {
return apiError(
`Invalid format: ${parsed.error.issues[0].message}`,
422,
);
}
const entries = parsed.data;
let imported = 0;
let skippedDuplicates = 0;
let skippedInvalid = 0;
for (const entry of entries) {
// Parse as local datetime first; if invalid, fall back to CET offset.
let takenAt = new Date(`${entry.datum}T${entry.uhrzeit}`);
if (isNaN(takenAt.getTime())) {
takenAt = new Date(`${entry.datum}T${entry.uhrzeit}+01:00`);
}
if (isNaN(takenAt.getTime())) {
skippedInvalid++;
continue;
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
// Prefer explicit counter; otherwise use timestamp-based dedup key.
const idempotencyKey = entry.zaehler
? `import-${id}-${String(entry.zaehler)}`
: `import-${id}-${takenAt.getTime()}`;
const { data: body, error: jsonError } = await safeJson(request);
const existing = await prisma.medicationIntakeEvent.findUnique({
where: { idempotencyKey },
});
if (existing) {
skippedDuplicates++;
continue;
if (jsonError) return jsonError;
// Support both direct arrays and object-with-array payloads
const payload = Array.isArray(body)
? body
: typeof body === "object" && body !== null
? Object.values(body).find((value) => Array.isArray(value))
: null;
const parsed = importSchema.safeParse(payload);
if (!parsed.success) {
return apiError(`Invalid format: ${parsed.error.issues[0].message}`, 422);
}
await prisma.medicationIntakeEvent.create({
data: {
userId: user.id,
const entries = parsed.data;
let imported = 0;
let skippedDuplicates = 0;
let skippedInvalid = 0;
for (const entry of entries) {
// Parse as local datetime first; if invalid, fall back to CET offset.
let takenAt = new Date(`${entry.datum}T${entry.uhrzeit}`);
if (isNaN(takenAt.getTime())) {
takenAt = new Date(`${entry.datum}T${entry.uhrzeit}+01:00`);
}
if (isNaN(takenAt.getTime())) {
skippedInvalid++;
continue;
}
// Prefer explicit counter; otherwise use timestamp-based dedup key.
const idempotencyKey = entry.zaehler
? `import-${id}-${String(entry.zaehler)}`
: `import-${id}-${takenAt.getTime()}`;
const existing = await prisma.medicationIntakeEvent.findUnique({
where: { idempotencyKey },
});
if (existing) {
skippedDuplicates++;
continue;
}
await prisma.medicationIntakeEvent.create({
data: {
userId: user.id,
medicationId: id,
scheduledFor: takenAt,
takenAt,
skipped: false,
source: "IMPORT",
idempotencyKey,
},
});
imported++;
}
await auditLog("medication.intake.import", {
userId: user.id,
ipAddress: getClientIp(request),
details: {
medicationId: id,
scheduledFor: takenAt,
takenAt,
skipped: false,
source: "IMPORT",
idempotencyKey,
imported,
skippedDuplicates,
skippedInvalid,
total: entries.length,
},
});
imported++;
}
await auditLog("medication.intake.import", {
userId: user.id,
ipAddress: getClientIp(request),
details: {
medicationId: id,
imported,
skippedDuplicates,
skippedInvalid,
total: entries.length,
},
});
annotate({
action: {
name: "medication.intake.import",
entity_type: "medication",
entity_id: id,
},
meta: {
imported,
skippedDuplicates,
skippedInvalid,
total: entries.length,
},
});
annotate({
action: {
name: "medication.intake.import",
entity_type: "medication",
entity_id: id,
},
meta: { imported, skippedDuplicates, skippedInvalid, total: entries.length },
});
return apiSuccess({ imported, skippedDuplicates, skippedInvalid }, 201);
});
return apiSuccess({ imported, skippedDuplicates, skippedInvalid }, 201);
},
);
@@ -7,33 +7,35 @@ import { NextRequest } from "next/server";
type RouteParams = { params: Promise<{ id: string }> };
export const DELETE = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const DELETE = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({ where: { id } });
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { count } = await prisma.medicationIntakeEvent.deleteMany({
where: { medicationId: id, userId: user.id },
});
const { count } = await prisma.medicationIntakeEvent.deleteMany({
where: { medicationId: id, userId: user.id },
});
await auditLog("medication.intake.purge", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, name: medication.name, deletedCount: count },
});
await auditLog("medication.intake.purge", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, name: medication.name, deletedCount: count },
});
annotate({
action: {
name: "medication.intake.purge",
entity_type: "medication",
entity_id: id,
},
meta: { purged_count: count },
});
annotate({
action: {
name: "medication.intake.purge",
entity_type: "medication",
entity_id: id,
},
meta: { purged_count: count },
});
return apiSuccess({ purged: true, count });
});
return apiSuccess({ purged: true, count });
},
);
@@ -7,108 +7,114 @@ import { NextRequest } from "next/server";
type RouteParams = { params: Promise<{ id: string }> };
export const GET = apiHandler(async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const GET = apiHandler(
async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const config = await prisma.reminderPhaseConfig.findUnique({
where: { medicationId: id },
});
const config = await prisma.reminderPhaseConfig.findUnique({
where: { medicationId: id },
});
annotate({
action: {
name: "medication.phase_config.get",
entity_type: "medication",
entity_id: id,
},
});
annotate({
action: {
name: "medication.phase_config.get",
entity_type: "medication",
entity_id: id,
},
});
// Return config or defaults
return apiSuccess(
config ?? {
greenValue: 60,
greenMode: "MINUTES",
yellowValue: 30,
yellowMode: "MINUTES",
orangeValue: 0,
orangeMode: "MINUTES",
redValue: 240,
redMode: "MINUTES",
},
);
});
// Return config or defaults
return apiSuccess(
config ?? {
greenValue: 60,
greenMode: "MINUTES",
yellowValue: 30,
yellowMode: "MINUTES",
orangeValue: 0,
orangeMode: "MINUTES",
redValue: 240,
redMode: "MINUTES",
},
);
},
);
export const PUT = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const PUT = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { data: body, error: jsonError } = await safeJson(request);
const { data: body, error: jsonError } = await safeJson(request);
if (jsonError) return jsonError;
const parsed = phaseConfigSchema.safeParse(body);
if (!parsed.success) {
return apiError("Invalid input", 400);
}
if (jsonError) return jsonError;
const parsed = phaseConfigSchema.safeParse(body);
if (!parsed.success) {
return apiError("Invalid input", 400);
}
const config = await prisma.reminderPhaseConfig.upsert({
where: { medicationId: id },
create: {
medicationId: id,
...parsed.data,
},
update: parsed.data,
});
const config = await prisma.reminderPhaseConfig.upsert({
where: { medicationId: id },
create: {
medicationId: id,
...parsed.data,
},
update: parsed.data,
});
annotate({
action: {
name: "medication.phase_config.update",
entity_type: "medication",
entity_id: id,
},
});
annotate({
action: {
name: "medication.phase_config.update",
entity_type: "medication",
entity_id: id,
},
});
return apiSuccess(config);
});
return apiSuccess(config);
},
);
export const DELETE = apiHandler(async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const DELETE = apiHandler(
async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
select: { userId: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
await prisma.reminderPhaseConfig.deleteMany({
where: { medicationId: id },
});
await prisma.reminderPhaseConfig.deleteMany({
where: { medicationId: id },
});
annotate({
action: {
name: "medication.phase_config.reset",
entity_type: "medication",
entity_id: id,
},
});
annotate({
action: {
name: "medication.phase_config.reset",
entity_type: "medication",
entity_id: id,
},
});
return apiSuccess({ reset: true });
});
return apiSuccess({ reset: true });
},
);
+183 -172
View File
@@ -2,7 +2,12 @@ import { prisma } from "@/lib/db";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { annotate } from "@/lib/logging/context";
import { auditLog } from "@/lib/auth/audit";
import { apiSuccess, apiError, getClientIp, safeJson } from "@/lib/api-response";
import {
apiSuccess,
apiError,
getClientIp,
safeJson,
} from "@/lib/api-response";
import { updateMedicationSchema } from "@/lib/validations/medication";
import {
deleteMedicationCategory,
@@ -14,193 +19,199 @@ import { NextRequest } from "next/server";
type RouteParams = { params: Promise<{ id: string }> };
export const GET = apiHandler(async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
export const GET = apiHandler(
async (_request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
include: { schedules: true },
});
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
let category = "OTHER";
try {
const categories = await getMedicationCategories([id]);
category = categories[id] ?? "OTHER";
} catch {
// Category enrichment is optional
}
annotate({
action: {
name: "medication.get",
entity_type: "medication",
entity_id: id,
},
});
return apiSuccess({ ...medication, category });
});
export const PUT = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { id } = await params;
const existing = await prisma.medication.findUnique({ where: { id } });
if (!existing || existing.userId !== user.id) {
return apiError("Medication not found", 404);
}
const { data: body, error: jsonError } = await safeJson(request);
if (jsonError) return jsonError;
const parsed = updateMedicationSchema.safeParse(body);
if (!parsed.success) {
return apiError(parsed.error.issues[0].message, 422);
}
const { name, dose, category, active, notificationsEnabled, schedules } =
parsed.data;
const pausedAtPatch =
active === undefined
? {}
: active
? { pausedAt: null as Date | null }
: existing.active
? { pausedAt: new Date() }
: {};
// If schedules provided, replace all
if (schedules) {
await prisma.medicationSchedule.deleteMany({
where: { medicationId: id },
const { id } = await params;
const medication = await prisma.medication.findUnique({
where: { id },
include: { schedules: true },
});
}
const baseUpdateData = {
...(name !== undefined && { name }),
...(dose !== undefined && { dose }),
...(active !== undefined && { active }),
...(notificationsEnabled !== undefined && { notificationsEnabled }),
...(schedules && {
schedules: {
create: schedules.map((s) => ({
windowStart: s.windowStart,
windowEnd: s.windowEnd,
label: s.label ?? null,
dose: s.dose ?? null,
daysOfWeek: serializeScheduleRecurrence({
daysOfWeek: s.daysOfWeek ?? [],
intervalWeeks: s.intervalWeeks ?? 1,
}),
})),
},
}),
};
const withoutNotifications = { ...baseUpdateData } as Record<
string,
unknown
>;
delete withoutNotifications.notificationsEnabled;
const hasPausedAtPatch = Object.keys(pausedAtPatch).length > 0;
const hasNotificationsPatch = notificationsEnabled !== undefined;
const updateCandidates: Array<Record<string, unknown>> = [
{ ...baseUpdateData, ...pausedAtPatch },
];
if (hasPausedAtPatch) {
updateCandidates.push(baseUpdateData);
}
if (hasNotificationsPatch) {
updateCandidates.push({ ...withoutNotifications, ...pausedAtPatch });
if (hasPausedAtPatch) {
updateCandidates.push(withoutNotifications);
if (!medication || medication.userId !== user.id) {
return apiError("Medication not found", 404);
}
}
let medication;
let lastUpdateErr: unknown;
for (const candidate of updateCandidates) {
let category = "OTHER";
try {
medication = await prisma.medication.update({
where: { id },
data: candidate,
include: { schedules: true },
});
break;
} catch (updateErr) {
lastUpdateErr = updateErr;
const categories = await getMedicationCategories([id]);
category = categories[id] ?? "OTHER";
} catch {
// Category enrichment is optional
}
}
if (!medication) throw lastUpdateErr;
const normalizedCategory =
category !== undefined
? await setMedicationCategory(id, category)
: ((await getMedicationCategories([id]))[id] ?? "OTHER");
annotate({
action: {
name: "medication.get",
entity_type: "medication",
entity_id: id,
},
});
await auditLog("medication.update", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id },
});
return apiSuccess({ ...medication, category });
},
);
annotate({
action: {
name: "medication.update",
entity_type: "medication",
entity_id: id,
},
});
export const PUT = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
return apiSuccess({
...medication,
category: normalizedCategory,
});
});
const { id } = await params;
const existing = await prisma.medication.findUnique({ where: { id } });
if (!existing || existing.userId !== user.id) {
return apiError("Medication not found", 404);
}
export const DELETE = apiHandler(async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
const { data: body, error: jsonError } = await safeJson(request);
const { id } = await params;
const existing = await prisma.medication.findUnique({ where: { id } });
if (!existing || existing.userId !== user.id) {
return apiError("Medication not found", 404);
}
if (jsonError) return jsonError;
const parsed = updateMedicationSchema.safeParse(body);
if (!parsed.success) {
return apiError(parsed.error.issues[0].message, 422);
}
// Revoke API tokens scoped to this medication
const medicationScope = `medication:${id}:ingest`;
await prisma.apiToken.updateMany({
where: {
const { name, dose, category, active, notificationsEnabled, schedules } =
parsed.data;
const pausedAtPatch =
active === undefined
? {}
: active
? { pausedAt: null as Date | null }
: existing.active
? { pausedAt: new Date() }
: {};
// If schedules provided, replace all
if (schedules) {
await prisma.medicationSchedule.deleteMany({
where: { medicationId: id },
});
}
const baseUpdateData = {
...(name !== undefined && { name }),
...(dose !== undefined && { dose }),
...(active !== undefined && { active }),
...(notificationsEnabled !== undefined && { notificationsEnabled }),
...(schedules && {
schedules: {
create: schedules.map((s) => ({
windowStart: s.windowStart,
windowEnd: s.windowEnd,
label: s.label ?? null,
dose: s.dose ?? null,
daysOfWeek: serializeScheduleRecurrence({
daysOfWeek: s.daysOfWeek ?? [],
intervalWeeks: s.intervalWeeks ?? 1,
}),
})),
},
}),
};
const withoutNotifications = { ...baseUpdateData } as Record<
string,
unknown
>;
delete withoutNotifications.notificationsEnabled;
const hasPausedAtPatch = Object.keys(pausedAtPatch).length > 0;
const hasNotificationsPatch = notificationsEnabled !== undefined;
const updateCandidates: Array<Record<string, unknown>> = [
{ ...baseUpdateData, ...pausedAtPatch },
];
if (hasPausedAtPatch) {
updateCandidates.push(baseUpdateData);
}
if (hasNotificationsPatch) {
updateCandidates.push({ ...withoutNotifications, ...pausedAtPatch });
if (hasPausedAtPatch) {
updateCandidates.push(withoutNotifications);
}
}
let medication;
let lastUpdateErr: unknown;
for (const candidate of updateCandidates) {
try {
medication = await prisma.medication.update({
where: { id },
data: candidate,
include: { schedules: true },
});
break;
} catch (updateErr) {
lastUpdateErr = updateErr;
}
}
if (!medication) throw lastUpdateErr;
const normalizedCategory =
category !== undefined
? await setMedicationCategory(id, category)
: ((await getMedicationCategories([id]))[id] ?? "OTHER");
await auditLog("medication.update", {
userId: user.id,
revoked: false,
permissions: { has: medicationScope },
},
data: { revoked: true },
});
ipAddress: getClientIp(request),
details: { medicationId: id },
});
await deleteMedicationCategory(id);
await prisma.medication.delete({ where: { id } });
annotate({
action: {
name: "medication.update",
entity_type: "medication",
entity_id: id,
},
});
await auditLog("medication.delete", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, name: existing.name },
});
return apiSuccess({
...medication,
category: normalizedCategory,
});
},
);
annotate({
action: {
name: "medication.delete",
entity_type: "medication",
entity_id: id,
},
});
export const DELETE = apiHandler(
async (request: NextRequest, { params }: RouteParams) => {
const { user } = await requireAuth();
return apiSuccess({ deleted: true });
});
const { id } = await params;
const existing = await prisma.medication.findUnique({ where: { id } });
if (!existing || existing.userId !== user.id) {
return apiError("Medication not found", 404);
}
// Revoke API tokens scoped to this medication
const medicationScope = `medication:${id}:ingest`;
await prisma.apiToken.updateMany({
where: {
userId: user.id,
revoked: false,
permissions: { has: medicationScope },
},
data: { revoked: true },
});
await deleteMedicationCategory(id);
await prisma.medication.delete({ where: { id } });
await auditLog("medication.delete", {
userId: user.id,
ipAddress: getClientIp(request),
details: { medicationId: id, name: existing.name },
});
annotate({
action: {
name: "medication.delete",
entity_type: "medication",
entity_id: id,
},
});
return apiSuccess({ deleted: true });
},
);
@@ -92,7 +92,10 @@ export const GET = apiHandler(async (request: NextRequest) => {
annotate({
action: { name: "medication.intake_summary" },
meta: { point_count: points.length, medication_count: medicationNames.size },
meta: {
point_count: points.length,
medication_count: medicationNames.size,
},
});
return apiSuccess({
@@ -27,7 +27,11 @@ vi.mock("@/lib/db-compat", () => ({
vi.mock("next/headers", () => ({
headers: vi.fn(async () => ({ get: () => null })),
cookies: vi.fn(async () => ({ get: () => undefined, set: () => {}, delete: () => {} })),
cookies: vi.fn(async () => ({
get: () => undefined,
set: () => {},
delete: () => {},
})),
}));
import { GET, POST } from "../route";
@@ -41,7 +45,9 @@ const SESSION_OK = {
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([] as never);
vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue(
[] as never,
);
});
describe("GET /api/medications/intake", () => {
+7 -3
View File
@@ -14,7 +14,12 @@
import { NextRequest } from "next/server";
import { z } from "zod/v4";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { apiError, apiSuccess, getClientIp, safeJson } from "@/lib/api-response";
import {
apiError,
apiSuccess,
getClientIp,
safeJson,
} from "@/lib/api-response";
import { annotate } from "@/lib/logging/context";
import { prisma } from "@/lib/db";
import { auditLog } from "@/lib/auth/audit";
@@ -175,8 +180,7 @@ export const POST = apiHandler(async (request: NextRequest) => {
});
} else {
// snoozed: snoozedUntil lives on the Medication row.
const until =
snoozedUntil ?? new Date(Date.now() + 30 * 60_000); // default +30min
const until = snoozedUntil ?? new Date(Date.now() + 30 * 60_000); // default +30min
await prisma.medication.update({
where: { id: existing.medicationId },
data: { snoozedUntil: until },
+6 -1
View File
@@ -2,7 +2,12 @@ import { prisma } from "@/lib/db";
import { apiHandler, requireAuth } from "@/lib/api-handler";
import { annotate, getEvent } from "@/lib/logging/context";
import { auditLog } from "@/lib/auth/audit";
import { apiSuccess, apiError, getClientIp, safeJson } from "@/lib/api-response";
import {
apiSuccess,
apiError,
getClientIp,
safeJson,
} from "@/lib/api-response";
import { createMedicationSchema } from "@/lib/validations/medication";
import {
getMedicationCategories,