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

+276
View File
@@ -0,0 +1,276 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
import { makeDocx, para, table } from "../helpers/docx";
import { describeDb, makeBook, makeEntity, 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 { previewWordImport, saveWordImport } from "@/actions/word-import";
import { MAX_DOCX_BYTES } from "@/lib/word-docx";
import { commitWordImport, previewWordFiles, type CommitItem } from "@/lib/word-import-db";
const character = (name: string, extra: string[][] = [], code = "KI-0001") =>
makeDocx([table(["Karaktärs ID:", code], ["Förnamn:", name], ["Efternamn:", "Test"], ...extra), para("Övrigt:"), para("Anteckning.")]);
const bytes = (doc: Uint8Array) => ({ name: "doc.docx", bytes: doc });
async function attempt(run: () => Promise<unknown>): Promise<string> {
try {
await run();
return "ok";
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (message === "NOT_FOUND" || message.startsWith("REDIRECT:")) return message;
throw error;
}
}
describeDb("import från Word", () => {
let ownerId: string;
let bookId: string;
beforeEach(async () => {
await resetAll();
ownerId = (await makeUser()).id;
bookId = (await makeBook(ownerId)).id;
login.userId = ownerId;
});
describe("förhandsgranskning", () => {
it("tolkar dokumentet mot bokens poster och markerar dubbletter", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna Test");
const [doc] = await previewWordFiles(bookId, [bytes(character("Anna", [["Anställd hos:", "Okänd"]]))]);
expect(doc.error).toBeNull();
expect(doc.kind).toBe("CHARACTER");
expect(doc.items[0]).toMatchObject({ name: "Anna Test", code: "KI-0001" });
expect(doc.items[0].duplicates).toEqual([{ id: anna.id, name: "Anna Test", code: anna.code }]);
expect(doc.items[0].links).toEqual([{ type: "Jobbar på", toDocument: false, entityId: null, text: "Okänd", note: "" }]);
});
it("hittar poster i boken på ID och namn, men inte i en annan bok", async () => {
const company = await makeEntity(bookId, "COMPANY", "Lunds skola");
const otherBook = await makeBook(ownerId, "Annan bok");
await makeEntity(otherBook.id, "COMPANY", "Främmande AB");
const [doc] = await previewWordFiles(bookId, [
bytes(character("Eva", [["Anställd hos:", `Lunds skola ${company.code}, Främmande AB`]])),
]);
expect(doc.items[0].links.map((l) => [l.text, l.entityId])).toEqual([
[`Lunds skola ${company.code}`, company.id],
["Främmande AB", null],
]);
});
it("använder bokens egen mall, med ändrade etiketter", async () => {
await prisma.template.create({ data: { bookId, kind: "CHARACTER", fields: [{ key: "job", label: "Arbete", type: "text" }, { key: "notes", label: "Övrigt", type: "textarea" }] } });
const [doc] = await previewWordFiles(bookId, [bytes(character("Eva", [["Arbete:", "Snickare"]]))]);
expect(doc.items[0].data).toEqual({ job: "Snickare", notes: "Anteckning." });
});
it("rapporterar filer som inte går att läsa, och läser de andra", async () => {
const docs = await previewWordFiles(bookId, [
{ name: "text.docx", bytes: new TextEncoder().encode("bara text") },
bytes(character("Eva")),
{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 1) },
]);
expect(docs.map((d) => d.error)).toEqual(["not-docx", null, "too-large"]);
expect(docs[1].items).toHaveLength(1);
});
it("låter användaren byta dokumenttyp", async () => {
const [doc] = await previewWordFiles(bookId, [bytes(makeDocx([table(["Namn:", "Rex"], ["Ras:", "Boxer"])]))], ["PET"]);
expect(doc).toMatchObject({ kind: "PET" });
expect(doc.items[0]).toMatchObject({ name: "Rex", data: { breed: "Boxer" } });
});
it("sparar ingenting", async () => {
await previewWordFiles(bookId, [bytes(character("Eva"))]);
expect(await prisma.entity.count()).toBe(0);
});
});
describe("sparande", () => {
const item = (overrides: Partial<CommitItem> = {}): CommitItem => ({
include: true,
entityKind: "CHARACTER",
name: "Eva Test",
code: "KI-0007",
data: { occupation: "Lärare" },
links: [],
unmatched: [],
...overrides,
});
const commit = (items: CommitItem[], appendUnmatched = true) => commitWordImport(bookId, ownerId, items, { appendUnmatched });
it("skapar poster med dokumentets ID när det är ledigt, annars ett nytt", async () => {
await makeEntity(bookId, "CHARACTER", "Redan"); // tar KI-0001
const result = await commit([item(), item({ name: "Två", code: "KI-0001" }), item({ name: "Tre", code: null }), item({ name: "Fyra", code: "FEL-1" })]);
expect(result).toMatchObject({ created: 4, skipped: 0 });
const codes = Object.fromEntries((await prisma.entity.findMany({ where: { bookId } })).map((e) => [e.name, e.code]));
expect(codes["Eva Test"]).toBe("KI-0007");
expect(new Set(Object.values(codes)).size).toBe(5); // alla ID är unika
expect(codes["Två"]).not.toBe("KI-0001");
});
it("nya poster fortsätter numreringen efter importerade ID", async () => {
await commit([item({ code: "KI-0020" })]);
expect((await makeEntity(bookId, "CHARACTER", "Nästa")).code).toBe("KI-0021");
});
it("hoppar över poster som användaren valt bort, och poster utan namn", async () => {
const result = await commit([item({ include: false }), item({ name: " " }), item({ name: "Behåll", code: null })]);
expect(result).toMatchObject({ created: 1, skipped: 2 });
expect((await prisma.entity.findMany({ where: { bookId } })).map((e) => e.name)).toEqual(["Behåll"]);
});
it("lägger det som inte tolkats i Övrigt, om användaren vill", async () => {
await commit([item({ data: { notes: "Först." }, unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })]);
const [saved] = await prisma.entity.findMany({ where: { bookId } });
expect((saved.data as { notes: string }).notes).toBe("Först.\n\nRelationer: Vän med Bo.");
const other = await makeBook(ownerId, "Utan tillägg");
await commitWordImport(other.id, ownerId, [item({ unmatched: [{ label: "Relationer", value: "Vän med Bo." }] })], { appendUnmatched: false });
expect((await prisma.entity.findFirstOrThrow({ where: { bookId: other.id } })).data).toEqual({ occupation: "Lärare" });
});
it("skapar relationer åt rätt håll med anteckning", async () => {
const anna = await makeEntity(bookId, "CHARACTER", "Anna");
const company = await makeEntity(bookId, "COMPANY", "Firma");
await commit([
item({ name: "Eva", links: [{ type: "Jobbar på", toDocument: false, entityId: company.id, text: "Firma", note: "" }] }),
item({
entityKind: "COMPANY",
name: "Kaffe AB",
code: null,
data: {},
links: [
{ type: "Jobbar på", toDocument: true, entityId: anna.id, text: "Anna", note: "Barista" },
{ type: "Jobbar på", toDocument: true, entityId: null, text: "Okänd", note: "" },
],
}),
]);
const relations = await prisma.relation.findMany({ include: { from: true, to: true }, orderBy: { createdAt: "asc" } });
expect(relations.map((r) => [r.from.name, r.type, r.to.name, r.description])).toEqual([
["Eva", "Jobbar på", "Firma", null],
["Anna", "Jobbar på", "Kaffe AB", "Barista"],
]);
expect(relations.every((r) => r.code && r.updatedById === ownerId)).toBe(true);
});
it("kopplingar till poster i en annan bok och till sig själv ignoreras", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(otherBook.id, "CHARACTER", "Främling");
await commit([item({ links: [{ type: "Vän till", toDocument: false, entityId: foreign.id, text: "Främling", note: "" }] })]);
expect(await prisma.relation.count()).toBe(0);
});
it("rensar värden som inte hör hemma i mallen, och kopplingsfält till fel typ eller bok", async () => {
const otherBook = await makeBook(ownerId, "Annan");
const foreign = await makeEntity(otherBook.id, "PREMISES", "Främmande lokal");
const own = await makeEntity(bookId, "CHARACTER", "Anna");
await commit([
item({
entityKind: "COMPANY",
name: "Firma",
code: null,
data: { industry: "Kaffe", premises: foreign.id, sketch: own.id, hotelRooms: "tio", okänt: "x", satisfaction: "Fantastisk", hasSketches: true },
}),
]);
expect((await prisma.entity.findFirstOrThrow({ where: { bookId, name: "Firma" } })).data).toEqual({ industry: "Kaffe", hasSketches: true });
});
it("okända dokumenttyper och trasiga poster hoppas över utan att stoppa resten", async () => {
const result = await commit([item({ entityKind: "FINNS_INTE" }), null as unknown as CommitItem, item({ name: "Ok", code: null })]);
expect(result.created).toBe(1);
});
it("en relation kräver två deltagare i boken och sätter släktband för partner", async () => {
const a = await makeEntity(bookId, "CHARACTER", "A");
const b = await makeEntity(bookId, "CHARACTER", "B");
const c = await makeEntity(bookId, "CHARACTER", "C");
const relation = (participants: string[], category: string): CommitItem =>
item({ entityKind: "RELATION", name: category, code: null, data: { category, healthy: true }, participants });
expect(await commit([relation([a.id], "Partner")])).toMatchObject({ relations: 0, skipped: 1 });
expect(await commit([relation([a.id, "finns-inte"], "Partner")])).toMatchObject({ relations: 0 });
await commit([relation([a.id, b.id, c.id], "Partner"), relation([a.id, c.id], "Vännergrupp")]);
const relations = await prisma.relation.findMany({ include: { members: true }, orderBy: { createdAt: "asc" } });
expect(relations.map((r) => [r.type, r.bond, r.members.length])).toEqual([
["Partner till", "PARTNER", 1],
["Vänner", null, 0],
]);
expect(relations[0]).toMatchObject({ fromId: a.id, toId: b.id, data: { category: "Partner", healthy: true } });
});
it("sparar allt eller inget om något går fel", async () => {
const result = commit([item({ name: "Bra", code: null }), item({ name: "x".repeat(10), code: null, data: { nickname: "y".repeat(30000) } })]);
await expect(result).resolves.toMatchObject({ created: 2 });
// För långa värden kortas i stället för att avvisas
const long = await prisma.entity.findFirstOrThrow({ where: { bookId, name: "xxxxxxxxxx" } });
expect(((long.data as { nickname: string }).nickname ?? "").length).toBeLessThanOrEqual(20000);
});
});
describe("åtgärderna", () => {
const formWith = (docs: { name: string; bytes: Uint8Array }[], kinds: string[] = []) => {
const data = new FormData();
data.set("bookId", bookId);
for (const d of docs) data.append("files", new File([d.bytes as BlobPart], d.name));
for (const k of kinds) data.append("kinds", k);
return data;
};
it("förhandsgranskar och sparar för redaktörer", async () => {
const response = await previewWordImport(formWith([bytes(character("Eva"))]));
if (!("docs" in response)) throw new Error("Väntade förhandsgranskning");
expect(response.docs[0].items[0].name).toBe("Eva Test");
const result = await saveWordImport({ bookId, appendUnmatched: true, items: [{ include: true, entityKind: "CHARACTER", name: "Eva Test", code: null, data: {}, links: [], unmatched: [] }] });
expect(result.created).toBe(1);
});
it("kräver minst en fil och högst 20", async () => {
expect(await previewWordImport(formWith([]))).toEqual({ error: "no-files" });
expect(await previewWordImport(formWith(Array.from({ length: 21 }, () => bytes(character("Eva")))))).toEqual({ error: "limit" });
});
it("stora filer läses inte alls", async () => {
const response = await previewWordImport(formWith([{ name: "stor.docx", bytes: new Uint8Array(MAX_DOCX_BYTES + 10) }]));
if (!("docs" in response)) throw new Error("Väntade svar");
expect(response.docs[0].error).toBe("too-large");
});
it("läsare och obehöriga får inte importera", async () => {
const viewer = await makeUser("Läsare");
const stranger = await makeUser("Obehörig");
await prisma.bookMember.create({ data: { bookId, userId: viewer.id, role: "VIEWER" } });
const editor = await makeUser("Redaktör");
await prisma.bookMember.create({ data: { bookId, userId: editor.id, role: "EDITOR" } });
for (const user of [viewer, stranger]) {
login.userId = user.id;
expect(await attempt(() => previewWordImport(formWith([bytes(character("Eva"))])))).toBe("NOT_FOUND");
expect(await attempt(() => saveWordImport({ bookId, appendUnmatched: false, items: [] }))).toBe("NOT_FOUND");
}
expect(await prisma.entity.count()).toBe(0);
login.userId = editor.id;
const result = await saveWordImport({ bookId, appendUnmatched: false, items: [{ include: true, entityKind: "CHARACTER", name: "Av redaktör", code: null, data: {}, links: [], unmatched: [] }] });
expect(result.created).toBe(1);
expect((await prisma.entity.findFirstOrThrow()).updatedById).toBe(editor.id);
});
});
});