225 lines
15 KiB
TypeScript
225 lines
15 KiB
TypeScript
import { afterEach, beforeEach, expect, test } from "bun:test";
|
|
import { mkdtemp, rm } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import { join } from "node:path";
|
|
import { strFromU8, unzipSync, zipSync, strToU8 } from "fflate";
|
|
import { forEachDialect } from "@sttracker/db/testing";
|
|
import { storeAttachment } from "../src/attachments.ts";
|
|
import { ImportError } from "../src/errors.ts";
|
|
import { moveEntryToWork, quickAdd, upsertEntry } from "../src/entries.ts";
|
|
import { exportUserBundle, exportUserCsv, importUserBundle } from "../src/export.ts";
|
|
import { makeUser, makeWork } from "./user-layer-fixtures.ts";
|
|
|
|
forEachDialect("export bundle", (getDb) => {
|
|
let dir: string;
|
|
let dir2: string;
|
|
beforeEach(async () => {
|
|
dir = await mkdtemp(join(tmpdir(), "sttracker-exp-"));
|
|
dir2 = await mkdtemp(join(tmpdir(), "sttracker-exp-"));
|
|
});
|
|
afterEach(async () => {
|
|
await rm(dir, { recursive: true, force: true });
|
|
await rm(dir2, { recursive: true, force: true });
|
|
});
|
|
|
|
async function seed(db: ReturnType<typeof getDb>, u: string) {
|
|
const shared = await makeWork(db, { title: "Dune", mediaType: "book", year: 1965, externalIds: { hardcover: "dune" } });
|
|
const parent = await makeWork(db, { title: "Show", mediaType: "tv", externalIds: { trakt: "show" } });
|
|
const child = await makeWork(db, { title: "Pilot", mediaType: "tv", parentId: parent, externalIds: { trakt: "pilot" } });
|
|
const priv = await makeWork(db, { title: "My Zine", mediaType: "book", ownerUserId: u });
|
|
const now = "2024-01-02T03:04:05.000Z";
|
|
const ent = async (id: string, workId: string, extra: object = {}) =>
|
|
db.k.insertInto("entries").values({
|
|
id, user_id: u, work_id: workId, status: "completed", rating: 85, review: "great", private_notes: null, favorite: 1,
|
|
tags: '["a","b"]', custom_fields: "{}", visibility: "private", overrides: "{}", media_type_override: null,
|
|
field_sources: '{"rating":"user"}', created_at: now, updated_at: now, deleted_at: null, ...extra,
|
|
}).execute();
|
|
const defId = crypto.randomUUID();
|
|
await db.k.insertInto("custom_field_definitions").values({ id: defId, user_id: u, name: "Shelf", type: "text", options: "[]", applies_to: '"all"', level: "entry", created_at: now }).execute();
|
|
const e1 = crypto.randomUUID(), e2 = crypto.randomUUID(), e3 = crypto.randomUUID(), e4 = crypto.randomUUID();
|
|
await ent(e1, shared, { overrides: '{"title":"Dune X"}', visibility: "public", custom_fields: JSON.stringify({ [defId]: "top shelf" }) });
|
|
await ent(e2, child);
|
|
await ent(e3, priv, { rating: null });
|
|
await ent(e4, parent, { deleted_at: now });
|
|
const eng = crypto.randomUUID();
|
|
await db.k.insertInto("engagements").values({
|
|
id: eng, entry_id: e1, started_at: "1999-05", started_precision: "month", finished_at: "2000", finished_precision: "year",
|
|
progress: "{}", platform: "kindle", rating: 70, notes: "n", custom_fields: "{}", field_sources: "{}", created_at: now, updated_at: now, deleted_at: null,
|
|
}).execute();
|
|
await db.k.insertInto("copies").values({ id: crypto.randomUUID(), user_id: u, work_id: shared, title_hint: null, format: "hardcover", acquired_from: "shop", acquired_at: "2020-03", acquired_precision: "month", price_cents: 1299, currency: "EUR", notes: null, custom_fields: "{}", source_ref: null, created_at: now, updated_at: now, deleted_at: null }).execute();
|
|
await db.k.insertInto("listens").values({ id: crypto.randomUUID(), user_id: u, listened_at: now, artist: "Artist", track: "Track", album: null, duration_ms: 1000, mbids: "{}", work_id: null, source: "lastfm", source_key: "k1", created_at: now }).execute();
|
|
const grp = crypto.randomUUID();
|
|
await db.k.insertInto("lists").values({ id: grp, user_id: u, name: "Grouped", description: "", kind: "grouping", visibility: "public", rating: 90, review: "nice set", created_at: now, updated_at: now, deleted_at: null }).execute();
|
|
const list = crypto.randomUUID();
|
|
await db.k.insertInto("lists").values({ id: list, user_id: u, name: "Faves", description: "d", kind: "list", visibility: "private", rating: null, review: null, created_at: now, updated_at: now, deleted_at: null }).execute();
|
|
await db.k.insertInto("list_items").values({ id: crypto.randomUUID(), list_id: list, work_id: shared, position: 0, note: "first" }).execute();
|
|
await db.k.insertInto("user_history").values({ id: crypto.randomUUID(), user_id: u, entity: "entry", entity_id: e1, before: "{}", after: '{"rating":85}', actor: "user", created_at: now }).execute();
|
|
await db.k.insertInto("user_history").values({ id: crypto.randomUUID(), user_id: u, entity: "entry", entity_id: e1, before: "{}", after: JSON.stringify({ workId: shared, note: "moved" }), actor: "user", created_at: now }).execute();
|
|
const att = await storeAttachment(db, dir, u, { bytes: new TextEncoder().encode("hello"), mime: "text/plain", filename: "n.txt", caption: "a caption" }, { entity: "entry", entityId: e1 });
|
|
await db.k.insertInto("attachment_links").values({ id: crypto.randomUUID(), attachment_id: att.id, entity: "engagement", entity_id: eng }).execute();
|
|
return { e1, shared, defId };
|
|
}
|
|
|
|
test("export then import into fresh user reproduces entries, ratings, engagements with precision, lists and attachments", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
const { defId } = await seed(db, u);
|
|
// A second user's data must never leak into ada's bundle.
|
|
const other = await makeUser(db, "eve");
|
|
const otherWork = await makeWork(db, { title: "Other Zine", mediaType: "book", ownerUserId: other });
|
|
const oe = crypto.randomUUID();
|
|
await db.k.insertInto("entries").values({ id: oe, user_id: other, work_id: otherWork, status: "planned", rating: null, review: null, private_notes: "secret", favorite: 0, tags: "[]", custom_fields: "{}", visibility: "private", overrides: "{}", media_type_override: null, field_sources: "{}", created_at: "2024-01-01T00:00:00.000Z", updated_at: "2024-01-01T00:00:00.000Z", deleted_at: null }).execute();
|
|
await storeAttachment(db, dir, other, { bytes: new TextEncoder().encode("hello"), mime: "text/plain", filename: "eve.txt" }, { entity: "entry", entityId: oe });
|
|
const zip = await exportUserBundle(db, dir, u);
|
|
const files = unzipSync(zip);
|
|
const allText = Object.entries(files).filter(([n]) => n.endsWith(".jsonl")).map(([, b]) => strFromU8(b)).join("\n");
|
|
expect(allText).not.toContain("Other Zine");
|
|
expect(allText).not.toContain("secret");
|
|
expect(strFromU8(files["attachments.jsonl"]!).trim().split("\n")).toHaveLength(1);
|
|
|
|
const v = await makeUser(db, "bob");
|
|
expect(await importUserBundle(db, dir2, v, zip)).toEqual({ works: 4, entries: 4 });
|
|
expect(await db.k.selectFrom("entries").select("id").where("user_id", "=", other).execute()).toHaveLength(1);
|
|
|
|
const rows = await db.k.selectFrom("entries").innerJoin("works", "works.id", "entries.work_id").select(["works.title", "entries.rating", "entries.favorite", "entries.field_sources", "entries.deleted_at", "entries.created_at", "works.owner_user_id", "works.parent_id", "works.id as wid"]).where("entries.user_id", "=", v).execute();
|
|
const byTitle = Object.fromEntries(rows.map((r) => [r.title, r]));
|
|
expect(rows).toHaveLength(4);
|
|
expect(byTitle["Dune"]!.rating).toBe(85);
|
|
expect(byTitle["Dune"]!.favorite).toBe(1);
|
|
expect(byTitle["Dune"]!.field_sources).toBe('{"rating":"user"}');
|
|
expect(byTitle["Dune"]!.created_at).toBe("2024-01-02T03:04:05.000Z");
|
|
expect(byTitle["Show"]!.deleted_at).not.toBeNull();
|
|
expect(byTitle["My Zine"]!.owner_user_id).toBe(v);
|
|
expect(byTitle["Pilot"]!.parent_id).toBe(byTitle["Show"]!.wid);
|
|
// shared works were re-matched, not duplicated
|
|
expect(await db.k.selectFrom("works").select("id").where("title", "=", "Dune").execute()).toHaveLength(1);
|
|
|
|
const eng = await db.k.selectFrom("engagements").innerJoin("entries", "entries.id", "engagements.entry_id").selectAll("engagements").where("entries.user_id", "=", v).execute();
|
|
expect(eng).toHaveLength(1);
|
|
expect(eng[0]).toMatchObject({ started_at: "1999-05", started_precision: "month", finished_precision: "year", platform: "kindle" });
|
|
|
|
const lists = await db.k.selectFrom("lists").selectAll().where("user_id", "=", v).execute();
|
|
expect(lists).toHaveLength(2);
|
|
const items = await db.k.selectFrom("list_items").selectAll().where("list_id", "=", lists.find((l) => l.name === "Faves")!.id).execute();
|
|
expect(items).toMatchObject([{ note: "first", work_id: byTitle["Dune"]!.wid }]);
|
|
|
|
const hist = await db.k.selectFrom("user_history").selectAll().where("user_id", "=", v).execute();
|
|
expect(hist).toHaveLength(2);
|
|
const dune = await db.k.selectFrom("entries").select("id").where("user_id", "=", v).where("work_id", "=", byTitle["Dune"]!.wid).executeTakeFirstOrThrow();
|
|
expect(hist.every((h) => h.entity_id === dune.id)).toBe(true);
|
|
|
|
const atts = await db.k.selectFrom("attachments").innerJoin("attachment_links", "attachment_links.attachment_id", "attachments.id").selectAll("attachments").select("attachment_links.entity_id").where("attachments.user_id", "=", v).execute();
|
|
expect(atts).toHaveLength(2);
|
|
expect(atts.every((a) => a.caption === "a caption")).toBe(true);
|
|
const engRow = eng[0]!;
|
|
expect(atts.map((a) => a.entity_id).sort()).toEqual([dune.id, engRow.id].sort());
|
|
|
|
const full = await db.k.selectFrom("entries").selectAll().where("id", "=", dune.id).executeTakeFirstOrThrow();
|
|
expect(full).toMatchObject({ visibility: "public", overrides: '{"title":"Dune X"}' });
|
|
const newDef = await db.k.selectFrom("custom_field_definitions").selectAll().where("user_id", "=", v).executeTakeFirstOrThrow();
|
|
expect(newDef.id).not.toBe(defId);
|
|
expect(JSON.parse(full.custom_fields)).toEqual({ [newDef.id]: "top shelf" });
|
|
|
|
const copy = await db.k.selectFrom("copies").selectAll().where("user_id", "=", v).executeTakeFirstOrThrow();
|
|
expect(copy).toMatchObject({ price_cents: 1299, currency: "EUR", acquired_precision: "month", work_id: byTitle["Dune"]!.wid });
|
|
expect(await db.k.selectFrom("listens").select("id").where("user_id", "=", v).execute()).toHaveLength(1);
|
|
const grouping = await db.k.selectFrom("lists").selectAll().where("user_id", "=", v).where("kind", "=", "grouping").executeTakeFirstOrThrow();
|
|
expect(grouping).toMatchObject({ rating: 90, review: "nice set", visibility: "public" });
|
|
const remapped = (await db.k.selectFrom("user_history").selectAll().where("user_id", "=", v).execute()).find((h) => h.after.includes("moved"))!;
|
|
expect(JSON.parse(remapped.after).workId).toBe(byTitle["Dune"]!.wid);
|
|
expect(await Bun.file(join(dir2, "attachments", atts[0]!.sha256.slice(0, 2), atts[0]!.sha256.slice(2, 4), atts[0]!.sha256)).text()).toBe("hello");
|
|
});
|
|
|
|
test("bundle has no credential fields", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
await seed(db, u);
|
|
const files = unzipSync(await exportUserBundle(db, dir, u));
|
|
expect(Object.keys(files)).toContain("manifest.json");
|
|
const keys = new Set<string>();
|
|
const walk = (v: unknown) => {
|
|
if (Array.isArray(v)) v.forEach(walk);
|
|
else if (v && typeof v === "object") for (const [k, x] of Object.entries(v)) (keys.add(k.toLowerCase().replaceAll("_", "")), walk(x));
|
|
};
|
|
for (const [n, b] of Object.entries(files)) {
|
|
if (n.endsWith(".jsonl")) strFromU8(b).split("\n").filter(Boolean).forEach((l) => walk(JSON.parse(l)));
|
|
}
|
|
expect(keys.size).toBeGreaterThan(10);
|
|
for (const bad of ["passwordhash", "tokenhash", "credentialsenc", "codehash"]) expect(keys.has(bad)).toBe(false);
|
|
expect(JSON.parse(strFromU8(files["manifest.json"]!)).format).toBe("sttracker-export/v1");
|
|
});
|
|
|
|
test("import into non-empty account refused", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
await seed(db, u);
|
|
const zip = await exportUserBundle(db, dir, u);
|
|
const err = await importUserBundle(db, dir2, u, zip).catch((e) => e);
|
|
expect(err).toBeInstanceOf(ImportError);
|
|
expect(err.code).toBe("account_not_empty");
|
|
});
|
|
|
|
test("import of an unknown format is refused", async () => {
|
|
const db = getDb();
|
|
const v = await makeUser(db, "bob");
|
|
const zip = zipSync({ "manifest.json": strToU8('{"format":"other"}') });
|
|
const err = await importUserBundle(db, dir2, v, zip).catch((e) => e);
|
|
expect(err.code).toBe("unsupported_format");
|
|
});
|
|
|
|
test("csv export has entries, engagements and listens", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
await seed(db, u);
|
|
const csv = await exportUserCsv(db, u);
|
|
expect(Object.keys(csv).sort()).toEqual(["engagements.csv", "entries.csv", "listens.csv"]);
|
|
expect(csv["entries.csv"]).toContain("Dune");
|
|
expect(csv["entries.csv"]).not.toContain("Show,");
|
|
expect(csv["engagements.csv"]).toContain("kindle");
|
|
});
|
|
|
|
test("a per-user move restores as alias plus tombstone and later upserts resolve to the moved entry", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
const draft = await quickAdd(db, u, { title: "Dune??", mediaType: "book" });
|
|
const shared = await makeWork(db, { title: "Dune", mediaType: "book", externalIds: { isbn13: "9780441013593" } });
|
|
await moveEntryToWork(db, u, draft.id, shared, "user");
|
|
const zip = await exportUserBundle(db, dir, u);
|
|
|
|
const v = await makeUser(db, "bob");
|
|
await importUserBundle(db, dir2, v, zip);
|
|
const alias = await db.k.selectFrom("work_aliases").selectAll().where("user_id", "=", v).executeTakeFirstOrThrow();
|
|
expect(alias.to_work_id).toBe(shared);
|
|
const tomb = await db.k.selectFrom("works").selectAll().where("id", "=", alias.from_work_id).executeTakeFirstOrThrow();
|
|
expect(tomb).toMatchObject({ merged_into_id: shared, owner_user_id: v });
|
|
const moved = await upsertEntry(db, v, tomb.id, { rating: 10 }, "user");
|
|
expect(moved.workId).toBe(shared);
|
|
expect(await db.k.selectFrom("entries").select("id").where("user_id", "=", v).execute()).toHaveLength(1);
|
|
});
|
|
|
|
test("an invalid attachment aborts the import with nothing written", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
await seed(db, u);
|
|
const files = unzipSync(await exportUserBundle(db, dir, u));
|
|
const key = Object.keys(files).find((n) => n.startsWith("attachments/"))!;
|
|
files[key] = new TextEncoder().encode("tampered");
|
|
const v = await makeUser(db, "bob");
|
|
const err = await importUserBundle(db, dir2, v, zipSync(files)).catch((e) => e);
|
|
expect(err.code).toBe("invalid_attachment");
|
|
expect(await db.k.selectFrom("entries").select("id").where("user_id", "=", v).execute()).toHaveLength(0);
|
|
expect(await db.k.selectFrom("attachments").select("id").where("user_id", "=", v).execute()).toHaveLength(0);
|
|
});
|
|
|
|
test("an out-of-range rating is a corrupt bundle", async () => {
|
|
const db = getDb();
|
|
const u = await makeUser(db, "ada");
|
|
await seed(db, u);
|
|
const files = unzipSync(await exportUserBundle(db, dir, u));
|
|
files["entries.jsonl"] = strToU8(strFromU8(files["entries.jsonl"]!).replaceAll('"rating":85', '"rating":185'));
|
|
const v = await makeUser(db, "bob");
|
|
const err = await importUserBundle(db, dir2, v, zipSync(files)).catch((e) => e);
|
|
expect(err.code).toBe("corrupt_bundle");
|
|
});
|
|
});
|