10 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
eead3c9be8 Fix issue #111: Entry sync on foundry keeps creating new journal entries
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 16:57:28 +00:00
b5d5e570d5 Merge pull request 'Fix #109: Add map sync' (#110) from ai/issue-109 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m7s
Reviewed-on: #110
2026-10-16 16:15:44 +00:00
Gitea OpenCode Agent
cd1e3cb125 Fix issue #109: Add map sync
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 16:06:21 +00:00
013c3512fe jkdsjkdsj
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 50s
2026-10-16 17:53:15 +02:00
3f2ac16394 Merge pull request 'Fix #98: Sync notes from dragonroll to foundry' (#103) from ai/issue-98 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m6s
Reviewed-on: #103
2026-10-16 14:31:46 +00:00
55fbacbdd7 Merge branch 'master' into ai/issue-98
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 14:31:39 +00:00
5efe43fd99 Merge pull request 'Fix #96: When right clicking actor on foundry, show action to force sync to dragonroll' (#102) from ai/issue-96 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m8s
Reviewed-on: #102
2026-10-16 14:27:22 +00:00
00ac1b16cd Merge branch 'master' into ai/issue-96
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 14:27:14 +00:00
Gitea OpenCode Agent
07dcf08616 Fix issue #98: Sync notes from dragonroll to foundry
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 23:19:43 +00:00
Gitea OpenCode Agent
967c704801 Fix issue #96: When right clicking actor on foundry, show action to force sync to dragonroll
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:53:03 +00:00
15 changed files with 994 additions and 18 deletions

View File

@@ -83,7 +83,7 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings` - `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings`
- `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId` - `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color` - `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`, `foundryPageId`
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color` - `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color`
- `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs) - `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs)
- `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description` - `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
@@ -116,12 +116,14 @@ rest, expire after 10 min, and Obsidian gets a long-lived (365 d) token back.
Foundry then syncs with that token on `/api/foundry/sync/*` (`routes/foundry-link.js`, mounted before Foundry then syncs with that token on `/api/foundry/sync/*` (`routes/foundry-link.js`, mounted before
the JWT guard; CORS opened for it): `snapshot` (actors + world items, `fullSync` also prunes), the JWT guard; CORS opened for it): `snapshot` (actors + world items, `fullSync` also prunes),
`item-snapshot`, `item-delete`, `scenes` (the world's scenes as the campaign's maps, `fullSync` also `item-snapshot`, `item-delete`, `scenes` (the world's scenes as the campaign's maps, `fullSync` also
prunes), `scene-delete`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules: prunes), `scene-delete`, `characters`, `items`, `notes` / `map-note`, `status`,
`map` / `map-item`, `delete`. Rules:
- **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row. - **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row.
- **Only the world's item directory reaches the item list** (Syndria98/dragonroll#67) — `snapshotItemSources` reads `body.items` (`game.items`) alone; gear embedded in a character is that actor's `inventory` (see the `Actor` model), not an `Item`. A world item still folds into a hand-made or renamed row it matches by name (`foundryNames`), so a rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped. - **Only the world's item directory reaches the item list** (Syndria98/dragonroll#67) — `snapshotItemSources` reads `body.items` (`game.items`) alone; gear embedded in a character is that actor's `inventory` (see the `Actor` model), not an `Item`. A world item still folds into a hand-made or renamed row it matches by name (`foundryNames`), so a rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped.
- **Item folders mirror the world's item directory** (`Folder.foundryFolderId`, target `item`): every push carries the whole tree and the world owns its names and nesting. `color` is the one field the campaign sets too, so it travels back with the folders `GET /foundry/sync/items` answers with (`{items, folders}`) and the module writes it onto the world's folder. - **Item folders mirror the world's item directory** (`Folder.foundryFolderId`, target `item`): every push carries the whole tree and the world owns its names and nesting. `color` is the one field the campaign sets too, so it travels back with the folders `GET /foundry/sync/items` answers with (`{items, folders}`) and the module writes it onto the world's folder.
- **A world's scenes arrive as its campaign's maps** (Syndria98/dragonroll#99): `POST /foundry/sync/scenes` writes one `Map` per scene through `saveFoundryScene`, and only the scene's background picture and grid cross over (`services/map-foundry.js`: `gridSize` from `grid`/`grid.size`, the offsets from `flags.core.shiftX`/`.shiftY`) — `scale`, the folder, the pins and the tokens stay with the campaign and nothing of a map goes back to the world. Identity is `Map.foundrySceneId` (unique per campaign), a `dragonroll-foundry.mapId` flag or a hand-made unmapped map of the same name; a scene with no picture makes no map. `POST /foundry/sync/scene-delete` drops the map of a deleted scene, and only the full list the module sends when the world links or loads prunes. - **A world's scenes arrive as its campaign's maps** (Syndria98/dragonroll#99): `POST /foundry/sync/scenes` writes one `Map` per scene through `saveFoundryScene`, and only the scene's background picture and grid cross over (`services/map-foundry.js`: `gridSize` from `grid`/`grid.size`, the offsets from `flags.core.shiftX`/`.shiftY`) — `scale`, the folder, the pins and the tokens stay with the campaign and nothing of a map goes back to the world. Identity is `Map.foundrySceneId` (unique per campaign), a `dragonroll-foundry.mapId` flag or a hand-made unmapped map of the same name; a scene with no picture makes no map. `POST /foundry/sync/scene-delete` drops the map of a deleted scene, and only the full list the module sends when the world links or loads prunes.
- **Notes reach the world as journal pages, one way** (Syndria98/dragonroll#98): the module reads `GET /sync/notes` and stands every campaign note as a page of one world `JournalEntry` named Dragonroll — the page carries the note's id in a `dragonroll-foundry.noteId` flag, the note keeps the page's id in `foundryPageId` (`POST /sync/map-note`). The reconcile rewrites pages from the notes and drops the page of a deleted note; journal edits never travel back.
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune. - **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune.
- **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`). - **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`).
- `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. Its one write, `POST /import`, pulls the bridge's actors or world items into the campaign through the same writers as a sync push. - `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. Its one write, `POST /import`, pulls the bridge's actors or world items into the campaign through the same writers as a sync push.

View File

@@ -14,7 +14,16 @@ const NoteSchema = new Schema({
ref: 'Folder' ref: 'Folder'
}, },
color: { type: String }, color: { type: String },
// The journal page this note is written as in the linked Foundry world: the
// page of the one "Dragonroll" journal whose rows carry this note's id in
// their `dragonroll-foundry.noteId` flag (see the module's notes sync).
foundryPageId: { type: String },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });
NoteSchema.index(
{ campaign: 1, foundryPageId: 1 },
{ unique: true, partialFilterExpression: { foundryPageId: { $type: 'string' } } }
);
module.exports = mongoose.model('Note', NoteSchema); module.exports = mongoose.model('Note', NoteSchema);

View File

@@ -9,6 +9,7 @@ const Item = require('../models/Item');
// Not `Map`: this route builds plain `Map`s of its own to mirror the world's folder tree. // Not `Map`: this route builds plain `Map`s of its own to mirror the world's folder tree.
const MapModel = require('../models/Map'); const MapModel = require('../models/Map');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
const Note = require('../models/Note');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-foundry');
const { foundrySceneToMapData } = require('../services/map-foundry'); const { foundrySceneToMapData } = require('../services/map-foundry');
@@ -67,9 +68,9 @@ function resolveWorldAssets(fields, campaign) {
} }
} }
async function saveFoundryActor(campaign, source, fullSync = false) { async function saveFoundryActor(campaign, source, fullSync = false, replace = false) {
const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120); const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryActorToCharacter(source || {}); const fields = foundryActorToCharacter(source || {}, replace);
if (!foundryActorId || !fields.name) return null; if (!foundryActorId || !fields.name) return null;
resolveWorldAssets(fields, campaign); resolveWorldAssets(fields, campaign);
@@ -348,12 +349,16 @@ router.post('/sync/snapshot', async (req, res) => {
} }
const fullSync = req.body.fullSync === true; const fullSync = req.body.fullSync === true;
// A forced actor sync from the module's context menu replaces the campaign's
// row for the actors it sends entirely (Syndria98/dragonroll#96). It stays
// clear of fullSync: it never prunes, unlike a reconnect's full snapshot.
const replace = req.body.replace === true;
// A module that knows nothing about item folders sends neither the tree // A module that knows nothing about item folders sends neither the tree
// nor the folder of an item, and then nothing here touches the folders. // nor the folder of an item, and then nothing here touches the folders.
const folderSources = Array.isArray(req.body.folders) ? req.body.folders : null; const folderSources = Array.isArray(req.body.folders) ? req.body.folders : null;
const actors = []; const actors = [];
for (const source of actorSources || []) { for (const source of actorSources || []) {
const mapping = await saveFoundryActor(campaign, source, fullSync); const mapping = await saveFoundryActor(campaign, source, fullSync, replace);
if (mapping) actors.push(mapping); if (mapping) actors.push(mapping);
} }
const itemFolders = folderSources ? await syncFoundryItemFolders(campaign, folderSources) : null; const itemFolders = folderSources ? await syncFoundryItemFolders(campaign, folderSources) : null;
@@ -574,6 +579,57 @@ router.post('/sync/map-item', async (req, res) => {
} }
}); });
// --- Note pages ------------------------------------------------------------
// The campaign's notes are read where their authors' table sits: every note
// stands as a page of the one journal the world calls "Dragonroll". Notes are
// written in Dragonroll, so this copy runs one way — the module reads the notes
// and rewrites their pages; nothing of the journal travels back. Its pages keep
// the note's id in a `dragonroll-foundry.noteId` flag, and the note keeps the
// page's id here, so either side recognises the pairing again after a restart.
// Every note of the campaign, content included: enough for the module to write
// each one as a page. Folders of the notes do not travel — the journal is flat.
router.get('/sync/notes', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const notes = await Note.find({ campaign: campaign._id })
.select('_id title content foundryPageId date')
.sort({ date: -1 })
.lean();
res.json({ status: 'ok', notes });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The page the module made for a note, kept on the note so the next reconcile —
// or a world whose page flags were lost — writes that page instead of a second
// one under the same title.
router.post('/sync/map-note', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { noteId, foundryPageId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !noteId || !foundryPageId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const note = await Note.findOne({ _id: noteId, campaign: campaign._id });
if (!note) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await Note.findOne({ campaign: campaign._id, foundryPageId, _id: { $ne: note._id } });
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.note-already-synced' });
note.foundryPageId = String(foundryPageId).trim().slice(0, 120);
await note.save();
res.json({ status: 'ok', note });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;
// The writers every Foundry document goes through: the sync pushes above, and the // The writers every Foundry document goes through: the sync pushes above, and the
// force import a campaign asks for from its sidebar (routes/foundry.js). One set of // force import a campaign asks for from its sidebar (routes/foundry.js). One set of

View File

@@ -130,7 +130,11 @@ function foundryTraits(source, items) {
return features.length ? features.join('\n\n') : undefined; return features.length ? features.join('\n\n') : undefined;
} }
function foundryActorToCharacter(foundryActor) { // `replace` is a forced actor sync from the module's context menu (Syndria98/dragonroll#96):
// it replaces everything the campaign holds for this actor, so the fields a live edit
// leaves out when the world says nothing are written empty instead of kept. A live Foundry
// change passes `false` and keeps the campaign's own toggles and text.
function foundryActorToCharacter(foundryActor, replace = false) {
const system = foundryActor.system || {}; const system = foundryActor.system || {};
const details = system.details || {}; const details = system.details || {};
const abilities = system.abilities || {}; const abilities = system.abilities || {};
@@ -169,7 +173,9 @@ function foundryActorToCharacter(foundryActor) {
])), ])),
armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10), armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10),
speed: numberOr(movement.walk ?? movement.value, 30), speed: numberOr(movement.walk ?? movement.value, 30),
proficiencies: foundryProficiencies || asText(savedDragonrollFields.proficiencies), // A replace takes the world's text even when it has none, so what Dragonroll
// cached on the actor's flag does not survive it; a live edit keeps that text.
proficiencies: foundryProficiencies || (replace ? '' : asText(savedDragonrollFields.proficiencies)),
// What the character carries: gear, and gear only (Syndria98/dragonroll#89). A feat // What the character carries: gear, and gear only (Syndria98/dragonroll#89). A feat
// is a trait — its tab shows it — and a race is the species; standing them in the // is a trait — its tab shows it — and a race is the species; standing them in the
// inventory next to the longswords is how traits and items got mixed up. // inventory next to the longswords is how traits and items got mixed up.
@@ -201,9 +207,21 @@ function foundryActorToCharacter(foundryActor) {
const currency = foundryCurrency(system); const currency = foundryCurrency(system);
if (currency) fields.currency = currency; if (currency) fields.currency = currency;
const worldTraits = foundryTraits(foundryActor, items); const worldTraits = foundryTraits(foundryActor, items);
const campaignTraits = asText(savedDragonrollFields.traits); const campaignTraits = replace ? '' : asText(savedDragonrollFields.traits);
if (worldTraits || campaignTraits) fields.traits = worldTraits || campaignTraits; if (worldTraits || campaignTraits) fields.traits = worldTraits || campaignTraits;
// A replace writes the fields a live edit would leave out when the world says
// nothing, so the campaign's toggles, lists and text for this actor go with it and
// the row reads as the Foundry actor alone (Syndria98/dragonroll#96).
if (replace) {
if (fields.skills === undefined) fields.skills = {};
if (fields.savingThrows === undefined) fields.savingThrows = {};
if (fields.tools === undefined) fields.tools = [];
if (fields.languages === undefined) fields.languages = [];
if (fields.currency === undefined) fields.currency = {};
if (fields.traits === undefined) fields.traits = '';
}
return fields; return fields;
} }

View File

@@ -73,9 +73,11 @@ queued while it was off are sent as the world catches up.
With autosync off — or any time a single character needs to cross over right now — right-click an With autosync off — or any time a single character needs to cross over right now — right-click an
actor (or several selected ones) in the Foundry actor directory and pick **Dragonroll: Force Sync**. actor (or several selected ones) in the Foundry actor directory and pick **Dragonroll: Force Sync**.
Those actors, together with the gear carried inside them, are pushed to the campaign immediately even Those actors, together with the gear carried inside them, are pushed to the campaign immediately even
when autosync is off. It is an upsert only: it never prunes the campaign's other actors, which a full when autosync is off, **replacing everything that campaign holds for them** (Syndria98/dragonroll#96):
snapshot does and a forced sync never claims to. Actors Dragonroll does not import (anything that is what the campaign had edited on those actors is written over by what the world says. It replaces
not a character, NPC or creature) are refused with a notification. those actors only — it never prunes the campaign's other actors, which a full snapshot does and a
forced sync never claims to. Actors Dragonroll does not import (anything that is not a character, NPC
or creature) are refused with a notification.
The optional read-only snapshot bridge is not affected: it keeps publishing the world snapshot behind The optional read-only snapshot bridge is not affected: it keeps publishing the world snapshot behind
`/api/foundry/*`, which is never written into the campaign. `/api/foundry/*`, which is never written into the campaign.
@@ -129,6 +131,18 @@ about it cross over: the scene's **background picture** and the **grid** laid ov
- Autosync covers maps like everything else: turned off, no scene crosses over at all, and the ones - Autosync covers maps like everything else: turned off, no scene crosses over at all, and the ones
queued while it was off go over when it is turned back on. queued while it was off go over when it is turned back on.
### Notes
The campaign's notes read like the campaign's journal in the world (Syndria98/dragonroll#98): every
note stands as a page of one JournalEntry named **Dragonroll**. The module creates that journal — or
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. 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): The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
| Route | Use | | Route | Use |
@@ -140,12 +154,16 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/scene-delete` | A scene was deleted | | `POST /api/foundry/sync/scene-delete` | A scene was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry | | `GET /api/foundry/sync/characters` | Characters to apply back in Foundry |
| `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry | | `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/notes` | The campaign's notes, markdown and all, and the journal page each stands as |
| `POST /api/foundry/sync/map-note` | Store a note's journal page id after creating that page |
| `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status | | `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status |
| `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document | | `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted | | `POST /api/foundry/sync/delete` | An actor was deleted |
Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId` Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId`
flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so flag, and a journal page the module made for a note keeps its note's id in the `dragonroll-foundry.noteId`
flag, so the notes reconcile recognises its own pages. World items are marked with
`dragonroll-foundry.syncMutation` while Dragonroll writes them so
the write is not echoed back. A folder colour is written with that folder held in the client's set of the write is not echoed back. A folder colour is written with that folder held in the client's set of
folders being synced, for the same reason. folders being synced, for the same reason.

View File

@@ -2,7 +2,7 @@
"id": "dragonroll-foundry", "id": "dragonroll-foundry",
"title": "Dragonroll Foundry API", "title": "Dragonroll Foundry API",
"description": "Links a Foundry world to a Dragonroll campaign and exposes a client-side API for world data.", "description": "Links a Foundry world to a Dragonroll campaign and exposes a client-side API for world data.",
"version": "0.4.0", "version": "0.6.0",
"library": true, "library": true,
"compatibility": { "compatibility": {
"minimum": "12", "minimum": "12",

View File

@@ -457,6 +457,7 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
reconcileDragonrollNotes();
initializeSceneSync(); initializeSceneSync();
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
@@ -578,7 +579,7 @@ function reportActorSyncError(error) {
console.warn(`${MODULE_ID} | Character sync failed and will retry.`, error); console.warn(`${MODULE_ID} | Character sync failed and will retry.`, error);
} }
async function pushFoundryActors(actors, fullSync = false) { async function pushFoundryActors(actors, fullSync = false, replace = false) {
const token = getSyncToken(); const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || (!actors.length && !fullSync)) return; if (!token || !game.user?.isGM || !game.world || (!actors.length && !fullSync)) return;
if (game.system.id !== "dnd5e") { if (game.system.id !== "dnd5e") {
@@ -597,6 +598,9 @@ async function pushFoundryActors(actors, fullSync = false) {
// The folder tree those world items stand in (see worldItemFolderSnapshots). // The folder tree those world items stand in (see worldItemFolderSnapshots).
folders: worldItemFolderSnapshots(), folders: worldItemFolderSnapshots(),
fullSync, fullSync,
// A forced sync replaces the campaign's row for these actors outright; a live
// change or a full snapshot never sets this, so the campaign keeps its edits.
replace,
}, token); }, token);
for (const mapping of result.actors || []) { for (const mapping of result.actors || []) {
@@ -619,8 +623,9 @@ async function deleteDragonrollActor(foundryActorId) {
} }
// Sending actors on purpose, whether or not autosync is on: this is the push the // Sending actors on purpose, whether or not autosync is on: this is the push the
// GM asks for. It upserts those actors only, so unlike a full snapshot it never // GM asks for. It replaces everything the campaign holds for those actors (Syndria98/
// prunes anything else the campaign holds. // dragonroll#96), but it upserts them only, so unlike a full snapshot it never prunes
// anything else the campaign holds.
async function forceSyncActorsToDragonroll(actors) { async function forceSyncActorsToDragonroll(actors) {
if (!game.user?.isGM || !game.world || !actors.length) return; if (!game.user?.isGM || !game.world || !actors.length) return;
if (!getSyncToken()) { if (!getSyncToken()) {
@@ -636,7 +641,7 @@ async function forceSyncActorsToDragonroll(actors) {
if (!supported.length) return; if (!supported.length) return;
try { try {
await pushFoundryActors(supported); await pushFoundryActors(supported, false, true);
ui.notifications?.info(supported.length === 1 ui.notifications?.info(supported.length === 1
? `${supported[0].name} was sent to the Dragonroll campaign.` ? `${supported[0].name} was sent to the Dragonroll campaign.`
: `${supported.length} actors were sent to the Dragonroll campaign.`); : `${supported.length} actors were sent to the Dragonroll campaign.`);
@@ -1464,6 +1469,180 @@ async function initializeSceneSync() {
} }
} }
// --- Note pages ------------------------------------------------------------
// The campaign's notes read like the campaign's journal in the world: every note
// 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. 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;
let noteSyncErrorLogged = false;
function dragonrollNoteId(page) {
return page.getFlag?.(MODULE_ID, "noteId") || page.flags?.[MODULE_ID]?.noteId || "";
}
// A note is markdown, a journal page is HTML. Foundry's own renderer keeps the
// page readable in the journal and in its styles; where this Foundry does not
// offer one, escaped paragraphs keep the text legible until it does.
function notePageHtml(content) {
const markdown = String(content ?? "");
if (!markdown.trim()) return "";
if (typeof TextEditor !== "undefined" && typeof TextEditor._getMarkdown === "function") {
const html = TextEditor._getMarkdown(markdown);
if (html) return html;
}
return markdown
.split(/\n\s*\n/)
.map((block) => `<p>${escapeNoteHtml(block.trim()).replace(/\n/g, "<br />")}</p>`)
.join("\n");
}
function escapeNoteHtml(value) {
return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
}
function notePageTitle(entry) {
return String(entry.title || "").trim() || "Untitled note";
}
// The journal this module writes the campaign's notes into: the one it flagged as
// its own, or one the GM already made under that name. An unflagged one is
// flagged on use, so renaming it afterwards still leaves the notes' home findable.
function notesJournal() {
const journals = game.journals?.contents || [];
return journals.find((journal) => journal.getFlag?.(MODULE_ID, "notesJournal"))
|| journals.find((journal) => journal.name === NOTES_JOURNAL_NAME)
|| null;
}
async function ensureNotesJournal() {
const existing = notesJournal();
if (existing) {
if (!existing.getFlag?.(MODULE_ID, "notesJournal")) {
await existing.update({ [`flags.${MODULE_ID}.notesJournal`]: true });
}
return existing;
}
const created = await JournalEntry.create(
{ name: NOTES_JOURNAL_NAME, flags: { [MODULE_ID]: { notesJournal: true } } },
{ renderSheet: false },
);
return Array.isArray(created) ? created[0] : created;
}
// The page a note stands as: rewrite what the campaign changed, and claim a page
// the campaign mapped by id but whose flag was lost.
async function applyDragonrollNotePage(page, entry) {
const title = notePageTitle(entry);
const html = notePageHtml(entry.content);
const updates = {};
if (String(page.name ?? "") !== title) updates.name = title;
if (String(page.text?.content ?? "") !== html) updates["text.content"] = html;
if (!dragonrollNoteId(page)) updates[`flags.${MODULE_ID}.noteId`] = String(entry._id);
if (Object.keys(updates).length) await page.update(updates);
}
async function createDragonrollNotePage(journal, entry) {
const pages = await journal.createEmbeddedDocuments("JournalEntryPage", [{
// A page's display title is its `name`; `title` only holds the table-of-contents
// flags (`show`/`level`). Missing `name` fails the document's validation.
name: notePageTitle(entry),
text: { content: notePageHtml(entry.content) },
flags: { [MODULE_ID]: { noteId: String(entry._id) } },
}], { renderSheet: false });
return Array.isArray(pages) ? pages[0] : pages;
}
async function mapDragonrollNote(noteId, foundryPageId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map-note", {
worldId: game.world.id,
noteId: String(noteId),
foundryPageId: String(foundryPageId),
}, token);
}
function reportNoteSyncError(error) {
if (noteSyncErrorLogged) return;
noteSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Note journal sync failed and will retry.`, error);
}
async function reconcileDragonrollNotes() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || noteSyncRunning || !isAutoSyncEnabled()) return;
noteSyncRunning = true;
try {
const result = await getDragonroll("foundry/sync/notes", token);
const remoteNotes = result.notes || [];
// A campaign without notes gets no journal of its own — but one it once had
// stays, so the pages of notes it deleted can go with them.
if (!remoteNotes.length && !notesJournal()) return;
const journal = await ensureNotesJournal();
if (!journal) return;
const remoteById = new Map(remoteNotes.map((entry) => [String(entry._id), entry]));
const localByRemoteId = new Map((journal.pages?.contents || [])
.map((page) => [String(dragonrollNoteId(page)), page])
.filter(([noteId]) => noteId));
const retainedPageIds = new Set();
for (const entry of remoteNotes) {
let page = entry.foundryPageId ? journal.pages?.get(entry.foundryPageId) : null;
if (!page) page = localByRemoteId.get(String(entry._id));
if (page) {
retainedPageIds.add(page.id);
await applyDragonrollNotePage(page, entry);
if (!entry.foundryPageId) await mapDragonrollNote(entry._id, page.id);
} else {
// 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);
}
}
}
}
// Pages whose note the campaign deleted go with it. Only pages this module
// made are its business: an unflagged page is the GM's own.
for (const page of journal.pages?.contents || []) {
const noteId = dragonrollNoteId(page);
if (!noteId || retainedPageIds.has(page.id) || remoteById.has(String(noteId))) continue;
await page.delete();
}
noteSyncErrorLogged = false;
} catch (error) {
reportNoteSyncError(error);
} finally {
noteSyncRunning = false;
}
}
async function publishSnapshot() { async function publishSnapshot() {
if (!game.user?.isGM || !game.world) return; if (!game.user?.isGM || !game.world) return;
if (syncInProgress) { if (syncInProgress) {
@@ -1556,6 +1735,10 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
// The campaign's notes arrive as pages of the world's Dragonroll journal on
// the same rhythm: a note written in the app is on the journal within seconds.
setTimeout(reconcileDragonrollNotes, 3000);
setInterval(reconcileDragonrollNotes, 5000);
// The campaign's maps mirror this world's scenes: the whole list goes once the world is // The campaign's maps mirror this world's scenes: the whole list goes once the world is
// loaded, and that push alone tells the campaign which of its synced maps this world has // loaded, and that push alone tells the campaign which of its synced maps this world has
// let go of. // let go of.
@@ -1603,7 +1786,8 @@ Hooks.once("ready", () => {
}); });
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context
// menu. This works with autosync on and off: it is the one push done on purpose. // menu, replacing whatever the campaign holds for them. This works with autosync on
// and off: it is the one push done on purpose.
Hooks.on("getActorDirectoryEntryContext", (html, options) => { Hooks.on("getActorDirectoryEntryContext", (html, options) => {
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;

View File

@@ -52,6 +52,7 @@ Worth knowing:
| The folders grouping that item directory | Item folders with the same names and nesting | | The folders grouping that item directory | Item folders with the same names and nesting |
| A folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder | | A folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder |
| The world's **scenes** | The campaign's maps: the scene's background picture and the grid laid over it, in the scene's own cell size | | The world's **scenes** | The campaign's maps: the scene's background picture and the grid laid over it, in the scene's own cell size |
| A journal called **Dragonroll** — one page per note | Your campaign's notes. They arrive **from** Dragonroll: what you write in the journal does not go back |
The item list is the world's item directory and nothing else. The gear a character carries is that The item list is the world's item directory and nothing else. The gear a character carries is that
character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
@@ -77,6 +78,13 @@ few seconds. A **full** snapshot — the one taken when the world links, or forc
directory — is the only thing that prunes: it is the only moment either side can see the whole list and directory — is the only thing that prunes: it is the only moment either side can see the whole list and
notice what is gone. Live edits never delete anything. 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. 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 ## Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or **Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or

View File

@@ -410,6 +410,36 @@ test("an actor that holds no traits does not clear what the campaign has", () =>
assert.ok(!("traits" in character), "a live edit that knows nothing about traits leaves the tab as it is"); assert.ok(!("traits" in character), "a live edit that knows nothing about traits leaves the tab as it is");
}); });
// A forced actor sync from the module's context menu replaces everything the campaign
// holds for that actor (Syndria98/dragonroll#96): the fields a live edit leaves out when
// the world says nothing are written empty instead of kept, and the campaign's own text
// on the actor's flag does not survive it.
test("a forced sync writes empty the fields a live edit would leave out", () => {
const actor = {
name: "Thalia",
system: {},
items: [],
flags: { [MODULE_ID]: { traits: "What the campaign typed", proficiencies: "Armour, tools" } },
};
const live = foundryActorToCharacter(actor);
assert.equal(live.traits, "What the campaign typed", "a live edit fills the traits tab from the actor's flag");
assert.equal(live.proficiencies, "Armour, tools", "and the free-text proficiencies from it too");
assert.ok(
!("tools" in live) && !("languages" in live) && !("skills" in live) && !("savingThrows" in live) && !("currency" in live),
"and says nothing about the toggles and lists the world has no data for"
);
const replaced = foundryActorToCharacter(actor, true);
assert.equal(replaced.traits, "", "a forced sync clears the traits the campaign typed");
assert.equal(replaced.proficiencies, "", "down to the free-text proficiencies");
assert.deepEqual(replaced.tools, []);
assert.deepEqual(replaced.languages, []);
assert.deepEqual(replaced.skills, {});
assert.deepEqual(replaced.savingThrows, {});
assert.deepEqual(replaced.currency, {});
});
// --- The module sends the names a sheet outside Foundry can read ----------------- // --- The module sends the names a sheet outside Foundry can read -----------------
function makeWorld({ actor, config = {}, worldItems = [] }) { function makeWorld({ actor, config = {}, worldItems = [] }) {

View File

@@ -133,6 +133,7 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)), "../models/Map": fakeModel("map", seeded(seed.maps)),
}; };

View File

@@ -271,6 +271,7 @@ function loadFoundryWriters({ seed = {} } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)), "../models/Map": fakeModel("map", seeded(seed.maps)),
}; };
@@ -330,6 +331,46 @@ test("an actor the world has never been seen as becomes one row, and the next im
assert.equal(sync.models["../models/Actor"].rows[0].foundryActorId, "actor-9"); assert.equal(sync.models["../models/Actor"].rows[0].foundryActorId, "actor-9");
}); });
// A forced sync from the module's context menu (Syndria98/dragonroll#96) replaces
// everything the campaign holds for the actor; a live change is a merge and leaves the
// fields the world says nothing about to the campaign.
test("a forced actor sync clears what the campaign wrote; a live change keeps it", async () => {
const sync = loadFoundryWriters({
seed: { actors: [{
_id: "actor-1",
name: "Thalia",
foundryActorId: "actor-1",
traits: "A trait the campaign wrote",
tools: ["Thieves' tools"],
languages: ["Elvish"],
skills: { perception: true },
savingThrows: { dex: true },
currency: { gp: 50 },
}] },
});
// The world says nothing about any of those: the fields a live edit leaves out.
const worldActor = { _id: "actor-1", name: "Thalia", type: "character", system: {} };
await sync.writers.saveFoundryActor(sync.campaign, worldActor, false, false);
let row = sync.models["../models/Actor"].rows[0];
assert.equal(row.traits, "A trait the campaign wrote", "a live push leaves what the campaign wrote alone");
assert.deepEqual(row.tools, ["Thieves' tools"]);
assert.deepEqual(row.languages, ["Elvish"]);
assert.deepEqual(row.skills, { perception: true });
assert.deepEqual(row.savingThrows, { dex: true });
assert.deepEqual(row.currency, { gp: 50 });
await sync.writers.saveFoundryActor(sync.campaign, worldActor, false, true);
row = sync.models["../models/Actor"].rows[0];
assert.equal(row.name, "Thalia", "the actor is still the one the world sent");
assert.equal(row.traits, "", "a forced sync clears the trait the campaign wrote");
assert.deepEqual(row.tools, [], "and the tools, languages, skills, saving throws and coin it held");
assert.deepEqual(row.languages, []);
assert.deepEqual(row.skills, {});
assert.deepEqual(row.savingThrows, {});
assert.deepEqual(row.currency, {});
});
test("a hand-made item folds into the import instead of doubling, and keeps being updated", async () => { test("a hand-made item folds into the import instead of doubling, and keeps being updated", async () => {
const sync = loadFoundryWriters({ const sync = loadFoundryWriters({
seed: { items: [{ _id: "item-1", name: "Longsword", quantity: 1 }] }, seed: { items: [{ _id: "item-1", name: "Longsword", quantity: 1 }] },

View File

@@ -0,0 +1,605 @@
// Tests for the campaign's notes reaching the Foundry world as journal pages
// (Syndria98/dragonroll#98): every Dragonroll note stands as a page of the one
// journal the world calls "Dragonroll", written by the module and kept in step with
// the campaign. The copy runs one way — notes are written in Dragonroll — so the
// backend answers with the notes and remembers each note's page; the module reads
// them, renders the markdown, and prunes the page of a note the campaign deleted.
//
// Both sides are loaded the way the other Foundry tests do it: the sync route runs
// against a stubbed `require` (models answer with plain objects and a small filter
// matcher), and the Foundry module is loaded into a `node:vm` context holding
// stubbed Foundry globals (`game.journals` and `JournalEntry` included) with fake
// timers, like tests/item-folder-sync.test.js.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const MODULE_ID = "dragonroll-foundry";
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
// --- The sync route against stubbed models -------------------------------------
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and
// lets `select()`, `sort()` and `limit()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
limit: (count) => mongooseQuery(value.slice(0, count)),
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Enough of the query language the note routes use: equality, $or, $in, $nin,
// $exists, $ne. Anything else is a filter this test did not expect and says so.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
if (key === "$or") return expected.some((part) => matches(document, part));
const value = document?.[key];
if (expected && typeof expected === "object" && !Array.isArray(expected)) {
return Object.entries(expected).every(([operator, wanted]) => {
if (operator === "$exists") return (value !== undefined && value !== null) === wanted;
if (operator === "$in") return wanted.some((entry) => String(value) === String(entry));
if (operator === "$nin") return !wanted.some((entry) => String(value) === String(entry));
if (operator === "$ne") return String(value ?? "") !== String(wanted ?? "");
throw new Error(`filter operator "${key}.${operator}" is not stubbed`);
});
}
return String(value ?? "") === String(expected ?? "");
});
}
function fakeModel(table, seed = [], campaignId) {
const rows = [];
let counter = 0;
function Document(data = {}) {
counter += 1;
this._id = `${table}-${counter}`;
this.isNew = true;
this.foundryNames = [];
Object.assign(this, data);
}
Document.prototype.save = async function save() {
if (this.isNew) rows.push(this);
this.isNew = false;
return this;
};
Object.defineProperty(Document.prototype, "id", { get() { return this._id; } });
for (const data of seed) {
// A seeded row belongs to the campaign the requests are made against unless the
// seed says otherwise: the routes scope every lookup by campaign.
const row = new Document({ campaign: campaignId, ...data });
row.isNew = false;
rows.push(row);
}
const model = function Model(data) { return new Document(data); };
model.rows = rows;
model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null;
model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter)));
model.deleteOne = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.deleteMany = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.updateMany = async (filter, update) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) Object.assign(row, update.$set ?? {});
return { modifiedCount: hit.length };
};
return model;
}
// The Foundry sync route with every model it requires stubbed. `seed` pre-fills the
// tables with documents the campaign already holds.
function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId };
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, body = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; }, set: () => {} };
const req = { body, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token" : "") };
await handlers[handlers.length - 1](req, res);
return res.payload;
}
return { call, models, campaign };
}
// --- The sync route: the notes it answers and the page ids it keeps ---------------
test("the world reads the campaign's notes with their content and page mapping", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "- rope" },
],
},
});
const response = await sync.call("GET /sync/notes");
assert.equal(response.status, "ok");
assert.deepEqual(response.notes.map((note) => note.title), ["Session 1", "Tavern Brawl"]);
assert.equal(response.notes[0].content, "**The start**", "the markdown source travels: the module renders it");
assert.equal(response.notes[0].foundryPageId, "page-9", "and the note says which page it already stands as");
});
test("mapping a note to the page the module made keeps them paired", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(response.status, "ok");
assert.equal(sync.models["../models/Note"].rows[0].foundryPageId, "page-9");
// Mapping the same pair again is the module checking, not a conflict.
const again = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(again.status, "ok");
});
test("a page already mapped to another note is refused", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "hi", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "ho" },
],
},
});
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-2", foundryPageId: "page-9",
});
assert.equal(response.status, "error");
assert.equal(response.msg, "foundry.errors.note-already-synced");
assert.equal(sync.models["../models/Note"].rows.find((row) => row._id === "note-2").foundryPageId, undefined,
"the first note keeps its page");
});
test("map-note wants this world's note and a page for it", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
assert.equal((await sync.call("POST /sync/map-note", { worldId: "world-1" })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/map-note", { noteId: "note-1", foundryPageId: "page-9" })).msg, "errors.missing-data",
"another world cannot map this campaign's note");
const gone = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-gone", foundryPageId: "page-9",
});
assert.equal(gone.msg, "errors.notfound");
});
// --- The Foundry module writes the journal ---------------------------------------
// Foundry's `update` takes dotted paths ("flags.dragonroll-foundry.noteId"); an
// embedded document's own id is not a path to set.
function writeFoundryPaths(target, data) {
for (const [key, value] of Object.entries(data)) {
if (key === "_id") continue;
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
return target;
}
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: [],
nextId: 1,
};
const journals = [];
const makePage = (journal, data = {}) => {
const page = {
id: `page-${state.nextId++}`,
documentName: "JournalEntryPage",
name: data.name,
text: { content: data.text?.content ?? "" },
flags: data.flags ?? {},
writes: 0,
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(update) {
page.writes += 1;
writeFoundryPaths(page, update);
return page;
},
async delete() {
const index = journal.pages.contents.indexOf(page);
if (index >= 0) journal.pages.contents.splice(index, 1);
},
};
return page;
};
const makeJournal = (data = {}) => {
const pages = [];
return {
id: `journal-${state.nextId++}`,
name: data.name,
documentName: "JournalEntry",
flags: data.flags ?? {},
getFlag(module, key) { return this.flags?.[module]?.[key]; },
pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) },
async update(update) { return writeFoundryPaths(this, update); },
async createEmbeddedDocuments(documentName, docs) {
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");
// 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;
},
};
};
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
ui: { notifications: { info() {}, warn() {}, error() {} } },
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); },
},
setTimeout: (fn, delay = 0) => {
const id = state.nextId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: (fn, delay = 0) => {
// Recorded, never run by itself: tests ask for a periodic reconcile with
// `runIntervals`, so the ones watching single pushes stay on their own.
const id = state.nextId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
fetch: async (url, options = {}) => {
const href = String(url);
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 }) };
}
if (href.includes("foundry/sync/notes")) {
return { ok: true, status: 200, json: async () => ({ status: "ok", notes: state.remoteNotes }) };
}
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
JournalEntry: {
async create(data) {
const journal = makeJournal(data);
journals.push(journal);
return [journal];
},
},
};
if (markdown) sandbox.TextEditor = { _getMarkdown: (md) => `<marked>${md}</marked>` };
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: [], get: () => null },
items: { contents: [], get: () => null },
folders: { contents: [], get: () => null },
journals: { contents: journals, get: (id) => journals.find((journal) => journal.id === id) },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.journals = () => journals;
state.addJournal = (name, flags = {}) => {
const journal = makeJournal({ name, flags });
journals.push(journal);
return journal;
};
state.addPage = (journal, data) => {
const page = makePage(journal, data);
journal.pages.contents.push(page);
return page;
};
state.mapNoteRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-note"));
state.notesReads = () => state.requests.filter((request) => request.href.includes("foundry/sync/notes"));
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
// The reconciles `setInterval` registered: what runs every few seconds on a
// linked world, and so what carries each note into its journal page.
state.runIntervals = async () => {
for (const interval of [...state.intervals.values()]) await interval.fn();
await drain();
};
state.linkedSetup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
state.requests.length = 0;
return state;
};
return state;
}
// The fetch stub updates a note with the page it maps, like the real backend
// does, so every test works on notes of its own.
const sessionNote = (over = {}) => ({ _id: "note-1", title: "Session 1", content: "**The start**", ...over });
const tavernNote = (over = {}) => ({ _id: "note-2", title: "Tavern Brawl", content: "A rope, a chandelier.", ...over });
test("the campaign's notes become pages of one Dragonroll journal", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "one journal carries the campaign's notes");
const journal = world.journals()[0];
assert.equal(journal.name, "Dragonroll");
assert.deepEqual(journal.pages.contents.map((page) => [page.name, page.text.content]), [
["Session 1", "<marked>**The start**</marked>"],
["Tavern Brawl", "<marked>A rope, a chandelier.</marked>"],
], "each note is a page, its markdown rendered by Foundry's own renderer");
assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"],
"each page keeps the note it stands for");
assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [
["note-1", journal.pages.contents[0].id],
["note-2", journal.pages.contents[1].id],
], "and the campaign remembers each note's page");
});
test("reconciling again does not double the journal or its pages", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
await world.runIntervals();
await world.runIntervals();
assert.equal(world.journals().length, 1, "the journal is made once, not per reconcile");
assert.equal(world.journals()[0].pages.contents.length, 2, "and each note stands as the one page it was given");
assert.equal(world.mapNoteRequests().length, 2, "an already-mapped note is not mapped again");
});
test("an existing journal named Dragonroll is used, not doubled", async () => {
const world = await makeWorld().linkedSetup();
const gmsOwn = world.addJournal("Dragonroll");
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "the journal the world already had is the notes' one");
assert.deepEqual(gmsOwn.pages.contents.map((page) => page.name), ["Session 1"]);
assert.equal(gmsOwn.getFlag(MODULE_ID, "notesJournal"), true, "and it is marked, so renaming it keeps the notes' home findable");
});
test("a note edited in Dragonroll rewrites its page", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const first = world.remoteNotes[0];
world.remoteNotes = [{ ...first, title: "Session 1 — revisited", content: "**A different start**" }];
await world.runIntervals();
const journal = world.journals()[0];
assert.equal(journal.pages.contents.length, 1, "the note still stands as the same single page");
assert.deepEqual(journal.pages.contents[0].name, "Session 1 — revisited");
assert.equal(journal.pages.contents[0].text.content, "<marked>**A different start**</marked>");
assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping");
});
test("a note deleted in Dragonroll takes its page with it", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
const journal = world.journals()[0];
const gmsPage = world.addPage(journal, { name: "My own notes", text: { content: "not from Dragonroll" } });
world.remoteNotes = world.remoteNotes.filter((note) => note._id !== "note-2");
await world.runIntervals();
assert.deepEqual(journal.pages.contents.map((page) => page.name), ["Session 1", "My own notes"],
"the deleted note's page goes; the GM's own page stays");
assert.ok(journal.pages.contents.includes(gmsPage));
});
test("pages already in step with the campaign are not rewritten", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const [page] = world.journals()[0].pages.contents;
assert.equal(page.writes, 0, "the page was created whole, not patched");
await world.runIntervals();
assert.equal(page.writes, 0, "a reconcile that changes nothing leaves the page alone");
});
test("the campaign's page mapping claims a page whose flag was lost", async () => {
const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll");
const orphan = world.addPage(journal, { name: "Old name", text: { content: "old" } });
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: orphan.id }];
await world.runIntervals();
assert.equal(journal.pages.contents.length, 1, "no second page under the same title");
assert.equal(orphan.name, "Session 1");
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, "<marked>**The start**</marked>", "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" }];
await world.runIntervals();
assert.equal(
world.journals()[0].pages.contents[0].text.content,
"<p>a &amp; b &lt; c<br />line two</p>\n<p>second para</p>",
"escaped paragraphs instead of nothing, until this Foundry offers a renderer",
);
});
test("autosync off: the campaign's notes are not written into the world", async () => {
const world = await makeWorld().linkedSetup();
await world.game.settings.set(MODULE_ID, "autoSync", false);
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.deepEqual(world.journals(), [], "no journal is made");
assert.deepEqual(world.notesReads(), [], "and the campaign is not even asked");
});

View File

@@ -207,6 +207,7 @@ test("autosync on: Foundry CRUD events keep syncing with Dragonroll", async () =
const pushes = world.syncRequests(); const pushes = world.syncRequests();
assert.equal(pushes.length, 1); assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.actors[0]._id, "actor-1"); assert.equal(pushes[0].body.actors[0]._id, "actor-1");
assert.equal(pushes[0].body.replace, false, "a live actor change never asks Dragonroll to replace the campaign's edits");
}); });
test("autosync off: CRUD requests stop syncing", async () => { test("autosync off: CRUD requests stop syncing", async () => {
@@ -260,6 +261,7 @@ test("force sync sends selected actors to Dragonroll even with autosync off", as
const pushes = world.syncRequests(); const pushes = world.syncRequests();
assert.equal(pushes.length, 1); assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.fullSync, false, "a forced actor never prunes the campaign"); assert.equal(pushes[0].body.fullSync, false, "a forced actor never prunes the campaign");
assert.equal(pushes[0].body.replace, true, "a forced sync replaces everything the campaign holds for those actors");
assert.deepEqual(pushes[0].body.actors.map((actor) => actor._id), ["actor-2"]); assert.deepEqual(pushes[0].body.actors.map((actor) => actor._id), ["actor-2"]);
assert.deepEqual(world.notifications.filter(([kind]) => kind !== "info"), []); assert.deepEqual(world.notifications.filter(([kind]) => kind !== "info"), []);
}); });

View File

@@ -132,6 +132,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)), "../models/Map": fakeModel("map", seeded(seed.maps)),
}; };

View File

@@ -112,6 +112,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1", settings } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
"../models/Map": fakeModel("map", seeded(seed.maps)), "../models/Map": fakeModel("map", seeded(seed.maps)),
}; };