mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-18 08:02:12 +00:00
The mood entry was committed before createTagLinks/replaceTagLinks ran, so a tag-link failure 5xx'd after the entry already existed and a client retry minted a duplicate entry. Wrap the entry write and the tag-link write in one $transaction and thread the tx client through both helpers so they commit or roll back together.
264 lines
8.6 KiB
TypeScript
264 lines
8.6 KiB
TypeScript
import { prisma } from "@/lib/db";
|
|
import { auditLog } from "@/lib/auth/audit";
|
|
import {
|
|
apiSuccess,
|
|
apiError,
|
|
getClientIp,
|
|
returnAllZodIssues,
|
|
safeJson,
|
|
sanitiseZodIssues,
|
|
} from "@/lib/api-response";
|
|
import {
|
|
createMoodEntrySchema,
|
|
listMoodEntriesSchema,
|
|
getScoreForMood,
|
|
} from "@/lib/validations/moodlog";
|
|
import { NextRequest } from "next/server";
|
|
import { Prisma } from "@/generated/prisma/client";
|
|
import { apiHandler, requireAuth } from "@/lib/api-handler";
|
|
import { annotate } from "@/lib/logging/context";
|
|
import { withIdempotency } from "@/lib/idempotency";
|
|
import { moodDateKey, DEFAULT_TIMEZONE } from "@/lib/mood/date-key";
|
|
import { invalidateUserMood } from "@/lib/cache/invalidate";
|
|
import { recomputeMoodBucketsForEntry } from "@/lib/rollups/mood-rollups";
|
|
import { pushMoodEntriesToMoodLog } from "@/lib/moodlog/push";
|
|
import { createTagLinks } from "@/lib/mood/tag-links";
|
|
|
|
function parseTags(tags: string | null): string[] {
|
|
if (!tags) return [];
|
|
try {
|
|
return JSON.parse(tags) as string[];
|
|
} catch {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
export const GET = apiHandler(async (request: NextRequest) => {
|
|
const { user } = await requireAuth();
|
|
|
|
const params = Object.fromEntries(request.nextUrl.searchParams);
|
|
const parsed = listMoodEntriesSchema.safeParse(params);
|
|
if (!parsed.success) {
|
|
// v1.4.43 W6 — surface every Zod issue + audit breadcrumb keyed
|
|
// `mood-entries.list.validation-failed`.
|
|
const issues = sanitiseZodIssues(parsed.error.issues);
|
|
annotate({
|
|
action: { name: "mood-entries.list.validation-failed" },
|
|
meta: { issue_count: issues.length },
|
|
});
|
|
// v1.4.49 — strip `message` from the audit-ledger row so Zod
|
|
// codes that embed the offending value (`invalid_enum_value` etc.)
|
|
// cannot leak user-typed content. Mood-entries carry free-text
|
|
// `note` + `tags`; defensive strip everywhere mood content can
|
|
// reach a Zod issue.
|
|
const auditIssues = sanitiseZodIssues(parsed.error.issues, {
|
|
stripValuesFromMessage: true,
|
|
});
|
|
prisma.auditLog
|
|
.create({
|
|
data: {
|
|
userId: user.id,
|
|
action: "mood-entries.list.validation-failed",
|
|
details: JSON.stringify({ issues: auditIssues }),
|
|
},
|
|
})
|
|
.catch(() => {
|
|
/* swallow — 422 response is the contract */
|
|
});
|
|
return returnAllZodIssues(parsed.error, 422);
|
|
}
|
|
|
|
const { mood, from, to, limit, offset, sortBy, sortDir } = parsed.data;
|
|
|
|
const where = {
|
|
userId: user.id,
|
|
// v1.7.0 sync — hide soft-deleted (tombstoned) rows from the list.
|
|
deletedAt: null,
|
|
...(mood && { mood }),
|
|
...(from || to
|
|
? {
|
|
date: {
|
|
...(from && { gte: from }),
|
|
...(to && { lte: to }),
|
|
},
|
|
}
|
|
: {}),
|
|
};
|
|
|
|
const [entries, total] = await Promise.all([
|
|
prisma.moodEntry.findMany({
|
|
where,
|
|
orderBy: { [sortBy]: sortDir },
|
|
take: limit,
|
|
skip: offset,
|
|
// v1.8.5 — include the structured-tag link keys so the edit form
|
|
// can pre-populate the taxonomy picker.
|
|
include: {
|
|
tagLinks: {
|
|
select: { moodTag: { select: { key: true } } },
|
|
},
|
|
},
|
|
}),
|
|
prisma.moodEntry.count({ where }),
|
|
]);
|
|
|
|
annotate({
|
|
action: { name: "mood-entries.list" },
|
|
meta: { total, limit, offset },
|
|
});
|
|
|
|
const entriesWithParsedTags = entries.map(({ tagLinks, ...e }) => ({
|
|
...e,
|
|
tags: parseTags(e.tags),
|
|
// v1.8.5 — flat list of structured-tag keys attached to the entry.
|
|
tagKeys: tagLinks.map((link) => link.moodTag.key),
|
|
}));
|
|
|
|
return apiSuccess({
|
|
entries: entriesWithParsedTags,
|
|
meta: { total, limit, offset },
|
|
});
|
|
});
|
|
|
|
export const POST = apiHandler(withIdempotency<[NextRequest]>(postMoodEntry));
|
|
|
|
async function postMoodEntry(request: NextRequest) {
|
|
const { user } = await requireAuth();
|
|
|
|
const { data: body, error: jsonError } = await safeJson(request);
|
|
|
|
if (jsonError) return jsonError;
|
|
const parsed = createMoodEntrySchema.safeParse(body);
|
|
if (!parsed.success) {
|
|
// v1.4.43 W6 — iOS mood log hot path; multi-issue 422 + audit
|
|
// breadcrumb keyed `mood-entries.create.validation-failed`.
|
|
const issues = sanitiseZodIssues(parsed.error.issues);
|
|
annotate({
|
|
action: { name: "mood-entries.create.validation-failed" },
|
|
meta: { issue_count: issues.length },
|
|
});
|
|
// v1.4.49 — strip `message` from the audit-ledger row; the
|
|
// mood-create schema's free-text `note` + `tags` could land in a
|
|
// Zod issue message verbatim.
|
|
const auditIssues = sanitiseZodIssues(parsed.error.issues, {
|
|
stripValuesFromMessage: true,
|
|
});
|
|
prisma.auditLog
|
|
.create({
|
|
data: {
|
|
userId: user.id,
|
|
action: "mood-entries.create.validation-failed",
|
|
details: JSON.stringify({ issues: auditIssues }),
|
|
},
|
|
})
|
|
.catch(() => {
|
|
/* swallow — 422 response is the contract */
|
|
});
|
|
return returnAllZodIssues(parsed.error, 422);
|
|
}
|
|
|
|
const { mood, tags, tagKeys, note, moodLoggedAt, source } = parsed.data;
|
|
// v1.4.25 W7b (Decision A) — anchor the `date` string to the user's
|
|
// current displayTimezone and store the resolved zone on the row.
|
|
// Legacy rows with `tz IS NULL` continue to read as Europe/Berlin
|
|
// (see `src/lib/mood/date-key.ts`).
|
|
const tz = user.timezone ?? DEFAULT_TIMEZONE;
|
|
const date = moodDateKey(moodLoggedAt, tz);
|
|
const score = getScoreForMood(mood);
|
|
|
|
try {
|
|
// v1.8.5 — write the entry and its structured-tag links in one
|
|
// transaction. The links are user-intended content, not a cache, so a
|
|
// tag-link failure must roll the entry back too — otherwise a client
|
|
// retry on the 5xx mints a duplicate entry. The tx client is threaded
|
|
// through the helper so both writes commit (or abort) together.
|
|
const entry = await prisma.$transaction(async (tx) => {
|
|
const created = await tx.moodEntry.create({
|
|
data: {
|
|
userId: user.id,
|
|
date,
|
|
tz,
|
|
mood,
|
|
score,
|
|
tags: tags ? JSON.stringify(tags) : null,
|
|
note: note ?? null,
|
|
source: source ?? "MANUAL",
|
|
moodLoggedAt,
|
|
},
|
|
});
|
|
|
|
if (tagKeys && tagKeys.length > 0) {
|
|
// Unknown keys are dropped inside the helper (the catalog is the
|
|
// source of truth).
|
|
await createTagLinks(created.id, tagKeys, tx);
|
|
}
|
|
|
|
return created;
|
|
});
|
|
|
|
await auditLog("moodEntry.create", {
|
|
userId: user.id,
|
|
ipAddress: getClientIp(request),
|
|
details: { moodEntryId: entry.id, mood },
|
|
});
|
|
|
|
annotate({
|
|
action: { name: "mood-entries.create" },
|
|
meta: { moodEntryId: entry.id, mood },
|
|
});
|
|
|
|
// v1.4.34 IW-G — bust per-user mood + achievements + analytics caches.
|
|
invalidateUserMood(user.id);
|
|
|
|
// v1.4.39 W-MOOD — refresh the persisted DAY rollup for the
|
|
// entry's bucket and enqueue the WEEK / MONTH / YEAR folds.
|
|
// Best-effort: a failure here must not surface as a 5xx to the
|
|
// user, the rollup is a cache tier, not a write-path invariant.
|
|
try {
|
|
await recomputeMoodBucketsForEntry(user.id, moodLoggedAt);
|
|
} catch (rollupErr) {
|
|
annotate({
|
|
meta: {
|
|
mood_rollup_write_failed: true,
|
|
mood_rollup_write_error:
|
|
rollupErr instanceof Error ? rollupErr.message : String(rollupErr),
|
|
},
|
|
});
|
|
}
|
|
|
|
// v1.4.50 — reverse-sync push to MoodLog. Fire-and-forget; the
|
|
// helper itself is best-effort and never throws, so a 502 from
|
|
// MoodLog or a transient network blip can never bubble back to
|
|
// the user's create. The pull side (15-min cron) backfills any
|
|
// entry that fails the push window. Entries with `source ===
|
|
// "MOODLOG"` skip inside the helper to avoid an echo loop.
|
|
void pushMoodEntriesToMoodLog(user.id, [
|
|
{
|
|
date: entry.date,
|
|
moodLoggedAt: entry.moodLoggedAt,
|
|
mood: entry.mood,
|
|
note: entry.note ?? null,
|
|
tags: entry.tags,
|
|
source: entry.source,
|
|
},
|
|
]).catch(() => {
|
|
// The helper already wraps its own errors in wide-event
|
|
// warnings. The void + .catch is defence-in-depth so a
|
|
// synchronous throw inside the helper's promise chain (e.g. a
|
|
// future refactor that adds an await on a rejected promise
|
|
// before the first try/catch) can't surface as an unhandled
|
|
// rejection in the Next.js runtime.
|
|
});
|
|
|
|
return apiSuccess({ ...entry, tags: parseTags(entry.tags) }, 201);
|
|
} catch (err) {
|
|
if (
|
|
err instanceof Prisma.PrismaClientKnownRequestError &&
|
|
err.code === "P2002"
|
|
) {
|
|
return apiError("A mood entry with this data already exists", 409);
|
|
}
|
|
throw err;
|
|
}
|
|
}
|