diff --git a/dragonroll-foundry/README.md b/dragonroll-foundry/README.md index 5351cee6..057c164b 100644 --- a/dragonroll-foundry/README.md +++ b/dragonroll-foundry/README.md @@ -138,9 +138,10 @@ note stands as a page of one JournalEntry named **Dragonroll**. The module creat adopts one the GM already made under that name, marking it as the notes' journal — and renders each note's markdown into page HTML with Foundry's own renderer. Notes are written in Dragonroll, so this copy runs one way: a note made or edited in the campaign rewrites its page on the next reconcile, and -a note deleted there takes its page with it. Pages the campaign does not own — the GM's own pages in -that journal — are left alone, and nothing written in the journal travels back. Autosync off stops it -too, like the rest of the sync. +a note deleted there takes its page with it. A page standing under a note's title but carrying no +Dragonroll mark is claimed as that note's page, so a lost pairing does not double it. Any other page in +that journal — the GM's own — is left alone, and nothing written in the journal travels back. Autosync +off stops it too, like the rest of the sync. The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login): diff --git a/dragonroll-foundry/scripts/api.js b/dragonroll-foundry/scripts/api.js index a75553e4..c7571ca8 100644 --- a/dragonroll-foundry/scripts/api.js +++ b/dragonroll-foundry/scripts/api.js @@ -1474,8 +1474,9 @@ async function initializeSceneSync() { // stands as a page of one JournalEntry named "Dragonroll". Notes are written in // Dragonroll, so this copy runs one way — the reconcile writes each note into its // page and drops the page of a note the campaign deleted. Nothing of the journal -// is read back, and the GM's own pages in that journal are left alone: only the -// ones this module made carry the `dragonroll-foundry.noteId` flag. +// is read back. A page the module made carries the `dragonroll-foundry.noteId` +// flag; one without it that stands under a note's title is claimed as that note's +// page rather than doubled, and any other page is the GM's own and left alone. const NOTES_JOURNAL_NAME = "Dragonroll"; let noteSyncRunning = false; @@ -1599,10 +1600,30 @@ async function reconcileDragonrollNotes() { await applyDragonrollNotePage(page, entry); if (!entry.foundryPageId) await mapDragonrollNote(entry._id, page.id); } else { - const created = await createDragonrollNotePage(journal, entry); - if (created) { - retainedPageIds.add(created.id); - await mapDragonrollNote(entry._id, created.id); + // A page under the note's title that carries no Dragonroll mark — one the + // module made before the campaign kept its mapping, or one whose flag was + // lost — is claimed as that note's page instead of adding a second page of + // the same name. Like the item sync's same-name adoption, this is what keeps + // a note from being written as a new page on every reconcile. + const sameName = (journal.pages?.contents || []).find((candidate) => ( + String(candidate.name ?? "") === notePageTitle(entry) + && !dragonrollNoteId(candidate) + && !retainedPageIds.has(candidate.id) + )); + if (sameName) { + retainedPageIds.add(sameName.id); + await applyDragonrollNotePage(sameName, entry); + await mapDragonrollNote(entry._id, sameName.id); + } else { + const created = await createDragonrollNotePage(journal, entry); + if (created) { + retainedPageIds.add(created.id); + // The create carries the note's flag, but a world that drops it would leave + // the page unclaimed and the next reconcile would make another: mark it + // again the way the rest of the sync marks its documents. + await applyDragonrollNotePage(created, entry); + await mapDragonrollNote(entry._id, created.id); + } } } } diff --git a/frontend/app/content/docs/03-integrations/03-foundry.md b/frontend/app/content/docs/03-integrations/03-foundry.md index 1e17fcb2..48c23753 100644 --- a/frontend/app/content/docs/03-integrations/03-foundry.md +++ b/frontend/app/content/docs/03-integrations/03-foundry.md @@ -80,9 +80,10 @@ notice what is gone. Live edits never delete anything. Notes are the exception that runs one way, because notes are written in Dragonroll: every note stands as a page of a single journal called **Dragonroll**. A note you make or edit in the app appears on that -journal within a few seconds, and deleting one takes its page with it. Pages the campaign does not own -— one the GM made in that journal themselves — are left alone, and nothing written in the journal -travels back to the campaign. +journal within a few seconds, and deleting one takes its page with it. A page that stands under a note's +title but carries no Dragonroll mark is claimed as that note's page, so a pairing that was lost does not +double it. Any other page — one the GM made in that journal themselves — is left alone, and nothing +written in the journal travels back to the campaign. ## Auto-sync, and sending one actor on purpose diff --git a/tests/foundry-note-journal.test.js b/tests/foundry-note-journal.test.js index 771784bc..e09c28fc 100644 --- a/tests/foundry-note-journal.test.js +++ b/tests/foundry-note-journal.test.js @@ -238,13 +238,15 @@ function writeFoundryPaths(target, data) { return target; } -function makeWorld({ markdown = true } = {}) { +function makeWorld({ markdown = true, keepCreateFlags = true, failMapNote = false } = {}) { const state = { hooks: new Map(), registered: new Map(), requests: [], timers: new Map(), intervals: new Map(), + keepCreateFlags, + failMapNote, // What Dragonroll answers the notes reconcile with. Mapping a page answers // like the real backend: the note keeps the page id, so later reads carry it. remoteNotes: [], @@ -289,7 +291,9 @@ function makeWorld({ markdown = true } = {}) { assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages"); // Foundry's own page validation refuses a page without a name. for (const doc of docs) assert.ok(doc.name, "a journal page needs a non-empty name"); - const created = docs.map((doc) => makePage(this, doc)); + // A world that does not keep the flags a create was handed: the page + // exists but carries no mark, which is what a lost pairing looks like. + const created = docs.map((doc) => makePage(this, keepCreateFlags ? doc : { ...doc, flags: {} })); pages.push(...created); return created; }, @@ -326,6 +330,7 @@ function makeWorld({ markdown = true } = {}) { const body = options.body ? JSON.parse(options.body) : null; state.requests.push({ href, method: options.method, body }); if (href.includes("foundry/sync/map-note")) { + if (state.failMapNote) return { ok: false, status: 500, json: async () => ({ status: "error", msg: "errors.internal" }) }; const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId)); if (note) note.foundryPageId = body.foundryPageId; return { ok: true, status: 200, json: async () => ({ status: "ok", note }) }; @@ -524,6 +529,57 @@ test("the campaign's page mapping claims a page whose flag was lost", async () = assert.equal(orphan.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked again"); }); +test("a page under the note's title with no mark is claimed, not doubled", async () => { + const world = await makeWorld().linkedSetup(); + const journal = world.addJournal("Dragonroll"); + const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } }); + + // The campaign has no page id for the note, and the page carries no flag: this + // is a page the module made before the pairing was kept, or one whose flag was + // lost. It is claimed instead of a second page being made under the same title. + world.remoteNotes = [sessionNote()]; + await world.runIntervals(); + + assert.equal(journal.pages.contents.length, 1, "no second page under the note's title"); + assert.equal(existing.text.content, "**The start**", "the note's text lands on the page the world already had"); + assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked as the note's"); + assert.deepEqual(world.mapNoteRequests().map((request) => request.body.foundryPageId), [existing.id], + "the campaign is told which page the note now stands as"); + + await world.runIntervals(); + assert.equal(journal.pages.contents.length, 1, "reconciling again does not add another"); +}); + +test("two notes of one title do not share a single page", async () => { + const world = await makeWorld().linkedSetup(); + const journal = world.addJournal("Dragonroll"); + const existing = world.addPage(journal, { name: "Session 1", text: { content: "an older copy" } }); + + world.remoteNotes = [sessionNote(), { _id: "note-9", title: "Session 1", content: "second" }]; + await world.runIntervals(); + + assert.equal(journal.pages.contents.length, 2, "the second note gets a page of its own"); + assert.equal(existing.getFlag(MODULE_ID, "noteId"), "note-1", "the world's page is claimed by the first note"); + assert.equal(journal.pages.contents[1].getFlag(MODULE_ID, "noteId"), "note-9"); +}); + +test("a page whose mark and mapping were both lost is claimed again, not doubled", async () => { + // Both ways of recognising the pairing are gone: the create's flag did not stick, + // and the campaign never got to keep the page id. Without claiming the page it + // already made, every reconcile would write another one. + const world = await makeWorld({ keepCreateFlags: false, failMapNote: true }).linkedSetup(); + world.remoteNotes = [sessionNote()]; + + await world.runIntervals(); + await world.runIntervals(); + await world.runIntervals(); + + const journal = world.journals()[0]; + assert.equal(journal.pages.contents.length, 1, "one note stands as the one page it was given"); + assert.equal(journal.pages.contents[0].getFlag(MODULE_ID, "noteId"), "note-1", + "and the page keeps the note it stands for even though the create did not mark it"); +}); + test("without Foundry's markdown renderer the fallback keeps the text legible", async () => { const world = await makeWorld({ markdown: false }).linkedSetup(); world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }];