Delning av böcker, skydd mot kolliderande ändringar och import från Word

Böcker kan delas med roller (läsare, redaktör, administratör), och
behörigheten kontrolleras på servern. Formulär för poster, relationer och
händelser skickar med version, och en krock visar vad som skiljer och låter
användaren spara ändå eller ladda om. Ifyllda Word-mallar kan importeras med
förhandsgranskning. Importerade ID flyttar nu räknaren. Migrering 0007.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
bobbanandClaude Sonnet 5.5 committed 2026-11-04 23:53:33 +01:00
1 parent bd269d70a5
commit 86fd435438
64 files changed
+4796 -235

No files matched your search

+242
View File
@@ -0,0 +1,242 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { UPLOAD_DIR, saveImageBytes } from "@/lib/files";
import { MAX_VERSIONS } from "@/lib/history";
import { isStale, versionOf, type ConflictInfo, type SaveResult } from "@/lib/conflict";
import { makeImage } from "../helpers/fixtures";
import { describeDb, filesIn, makeBook, makeEntity, makeEvent, makeRelation, makeUser, prisma, resetAll } from "../helpers/db";
const login = vi.hoisted(() => ({ userId: "" as string }));
vi.mock("@/auth", () => ({ auth: async () => (login.userId ? { user: { id: login.userId } } : null) }));
vi.mock("next/cache", () => ({ revalidatePath: () => undefined }));
vi.mock("next/navigation", () => ({
redirect: (to: string) => {
throw new Error(`REDIRECT:${to}`);
},
notFound: () => {
throw new Error("NOT_FOUND");
},
}));
vi.mock("@/i18n/server", async () => {
const core = await import("@/i18n/core");
return { getLocale: async () => "sv", getT: async () => ({ locale: "sv", t: core.makeT(core.dictionaries.sv) }) };
});
import { saveEntity } from "@/actions/entities";
import { saveEvent } from "@/actions/events";
import { saveRelation } from "@/actions/relations";
const form = (fields: Record<string, string | string[] | Blob>) => {
const data = new FormData();
for (const [key, value] of Object.entries(fields)) {
if (value instanceof Blob) data.append(key, value, "bild.png");
else for (const v of Array.isArray(value) ? value : [value]) data.append(key, v);
}
return data;
};
/** Kör en sparåtgärd. Antingen omdirigerar den (sparat) eller svarar med en krock. */
async function save(run: () => Promise<SaveResult>): Promise<{ saved: true; to: string } | { saved: false; conflict: ConflictInfo }> {
try {
const result = await run();
if (result?.conflict) return { saved: false, conflict: result.conflict };
throw new Error("Åtgärden svarade varken med omdirigering eller krock");
} catch (error) {
const message = error instanceof Error ? error.message : "";
if (message.startsWith("REDIRECT:")) return { saved: true, to: message.slice(9) };
throw error;
}
}
describe("isStale", () => {
const now = new Date("2026-01-01T12:00:00.000Z");
it("jämför versionen som formuläret öppnades med", () => {
expect(isStale(versionOf(now), now)).toBe(false);
expect(isStale(versionOf(new Date(now.getTime() - 1)), now)).toBe(true);
});
it("kontrollerar inget när versionen saknas", () => {
expect(isStale("", now)).toBe(false);
});
});
describeDb("skydd mot kolliderande ändringar", () => {
let ownerId: string;
let otherId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
const owner = await makeUser("Ägare");
const other = await makeUser("Kollega", "kollega@example.com");
ownerId = owner.id;
otherId = other.id;
bookId = (await makeBook(ownerId)).id;
await prisma.bookMember.create({ data: { bookId, userId: otherId, role: "EDITOR" } });
login.userId = ownerId;
});
describe("poster", () => {
const edit = (id: string, version: string, fields: Record<string, string> = {}) =>
save(() => saveEntity(form({ bookId, id, name: "Anna", version, ...fields })));
it("sparar när versionen stämmer, och ger en ny version", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const result = await edit(anna.id, versionOf(anna.updatedAt), { summary: "Ny" });
expect(result).toMatchObject({ saved: true });
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
expect(after.summary).toBe("Ny");
expect(after.updatedById).toBe(ownerId);
expect(versionOf(after.updatedAt)).not.toBe(versionOf(anna.updatedAt));
});
it("sparar ingenting när någon annan hunnit före, och visar vad som skiljer", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början", data: { nickname: "Ann" } });
const opened = versionOf(anna.updatedAt);
// Kollegan sparar först
login.userId = otherId;
await edit(anna.id, opened, { summary: "Kollegans text", f_nickname: "Ann" });
// Sedan sparar den första med den gamla versionen
login.userId = ownerId;
const result = await edit(anna.id, opened, { summary: "Min text", f_nickname: "Annie" });
expect(result.saved).toBe(false);
if (result.saved) return;
expect(result.conflict.by).toBe("Kollega");
expect(result.conflict.changes).toEqual(
expect.arrayContaining([
{ label: "Sammanfattning", before: "Kollegans text", after: "Min text" },
{ label: "Smeknamn", before: "Ann", after: "Annie" },
]),
);
const stored = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
expect(stored.summary).toBe("Kollegans text");
expect(stored.updatedById).toBe(otherId);
});
it("att spara ändå med den nya versionen skriver över, och den andras version hamnar i historiken", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { summary: "Från början" });
const opened = versionOf(anna.updatedAt);
login.userId = otherId;
await edit(anna.id, opened, { summary: "Kollegans text" });
login.userId = ownerId;
const conflict = await edit(anna.id, opened, { summary: "Min text" });
if (conflict.saved) throw new Error("Väntade en krock");
const forced = await edit(anna.id, conflict.conflict.version, { summary: "Min text" });
expect(forced.saved).toBe(true);
expect((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).summary).toBe("Min text");
const versions = await prisma.entityVersion.findMany({ where: { entityId: anna.id }, orderBy: { createdAt: "asc" } });
const summaries = versions.map((v) => (v.snapshot as { summary: string }).summary);
expect(summaries).toEqual(["Från början", "Kollegans text"]);
expect(versions[1].userId).toBe(ownerId);
});
it("tre samtidiga redigerare: bara en kommer igenom med samma version", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const opened = versionOf(anna.updatedAt);
const results = await Promise.all([1, 2, 3].map((n) => edit(anna.id, opened, { summary: `Text ${n}` }).catch((e) => ({ error: String(e) }))));
const saved = results.filter((r) => "saved" in r && r.saved).length;
const conflicts = results.filter((r) => "saved" in r && !r.saved).length;
expect(saved).toBe(1);
expect(conflicts).toBe(2);
});
it("en ny bild läggs inte kvar som skräp när sparningen avbryts av en krock", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const opened = versionOf(anna.updatedAt);
await edit(anna.id, opened, { summary: "Först" });
const before = await filesIn(UPLOAD_DIR);
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
const result = await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", version: opened, image: png })));
expect(result.saved).toBe(false);
expect(await filesIn(UPLOAD_DIR)).toEqual(before);
});
it("en bild som byts ut tar bort den gamla först när sparningen lyckats", async () => {
const old = await saveImageBytes(await makeImage(40, 40, "png"));
const anna = await makeEntity(bookId, "CHARACTER", "Anna", { imageFile: old });
const png = new Blob([(await makeImage(50, 50, "png")) as BlobPart], { type: "image/png" });
const result = await edit(anna.id, versionOf(anna.updatedAt), { image: png as unknown as string });
expect(result.saved).toBe(true);
const after = await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } });
expect(after.imageFile).toBeTruthy();
expect(after.imageFile).not.toBe(old);
expect(await filesIn(UPLOAD_DIR)).not.toContain(old);
});
it("formulär utan version sparas som förut", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
expect((await save(() => saveEntity(form({ bookId, id: anna.id, name: "Anna", summary: "Utan version" })))).saved).toBe(true);
});
it("nya poster behöver ingen version", async () => {
const result = await save(() => saveEntity(form({ bookId, kind: "CHARACTER", name: "Ny", version: "" })));
expect(result.saved).toBe(true);
expect((await prisma.entity.findFirstOrThrow({ where: { name: "Ny" } })).updatedById).toBe(ownerId);
});
it("historiken håller sig inom gränsen även med många krockar", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
let version = versionOf(anna.updatedAt);
for (let i = 0; i < MAX_VERSIONS + 3; i++) {
await edit(anna.id, version, { summary: `v${i}` });
version = versionOf((await prisma.entity.findUniqueOrThrow({ where: { id: anna.id } })).updatedAt);
}
expect(await prisma.entityVersion.count({ where: { entityId: anna.id } })).toBe(MAX_VERSIONS);
});
});
describe("relationer", () => {
it("kan inte skriva över en relation som ändrats av någon annan", async () => {
const a = await makeEntity(bookId, "CHARACTER", "A");
const b = await makeEntity(bookId, "CHARACTER", "B");
const relation = await makeRelation(bookId, a.id, b.id, "Vänner");
const opened = versionOf(relation.updatedAt);
const edit = (type: string, version: string) => save(() => saveRelation(form({ bookId, id: relation.id, type, version })));
login.userId = otherId;
expect((await edit("Bästa vänner", opened)).saved).toBe(true);
login.userId = ownerId;
const result = await edit("Ovänner", opened);
expect(result.saved).toBe(false);
if (result.saved) return;
expect(result.conflict.by).toBe("Kollega");
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Bästa vänner");
expect((await edit("Ovänner", result.conflict.version)).saved).toBe(true);
expect((await prisma.relation.findUniqueOrThrow({ where: { id: relation.id } })).type).toBe("Ovänner");
});
it("deltagarna behålls när en sparning avvisas", async () => {
const a = await makeEntity(bookId, "CHARACTER", "A");
const b = await makeEntity(bookId, "CHARACTER", "B");
const c = await makeEntity(bookId, "CHARACTER", "C");
const relation = await makeRelation(bookId, a.id, b.id, "Grupp", [c.id]);
const opened = versionOf(relation.updatedAt);
await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 2", version: opened, memberIds: [c.id] })));
const result = await save(() => saveRelation(form({ bookId, id: relation.id, type: "Grupp 3", version: opened })));
expect(result.saved).toBe(false);
expect(await prisma.relationMember.count({ where: { relationId: relation.id } })).toBe(1);
});
});
describe("händelser", () => {
it("kan inte skriva över en händelse som ändrats av någon annan", async () => {
const a = await makeEntity(bookId, "CHARACTER", "A");
const event = await makeEvent(bookId, "Fest", "2000", [a.id]);
const opened = versionOf(event.updatedAt);
const edit = (title: string, version: string) => save(() => saveEvent(form({ bookId, id: event.id, title, date: "2000", version, participantIds: [a.id] })));
login.userId = otherId;
expect((await edit("Stor fest", opened)).saved).toBe(true);
login.userId = ownerId;
const result = await edit("Liten fest", opened);
expect(result.saved).toBe(false);
expect((await prisma.storyEvent.findUniqueOrThrow({ where: { id: event.id } })).title).toBe("Stor fest");
expect(await prisma.eventParticipant.count({ where: { eventId: event.id } })).toBe(1);
});
});
});