jdkjskdj
Some checks failed
Build and Deploy Nuxt / build (push) Successful in 1m10s
Test / test (push) Failing after 2s

This commit is contained in:
2026-10-19 19:42:10 +02:00
parent 1c98af69b2
commit b83f64ff9e
14 changed files with 299 additions and 9 deletions

View File

@@ -116,7 +116,7 @@ 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
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
prunes), `scene-delete`, `characters`, `items`, `notes` / `map-note`, `status`,
prunes), `scene-delete`, `characters`, `items`, `notes` / `map-note`, `status`, `unlink`,
`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.

View File

@@ -8,12 +8,11 @@ const serviceLinks = require('../services/service-links');
// Every service links to a campaign through the same sign-up link
// (routes/service-link.js); a campaign only drops one of them again.
async function unlinkService(campaign, service) {
if (service === 'foundry') {
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
} else if (service === 'discord') {
// A Foundry world can also let the campaign go from the module itself
// (routes/foundry-link.js), so both go through the same helper.
if (service === 'foundry') return serviceLinks.unlinkFoundryWorld(campaign);
if (service === 'discord') {
// The Discord account the bot answers to stays: the server is simply
// left without a campaign until somebody picks one again.
campaign.discordGuildId = undefined;

View File

@@ -14,6 +14,7 @@ const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry');
const { foundrySceneToMapData } = require('../services/map-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
const serviceLinks = require('../services/service-links');
// Upper bound for the Foundry names remembered per synced item (see Item model).
const MAX_FOUNDRY_NAMES = 20;
@@ -698,6 +699,25 @@ router.post('/sync/map-note', async (req, res) => {
}
});
// A world letting its campaign go from the module settings: the campaign forgets
// the world and the token this request used stops working, so the world is free
// to pair again — and the campaign's settings stop listing it as connected.
router.post('/sync/unlink', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
if (!requestMatchesWorld(campaign, req.body.worldId)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
await serviceLinks.unlinkFoundryWorld(campaign);
res.json({ status: 'ok' });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router;
// 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

View File

@@ -165,7 +165,9 @@ async function startServiceLink(service, target) {
async function findServiceLinkByCode(code) {
if (!code) return null;
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials').lean();
// Not `.lean()`: the link answered by /complete is saved back with its new
// state, and a plain object has no document behind it to save.
return ServiceLinkRequest.findOne({ codeHash: codeHash(code) }).select('+credentials');
}
// The credential that belongs to a link is handed over once and then dropped:
@@ -211,6 +213,18 @@ async function revokeServiceLink(service, campaignId) {
return result.matchedCount;
}
// A campaign letting a Foundry world go: it forgets the world, which frees the
// world to pair with a campaign again, and the token the world still holds stops
// working the next time it asks.
async function unlinkFoundryWorld(campaign) {
campaign.foundryWorldId = undefined;
campaign.foundryWorldTitle = undefined;
campaign.foundrySystem = undefined;
campaign.set('foundrySyncTokenHash', undefined);
await campaign.save();
await revokeServiceLink('foundry', campaign._id);
}
// What a campaign has connected to it, newest link first and one row per
// service, so the campaign settings can list its services together.
async function listLinkedServices(campaignId) {
@@ -254,5 +268,6 @@ module.exports = {
serviceName,
signUpLinkUrl,
startServiceLink,
takeServiceLinkCredentials
takeServiceLinkCredentials,
unlinkFoundryWorld
};

View File

@@ -54,6 +54,13 @@ gives the reason when a pairing code can never be redeemed, and says the world i
once the campaign unlinks it. Because both the pairing code and the sync token are client settings,
another browser of the same world reads as not paired.
**Dragonroll Connection** in the module settings opens the same state with the two actions a GM needs:
**Copy link** puts the sign-up link on the clipboard to hand to whoever will pick the campaign, and
**Unlink campaign** lets the world go. Unlinking drops the token on this client and on the campaign
(`POST /api/foundry/sync/unlink`), so the campaign's settings stop listing the world and it can be
paired again. If Dragonroll cannot be reached the token is kept and the failure is reported instead —
dropping it alone would leave the campaign still believing the world is connected.
The campaign settings show the linked world's title and system. A Foundry world can be linked to
only one campaign at a time. The pairing endpoint accepts cross-origin requests from the Foundry
client and uses the one-time code instead of a Dragonroll login token.
@@ -182,6 +189,7 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `GET /api/foundry/sync/notes/revision` | A hash of the campaign's notes and folder paths, for the module's change check |
| `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 |
| `POST /api/foundry/sync/unlink` | The module unlinks the world; the campaign forgets it and the token is revoked |
| `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted |

View File

@@ -180,6 +180,8 @@ Hooks.once("init", () => {
onChange: handleAutoSyncChange,
});
registerPairingMenu();
const module = game.modules.get(MODULE_ID);
if (!module) {
console.warn(`${MODULE_ID} | Could not register the public API: module was not found.`);
@@ -427,6 +429,135 @@ async function refreshPairingStatus() {
await setPairingStatus(pairingStatusText());
}
// --- Connection actions ----------------------------------------------------
// The module settings open a small window for the two things a GM does about a
// pairing: hand its sign-up link to somebody, and let the campaign go again.
// The sign-up link lives in a client setting, so copying it is how it reaches
// the browser the user will open it in.
async function copyPairingLink() {
if (getSyncToken()) {
ui.notifications?.info("This world is already linked to a Dragonroll campaign; there is no sign-up link to copy.");
return;
}
if (!game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim()) await requestDragonrollLink();
const link = game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim();
if (!link) {
ui.notifications?.warn("Dragonroll does not have a sign-up link for this world right now. Check the Dragonroll Endpoint setting.");
return;
}
try {
await navigator.clipboard.writeText(link);
ui.notifications?.info("Dragonroll sign-up link copied to the clipboard.");
} catch (error) {
// A browser can refuse the clipboard; the link is still the GM's to copy.
console.warn(`${MODULE_ID} | Could not copy the Dragonroll sign-up link.`, error);
ui.notifications?.warn(`Copy the Dragonroll sign-up link yourself: ${link}`);
}
}
// Letting the campaign go from this side: Dragonroll forgets the world and drops
// the token, so this world can pair with a campaign again. An unreachable
// Dragonroll keeps the token — dropping it here would leave the campaign still
// listing a world that can no longer reach it.
async function unlinkDragonrollCampaign() {
if (!game.user?.isGM || !game.world) return;
const token = getSyncToken();
try {
if (token) await postDragonroll("foundry/sync/unlink", { worldId: game.world.id }, token);
} catch (error) {
if (error.message !== "unauthorized") {
console.error(`${MODULE_ID} | Could not unlink this world from Dragonroll.`, error);
ui.notifications?.warn(`Dragonroll could not unlink this world: ${error.message}`);
return;
}
}
await game.settings.set(MODULE_ID, SETTING_SYNC_TOKEN, "");
linkedCampaignName = "";
linkProblem = "";
await setLink("", "");
await setPairingStatus(pairingStatusText());
ui.notifications?.info("This Foundry world is no longer linked to its Dragonroll campaign.");
await requestDragonrollLink();
}
function registerPairingMenu() {
const ApplicationV2 = globalThis.foundry?.applications?.api?.ApplicationV2;
// The module is loaded without Foundry's settings UI in its tests, and no
// Foundry this module runs on lacks ApplicationV2.
if (typeof game.settings.registerMenu !== "function" || !ApplicationV2) return;
class DragonrollPairingMenu extends ApplicationV2 {
static DEFAULT_OPTIONS = {
id: "dragonroll-pairing-menu",
classes: [MODULE_ID],
window: { title: "Dragonroll Connection", icon: "fa-solid fa-link" },
position: { width: 560 },
actions: {
copyLink() {
return copyPairingLink().then(() => this.render());
},
unlink() {
return unlinkDragonrollCampaign().then(() => this.render());
},
},
};
async _renderHTML() {
const link = game.settings.get(MODULE_ID, SETTING_LINK_URL)?.trim();
const root = document.createElement("div");
root.className = "dragonroll-pairing-menu";
const status = document.createElement("p");
status.textContent = pairingStatusText();
root.append(status);
if (link) {
const field = document.createElement("input");
field.type = "text";
field.readOnly = true;
field.value = link;
field.addEventListener("focus", () => field.select());
root.append(field);
}
const actions = document.createElement("div");
actions.className = "dragonroll-pairing-actions";
const copy = document.createElement("button");
copy.type = "button";
copy.dataset.action = "copyLink";
copy.innerHTML = '<i class="fa-solid fa-copy"></i> Copy link';
copy.disabled = Boolean(getSyncToken());
const unlink = document.createElement("button");
unlink.type = "button";
unlink.dataset.action = "unlink";
unlink.innerHTML = '<i class="fa-solid fa-link-slash"></i> Unlink campaign';
unlink.disabled = !getSyncToken();
actions.append(copy, unlink);
root.append(actions);
return root;
}
_replaceHTML(result, content) {
content.replaceChildren(result);
}
}
game.settings.registerMenu(MODULE_ID, "pairingMenu", {
name: "Dragonroll Connection",
label: "Copy link / Unlink",
hint: "Copy this world's sign-up link, or unlink the Dragonroll campaign it was paired with.",
icon: "fa-solid fa-link",
type: DragonrollPairingMenu,
restricted: true,
});
}
function scheduleSnapshotSync(delay = 500) {
clearTimeout(syncTimeout);
syncTimeout = setTimeout(publishSnapshot, delay);

View File

@@ -25,3 +25,19 @@
text-decoration: underline dashed;
cursor: help;
}
/* The connection window the module settings open: the sign-up link and its actions. */
.dragonroll-pairing-menu {
display: flex;
flex-direction: column;
gap: 10px;
}
.dragonroll-pairing-menu input[readonly] {
width: 100%;
}
.dragonroll-pairing-actions {
display: flex;
gap: 8px;
}

View File

@@ -148,6 +148,7 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
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 (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -284,6 +284,7 @@ function loadFoundryWriters({ seed = {} } = {}) {
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 (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -133,6 +133,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
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 (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -40,8 +40,10 @@ function makeStubWorld({
const state = {
hooks: new Map(),
registered: new Map(),
menus: new Map(),
requests: [],
notifications: [],
copied: [],
};
const settingsStore = {
@@ -57,6 +59,10 @@ function makeStubWorld({
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
// The module registers a menu for its connection actions: the window needs
// ApplicationV2 to exist, not to render.
foundry: { applications: { api: { ApplicationV2: class { render() {} } } } },
navigator: { clipboard: { writeText: async (text) => state.copied.push(text) } },
ui: {
notifications: {
info: (text) => state.notifications.push(["info", text]),
@@ -110,6 +116,7 @@ function makeStubWorld({
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
registerMenu(module, key, definition) { state.menus.set(key, definition); },
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
@@ -267,6 +274,43 @@ test("an expired link is replaced by one the GM can still open", async () => {
assert.match(world.status(), /link-code-2/, "and shows the new one");
});
test("the connection window copies the sign-up link", async () => {
const world = await makeStubWorld({
syncToken: "",
linkCode: "link-code-1",
linkUrl: SIGN_UP_LINK,
answers: { "link/pickup": { status: "ok", state: "pending" } },
}).start();
const menu = world.menus.get("pairingMenu");
assert.ok(menu, "the module settings open the connection window");
await menu.type.DEFAULT_OPTIONS.actions.copyLink.call(new menu.type());
assert.deepEqual(world.copied, [SIGN_UP_LINK], "the link waiting for its GM reaches the clipboard");
});
test("the connection window unlinks the campaign and asks for a fresh link", async () => {
const world = await makeStubWorld({
answers: {
"foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" },
"foundry/sync/unlink": { status: "ok" },
"link/start": { status: "ok", code: "link-code-2", linkUrl: SIGN_UP_LINK },
},
}).start();
assert.equal(world.status(), `Connected to the Dragonroll campaign "${LINKED_CAMPAIGN.name}".`);
const menu = world.menus.get("pairingMenu");
await menu.type.DEFAULT_OPTIONS.actions.unlink.call(new menu.type());
const unlink = world.requests.find((request) => request.href.includes("foundry/sync/unlink"));
assert.ok(unlink, "Dragonroll is told to forget this world");
assert.equal(unlink.body.worldId, "world-1");
assert.equal(unlink.authorization, "Bearer sync-token-1", "the world unlinks with the token it holds");
assert.equal(world.setting("syncToken"), "", "the token is dropped on this client too");
assert.equal(world.setting("linkCode"), "link-code-2", "a fresh link is kept ready to pair again");
assert.match(world.status(), /^Not connected yet/);
});
test("whatever is typed into the status is replaced by the real one", async () => {
const world = await makeStubWorld({
answers: { "foundry/sync/status": { status: "ok", campaign: LINKED_CAMPAIGN, worldId: "world-1" } },

View File

@@ -145,6 +145,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
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 (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -125,6 +125,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1", settings } = {}) {
if (id === "../services/item-foundry") return { foundryItemToItemData: () => null };
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 (id === "../services/service-links") return { unlinkFoundryWorld: async () => {} };
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};

View File

@@ -6,6 +6,58 @@ const { test } = require("node:test");
const assert = require("node:assert/strict");
const serviceLinks = require("../backend/src/services/service-links");
const ServiceLinkRequest = require("../backend/src/models/ServiceLinkRequest");
test("a link found by its code can be answered and saved", async () => {
const original = ServiceLinkRequest.findOne;
const document = { _id: "link-1", state: "pending", save: async () => {} };
const query = {
select: () => query,
lean: () => Promise.resolve({ _id: "link-1", state: "pending" }),
then: (resolve, reject) => Promise.resolve(document).then(resolve, reject),
};
ServiceLinkRequest.findOne = () => query;
try {
const request = await serviceLinks.findServiceLinkByCode("code-1");
assert.equal(typeof request?.save, "function",
"the complete route saves the answered link, so it cannot be a plain lean object");
} finally {
ServiceLinkRequest.findOne = original;
}
});
test("unlinking a Foundry world forgets it and revokes its link", async () => {
const original = ServiceLinkRequest.updateMany;
const revocations = [];
ServiceLinkRequest.updateMany = async (filter, update) => {
revocations.push({ filter, update });
return { matchedCount: 1 };
};
try {
const campaign = {
_id: "campaign-1",
foundryWorldId: "world-1",
foundryWorldTitle: "Test World",
foundrySystem: "dnd5e",
foundrySyncTokenHash: "hash",
set(key, value) { this[key] = value; },
async save() { campaign.saved = true; },
};
await serviceLinks.unlinkFoundryWorld(campaign);
assert.equal(campaign.saved, true);
assert.equal(campaign.foundryWorldId, undefined);
assert.equal(campaign.foundryWorldTitle, undefined);
assert.equal(campaign.foundrySystem, undefined);
assert.equal(campaign.foundrySyncTokenHash, undefined);
assert.equal(revocations[0].filter.service, "foundry");
assert.equal(revocations[0].filter.campaign, "campaign-1");
assert.equal(revocations[0].update.$set.state, "revoked");
} finally {
ServiceLinkRequest.updateMany = original;
}
});
test("a link request keeps the service metadata short and plain", () => {
const target = serviceLinks.readTarget({