BlueGit

timfa questward

Files

questward / server / src / persistence / worldDb.js

worldDb.js

worldDb.js 19.7 KiB Download Raw
1import { DEFAULT_WORLD_SETTINGS } from "../../../shared/protocol/constants.js";
2import { normalizeStarterLoadout } from "../../../shared/items/starterLoadout.js";
3import {
4 OVERWORLD_ID,
5 DIMENSION_PURGE_MS,
6 defaultDimensionRecord,
7 normalizeDimensionRecord,
8 normalizeDimensionId,
9 isOverworld
10} from "../../../shared/world/dimensions.js";
11import { openDatabase, withTransaction } from "./database.js";
12
13const WORLD_SCHEMA = `
14CREATE TABLE IF NOT EXISTS world_revisions (
15 revision_id INTEGER PRIMARY KEY AUTOINCREMENT,
16 created_at INTEGER NOT NULL,
17 created_by TEXT NOT NULL,
18 status TEXT NOT NULL
19);
20
21CREATE TABLE IF NOT EXISTS world_chunk_versions (
22 dimension_id TEXT NOT NULL DEFAULT 'overworld',
23 chunk_x INTEGER NOT NULL,
24 chunk_y INTEGER NOT NULL,
25 revision_id INTEGER NOT NULL,
26 open INTEGER NOT NULL,
27 data_blob TEXT NOT NULL,
28 PRIMARY KEY (dimension_id, chunk_x, chunk_y, revision_id)
29);
30
31CREATE TABLE IF NOT EXISTS world_meta (
32 key TEXT PRIMARY KEY,
33 value INTEGER
34);
35
36CREATE TABLE IF NOT EXISTS world_settings (
37 revision_id INTEGER PRIMARY KEY,
38 settings_blob TEXT NOT NULL
39);
40
41CREATE TABLE IF NOT EXISTS world_chunk_edit_log (
42 log_id INTEGER PRIMARY KEY AUTOINCREMENT,
43 dimension_id TEXT NOT NULL DEFAULT 'overworld',
44 chunk_x INTEGER NOT NULL,
45 chunk_y INTEGER NOT NULL,
46 revision_id INTEGER NOT NULL,
47 editor_admin_id TEXT NOT NULL,
48 edited_at INTEGER NOT NULL,
49 diff_entries TEXT NOT NULL
50);
51
52CREATE TABLE IF NOT EXISTS world_live_settings (
53 id INTEGER PRIMARY KEY CHECK (id = 1),
54 settings_blob TEXT NOT NULL,
55 updated_at INTEGER NOT NULL,
56 updated_by TEXT NOT NULL
57);
58
59CREATE TABLE IF NOT EXISTS world_settings_edit_log (
60 log_id INTEGER PRIMARY KEY AUTOINCREMENT,
61 editor_admin_id TEXT NOT NULL,
62 edited_at INTEGER NOT NULL,
63 diff_entries TEXT NOT NULL
64);
65
66CREATE TABLE IF NOT EXISTS world_quest_defs (
67 revision_id INTEGER NOT NULL,
68 quest_id TEXT NOT NULL,
69 def_blob TEXT NOT NULL,
70 PRIMARY KEY (revision_id, quest_id)
71);
72
73CREATE TABLE IF NOT EXISTS world_dialogue_trees (
74 revision_id INTEGER NOT NULL,
75 dialogue_id TEXT NOT NULL,
76 tree_blob TEXT NOT NULL,
77 PRIMARY KEY (revision_id, dialogue_id)
78);
79
80CREATE TABLE IF NOT EXISTS world_dimensions (
81 revision_id INTEGER NOT NULL,
82 dimension_id TEXT NOT NULL,
83 display_name TEXT NOT NULL,
84 lighting_mode TEXT NOT NULL,
85 season_mode TEXT NOT NULL,
86 default_ground_type_id INTEGER NOT NULL,
87 deleted_at INTEGER,
88 purge_after INTEGER,
89 PRIMARY KEY (revision_id, dimension_id)
90);
91`;
92
93export class WorldDatabase
94{
95 constructor (filePath)
96 {
97 this.db = openDatabase(filePath);
98 this.db.exec(WORLD_SCHEMA);
99 this.#migrateChunkDimensionColumn();
100 this.#ensureInitialRevision();
101 this.#ensureLiveSettings();
102 this.#ensureOverworldDimension(this.getActiveRevisionId());
103 }
104
105 #migrateChunkDimensionColumn ()
106 {
107 const cols = this.db.prepare("PRAGMA table_info(world_chunk_versions)").all();
108 const hasDim = cols.some((col) => col.name === "dimension_id");
109 if (hasDim)
110 {
111 this.#migrateEditLogDimensionColumn();
112 return;
113 }
114
115 withTransaction(this.db, () =>
116 {
117 this.db.exec(`
118 CREATE TABLE world_chunk_versions_v2 (
119 dimension_id TEXT NOT NULL DEFAULT 'overworld',
120 chunk_x INTEGER NOT NULL,
121 chunk_y INTEGER NOT NULL,
122 revision_id INTEGER NOT NULL,
123 open INTEGER NOT NULL,
124 data_blob TEXT NOT NULL,
125 PRIMARY KEY (dimension_id, chunk_x, chunk_y, revision_id)
126 );
127 INSERT INTO world_chunk_versions_v2
128 (dimension_id, chunk_x, chunk_y, revision_id, open, data_blob)
129 SELECT 'overworld', chunk_x, chunk_y, revision_id, open, data_blob
130 FROM world_chunk_versions;
131 DROP TABLE world_chunk_versions;
132 ALTER TABLE world_chunk_versions_v2 RENAME TO world_chunk_versions;
133 `);
134 });
135 this.#migrateEditLogDimensionColumn();
136 }
137
138 #migrateEditLogDimensionColumn ()
139 {
140 const cols = this.db.prepare("PRAGMA table_info(world_chunk_edit_log)").all();
141 const hasDim = cols.some((col) => col.name === "dimension_id");
142 if (hasDim)
143 { return; }
144 withTransaction(this.db, () =>
145 {
146 this.db.exec(`
147 CREATE TABLE world_chunk_edit_log_v2 (
148 log_id INTEGER PRIMARY KEY AUTOINCREMENT,
149 dimension_id TEXT NOT NULL DEFAULT 'overworld',
150 chunk_x INTEGER NOT NULL,
151 chunk_y INTEGER NOT NULL,
152 revision_id INTEGER NOT NULL,
153 editor_admin_id TEXT NOT NULL,
154 edited_at INTEGER NOT NULL,
155 diff_entries TEXT NOT NULL
156 );
157 INSERT INTO world_chunk_edit_log_v2
158 (log_id, dimension_id, chunk_x, chunk_y, revision_id, editor_admin_id, edited_at, diff_entries)
159 SELECT log_id, 'overworld', chunk_x, chunk_y, revision_id, editor_admin_id, edited_at, diff_entries
160 FROM world_chunk_edit_log;
161 DROP TABLE world_chunk_edit_log;
162 ALTER TABLE world_chunk_edit_log_v2 RENAME TO world_chunk_edit_log;
163 `);
164 });
165 }
166
167 #ensureInitialRevision ()
168 {
169 const meta = this.db.prepare("SELECT key, value FROM world_meta").all();
170 if (meta.length > 0)
171 { return; }
172
173 withTransaction(this.db, () =>
174 {
175 this.db.prepare(
176 "INSERT INTO world_revisions (created_at, created_by, status) VALUES (?, ?, ?)"
177 ).run(Date.now(), "system", "active");
178 const revisionId = Number(this.db.prepare("SELECT last_insert_rowid() AS id").get().id);
179 this.db.prepare("INSERT INTO world_meta (key, value) VALUES ('active_revision', ?)").run(revisionId);
180 this.db.exec("INSERT INTO world_meta (key, value) VALUES ('pending_revision', NULL)");
181 this.db.prepare("INSERT INTO world_settings (revision_id, settings_blob) VALUES (?, ?)").run(
182 revisionId,
183 JSON.stringify(DEFAULT_WORLD_SETTINGS)
184 );
185 this.#upsertDimensionRow(revisionId, defaultDimensionRecord(OVERWORLD_ID, {
186 defaultGroundTypeId: DEFAULT_WORLD_SETTINGS.defaultGroundTypeId
187 }));
188 });
189 }
190
191 #ensureOverworldDimension (revisionId)
192 {
193 if (revisionId == null)
194 { return; }
195 const existing = this.getDimension(revisionId, OVERWORLD_ID);
196 if (existing)
197 { return; }
198 const settings = this.getSettings(revisionId);
199 this.#upsertDimensionRow(revisionId, defaultDimensionRecord(OVERWORLD_ID, {
200 defaultGroundTypeId: settings.defaultGroundTypeId
201 }));
202 }
203
204 #upsertDimensionRow (revisionId, record)
205 {
206 const dim = normalizeDimensionRecord(record);
207 this.db.prepare(`
208 INSERT INTO world_dimensions (
209 revision_id, dimension_id, display_name, lighting_mode, season_mode,
210 default_ground_type_id, deleted_at, purge_after
211 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
212 ON CONFLICT(revision_id, dimension_id) DO UPDATE SET
213 display_name = excluded.display_name,
214 lighting_mode = excluded.lighting_mode,
215 season_mode = excluded.season_mode,
216 default_ground_type_id = excluded.default_ground_type_id,
217 deleted_at = excluded.deleted_at,
218 purge_after = excluded.purge_after
219 `).run(
220 revisionId,
221 dim.dimensionId,
222 dim.displayName,
223 dim.lightingMode,
224 dim.seasonMode,
225 dim.defaultGroundTypeId,
226 dim.deletedAt,
227 dim.purgeAfter
228 );
229 }
230
231 #rowToDimension (row)
232 {
233 if (!row)
234 { return null; }
235 return normalizeDimensionRecord({
236 dimensionId: row.dimension_id,
237 displayName: row.display_name,
238 lightingMode: row.lighting_mode,
239 seasonMode: row.season_mode,
240 defaultGroundTypeId: row.default_ground_type_id,
241 deletedAt: row.deleted_at,
242 purgeAfter: row.purge_after
243 });
244 }
245
246 #ensureLiveSettings ()
247 {
248 const existing = this.db.prepare("SELECT id FROM world_live_settings WHERE id = 1").get();
249 if (existing)
250 { return; }
251
252 const settings = this.getSettings(this.getActiveRevisionId());
253 this.db.prepare(
254 "INSERT INTO world_live_settings (id, settings_blob, updated_at, updated_by) VALUES (1, ?, ?, ?)"
255 ).run(JSON.stringify(settings), Date.now(), "system");
256 }
257
258 getLiveSettings ()
259 {
260 this.#ensureLiveSettings();
261 const row = this.db.prepare("SELECT settings_blob FROM world_live_settings WHERE id = 1").get();
262 const merged = row
263 ? { ...DEFAULT_WORLD_SETTINGS, ...JSON.parse(row.settings_blob) }
264 : { ...DEFAULT_WORLD_SETTINGS };
265 const loadout = normalizeStarterLoadout(merged);
266 merged.starterEquipment = loadout.equipment;
267 merged.starterInventory = loadout.inventory;
268 return merged;
269 }
270
271 saveLiveSettings (settings, updatedBy)
272 {
273 this.db.prepare(`
274 INSERT INTO world_live_settings (id, settings_blob, updated_at, updated_by)
275 VALUES (1, ?, ?, ?)
276 ON CONFLICT(id) DO UPDATE SET
277 settings_blob = excluded.settings_blob,
278 updated_at = excluded.updated_at,
279 updated_by = excluded.updated_by
280 `).run(JSON.stringify(settings), Date.now(), updatedBy);
281 }
282
283 appendSettingsChangelog (editorAdminId, diffEntries)
284 {
285 this.db.prepare(`
286 INSERT INTO world_settings_edit_log (editor_admin_id, edited_at, diff_entries)
287 VALUES (?, ?, ?)
288 `).run(editorAdminId, Date.now(), JSON.stringify(diffEntries));
289 }
290
291 listSettingsChangelog ()
292 {
293 return this.db.prepare(`
294 SELECT log_id, editor_admin_id, edited_at, diff_entries
295 FROM world_settings_edit_log
296 ORDER BY edited_at ASC, log_id ASC
297 `).all().map((row) => ({
298 ...row,
299 diffEntries: JSON.parse(row.diff_entries)
300 }));
301 }
302
303 getActiveRevisionId ()
304 {
305 return this.db.prepare("SELECT value FROM world_meta WHERE key = 'active_revision'").get()?.value ?? null;
306 }
307
308 getPendingRevisionId ()
309 {
310 return this.db.prepare("SELECT value FROM world_meta WHERE key = 'pending_revision'").get()?.value ?? null;
311 }
312
313 getEditorRevisionId ()
314 {
315 return this.getPendingRevisionId() ?? this.getActiveRevisionId();
316 }
317
318 getSettings (revisionId)
319 {
320 const row = this.db.prepare("SELECT settings_blob FROM world_settings WHERE revision_id = ?").get(revisionId);
321 if (row)
322 { return { ...DEFAULT_WORLD_SETTINGS, ...JSON.parse(row.settings_blob) }; }
323
324 const fallback = this.db.prepare(
325 "SELECT settings_blob FROM world_settings WHERE revision_id <= ? ORDER BY revision_id DESC LIMIT 1"
326 ).get(revisionId);
327 return fallback
328 ? { ...DEFAULT_WORLD_SETTINGS, ...JSON.parse(fallback.settings_blob) }
329 : { ...DEFAULT_WORLD_SETTINGS };
330 }
331
332 listDimensions (revisionId)
333 {
334 this.#ensureOverworldDimension(revisionId);
335 return this.db.prepare(`
336 SELECT dimension_id, display_name, lighting_mode, season_mode,
337 default_ground_type_id, deleted_at, purge_after
338 FROM world_dimensions
339 WHERE revision_id = ?
340 ORDER BY dimension_id ASC
341 `).all(revisionId).map((row) => this.#rowToDimension(row));
342 }
343
344 getDimension (revisionId, dimensionId)
345 {
346 const id = normalizeDimensionId(dimensionId);
347 const row = this.db.prepare(`
348 SELECT dimension_id, display_name, lighting_mode, season_mode,
349 default_ground_type_id, deleted_at, purge_after
350 FROM world_dimensions
351 WHERE revision_id = ? AND dimension_id = ?
352 `).get(revisionId, id);
353 return this.#rowToDimension(row);
354 }
355
356 /** Latest dimension row at or before revision (for live fallback). */
357 getDimensionAtOrBefore (revisionId, dimensionId)
358 {
359 const id = normalizeDimensionId(dimensionId);
360 const row = this.db.prepare(`
361 SELECT dimension_id, display_name, lighting_mode, season_mode,
362 default_ground_type_id, deleted_at, purge_after
363 FROM world_dimensions
364 WHERE dimension_id = ? AND revision_id <= ?
365 ORDER BY revision_id DESC
366 LIMIT 1
367 `).get(id, revisionId);
368 return this.#rowToDimension(row);
369 }
370
371 saveDimension (revisionId, record)
372 {
373 const dim = normalizeDimensionRecord(record);
374 if (isOverworld(dim.dimensionId))
375 {
376 dim.deletedAt = null;
377 dim.purgeAfter = null;
378 }
379 this.#upsertDimensionRow(revisionId, dim);
380 return dim;
381 }
382
383 softDeleteDimension (revisionId, dimensionId, now = Date.now())
384 {
385 const id = normalizeDimensionId(dimensionId);
386 if (isOverworld(id))
387 { return { ok: false, error: "Cannot delete overworld." }; }
388 const existing = this.getDimension(revisionId, id) ?? defaultDimensionRecord(id);
389 existing.deletedAt = now;
390 existing.purgeAfter = now + DIMENSION_PURGE_MS;
391 this.#upsertDimensionRow(revisionId, existing);
392 return { ok: true, dimension: existing };
393 }
394
395 cancelDimensionDeletion (revisionId, dimensionId)
396 {
397 const id = normalizeDimensionId(dimensionId);
398 const existing = this.getDimension(revisionId, id);
399 if (!existing)
400 { return { ok: false, error: "Unknown dimension." }; }
401 existing.deletedAt = null;
402 existing.purgeAfter = null;
403 this.#upsertDimensionRow(revisionId, existing);
404 return { ok: true, dimension: existing };
405 }
406
407 /** Permanently remove dimensions past purge_after and all their chunk versions. */
408 purgeExpiredDimensions (now = Date.now())
409 {
410 const rows = this.db.prepare(`
411 SELECT DISTINCT dimension_id FROM world_dimensions
412 WHERE purge_after IS NOT NULL AND purge_after <= ? AND dimension_id != ?
413 `).all(now, OVERWORLD_ID);
414 let purged = 0;
415 for (const row of rows)
416 {
417 const id = row.dimension_id;
418 withTransaction(this.db, () =>
419 {
420 this.db.prepare("DELETE FROM world_chunk_versions WHERE dimension_id = ?").run(id);
421 this.db.prepare("DELETE FROM world_chunk_edit_log WHERE dimension_id = ?").run(id);
422 this.db.prepare("DELETE FROM world_dimensions WHERE dimension_id = ?").run(id);
423 });
424 purged += 1;
425 }
426 return purged;
427 }
428
429 getChunkVersion (chunkX, chunkY, revisionId, dimensionId = OVERWORLD_ID)
430 {
431 const dim = normalizeDimensionId(dimensionId);
432 return this.db.prepare(`
433 SELECT dimension_id, chunk_x, chunk_y, revision_id, open, data_blob
434 FROM world_chunk_versions
435 WHERE dimension_id = ? AND chunk_x = ? AND chunk_y = ? AND revision_id <= ?
436 ORDER BY revision_id DESC
437 LIMIT 1
438 `).get(dim, chunkX, chunkY, revisionId) ?? null;
439 }
440
441 listChunkCoords (revisionId, dimensionId = null)
442 {
443 if (dimensionId != null)
444 {
445 const dim = normalizeDimensionId(dimensionId);
446 return this.db.prepare(`
447 SELECT dimension_id, chunk_x, chunk_y, MAX(revision_id) AS revision_id
448 FROM world_chunk_versions
449 WHERE revision_id <= ? AND dimension_id = ?
450 GROUP BY dimension_id, chunk_x, chunk_y
451 `).all(revisionId, dim);
452 }
453 return this.db.prepare(`
454 SELECT dimension_id, chunk_x, chunk_y, MAX(revision_id) AS revision_id
455 FROM world_chunk_versions
456 WHERE revision_id <= ?
457 GROUP BY dimension_id, chunk_x, chunk_y
458 `).all(revisionId);
459 }
460
461 ensurePendingRevision (createdBy)
462 {
463 const existing = this.getPendingRevisionId();
464 if (existing)
465 { return existing; }
466
467 return withTransaction(this.db, () =>
468 {
469 const activeId = this.getActiveRevisionId();
470 this.db.prepare(
471 "INSERT INTO world_revisions (created_at, created_by, status) VALUES (?, ?, ?)"
472 ).run(Date.now(), createdBy, "pending");
473 const revisionId = Number(this.db.prepare("SELECT last_insert_rowid() AS id").get().id);
474 this.db.prepare("UPDATE world_meta SET value = ? WHERE key = 'pending_revision'").run(revisionId);
475
476 const settings = this.getSettings(activeId);
477 this.db.prepare("INSERT INTO world_settings (revision_id, settings_blob) VALUES (?, ?)").run(
478 revisionId,
479 JSON.stringify(settings)
480 );
481 this.#copyQuestDefs(activeId, revisionId);
482 this.#copyDialogueTrees(activeId, revisionId);
483 this.#copyDimensions(activeId, revisionId);
484 return revisionId;
485 });
486 }
487
488 #copyDimensions (fromRevisionId, toRevisionId)
489 {
490 const rows = this.listDimensions(fromRevisionId);
491 for (const dim of rows)
492 { this.#upsertDimensionRow(toRevisionId, dim); }
493 this.#ensureOverworldDimension(toRevisionId);
494 }
495
496 #copyQuestDefs (fromRevisionId, toRevisionId)
497 {
498 const rows = this.listQuestDefs(fromRevisionId);
499 const insert = this.db.prepare(`
500 INSERT INTO world_quest_defs (revision_id, quest_id, def_blob)
501 VALUES (?, ?, ?)
502 `);
503 for (const def of rows)
504 { insert.run(toRevisionId, def.questId, JSON.stringify(def)); }
505 }
506
507 #copyDialogueTrees (fromRevisionId, toRevisionId)
508 {
509 const rows = this.listDialogueTrees(fromRevisionId);
510 const insert = this.db.prepare(`
511 INSERT INTO world_dialogue_trees (revision_id, dialogue_id, tree_blob)
512 VALUES (?, ?, ?)
513 `);
514 for (const tree of rows)
515 { insert.run(toRevisionId, tree.dialogueId, JSON.stringify(tree)); }
516 }
517
518 listQuestDefs (revisionId)
519 {
520 return this.db.prepare(`
521 SELECT quest_id, def_blob FROM world_quest_defs WHERE revision_id = ?
522 `).all(revisionId).map((row) => JSON.parse(row.def_blob));
523 }
524
525 getQuestDef (revisionId, questId)
526 {
527 const row = this.db.prepare(`
528 SELECT def_blob FROM world_quest_defs WHERE revision_id = ? AND quest_id = ?
529 `).get(revisionId, questId);
530 return row ? JSON.parse(row.def_blob) : null;
531 }
532
533 saveQuestDef (revisionId, def)
534 {
535 this.db.prepare(`
536 INSERT INTO world_quest_defs (revision_id, quest_id, def_blob)
537 VALUES (?, ?, ?)
538 ON CONFLICT(revision_id, quest_id) DO UPDATE SET def_blob = excluded.def_blob
539 `).run(revisionId, def.questId, JSON.stringify(def));
540 }
541
542 deleteQuestDef (revisionId, questId)
543 {
544 this.db.prepare(`
545 DELETE FROM world_quest_defs WHERE revision_id = ? AND quest_id = ?
546 `).run(revisionId, questId);
547 }
548
549 listDialogueTrees (revisionId)
550 {
551 return this.db.prepare(`
552 SELECT dialogue_id, tree_blob FROM world_dialogue_trees WHERE revision_id = ?
553 `).all(revisionId).map((row) => JSON.parse(row.tree_blob));
554 }
555
556 getDialogueTree (revisionId, dialogueId)
557 {
558 const row = this.db.prepare(`
559 SELECT tree_blob FROM world_dialogue_trees WHERE revision_id = ? AND dialogue_id = ?
560 `).get(revisionId, dialogueId);
561 return row ? JSON.parse(row.tree_blob) : null;
562 }
563
564 saveDialogueTree (revisionId, tree)
565 {
566 this.db.prepare(`
567 INSERT INTO world_dialogue_trees (revision_id, dialogue_id, tree_blob)
568 VALUES (?, ?, ?)
569 ON CONFLICT(revision_id, dialogue_id) DO UPDATE SET tree_blob = excluded.tree_blob
570 `).run(revisionId, tree.dialogueId, JSON.stringify(tree));
571 }
572
573 deleteDialogueTree (revisionId, dialogueId)
574 {
575 this.db.prepare(`
576 DELETE FROM world_dialogue_trees WHERE revision_id = ? AND dialogue_id = ?
577 `).run(revisionId, dialogueId);
578 }
579
580 saveChunkVersion (chunkX, chunkY, revisionId, open, dataBlob, dimensionId = OVERWORLD_ID)
581 {
582 const dim = normalizeDimensionId(dimensionId);
583 this.db.prepare(`
584 INSERT INTO world_chunk_versions (dimension_id, chunk_x, chunk_y, revision_id, open, data_blob)
585 VALUES (?, ?, ?, ?, ?, ?)
586 ON CONFLICT(dimension_id, chunk_x, chunk_y, revision_id) DO UPDATE SET
587 open = excluded.open,
588 data_blob = excluded.data_blob
589 `).run(dim, chunkX, chunkY, revisionId, open ? 1 : 0, dataBlob);
590 }
591
592 saveSettings (revisionId, settings)
593 {
594 this.db.prepare(`
595 INSERT INTO world_settings (revision_id, settings_blob)
596 VALUES (?, ?)
597 ON CONFLICT(revision_id) DO UPDATE SET settings_blob = excluded.settings_blob
598 `).run(revisionId, JSON.stringify(settings));
599 }
600
601 appendChangelog (chunkX, chunkY, revisionId, editorAdminId, diffEntries, dimensionId = OVERWORLD_ID)
602 {
603 const dim = normalizeDimensionId(dimensionId);
604 this.db.prepare(`
605 INSERT INTO world_chunk_edit_log
606 (dimension_id, chunk_x, chunk_y, revision_id, editor_admin_id, edited_at, diff_entries)
607 VALUES (?, ?, ?, ?, ?, ?, ?)
608 `).run(dim, chunkX, chunkY, revisionId, editorAdminId, Date.now(), JSON.stringify(diffEntries));
609 }
610
611 listChangelog (chunkX, chunkY, dimensionId = OVERWORLD_ID)
612 {
613 const dim = normalizeDimensionId(dimensionId);
614 return this.db.prepare(`
615 SELECT log_id, dimension_id, chunk_x, chunk_y, revision_id, editor_admin_id, edited_at, diff_entries
616 FROM world_chunk_edit_log
617 WHERE dimension_id = ? AND chunk_x = ? AND chunk_y = ?
618 ORDER BY edited_at ASC, log_id ASC
619 `).all(dim, chunkX, chunkY).map((row) => ({
620 ...row,
621 dimensionId: row.dimension_id,
622 diffEntries: JSON.parse(row.diff_entries)
623 }));
624 }
625
626 promotePendingRevision ()
627 {
628 const pendingId = this.getPendingRevisionId();
629 if (!pendingId)
630 { return this.getActiveRevisionId(); }
631
632 return withTransaction(this.db, () =>
633 {
634 const activeId = this.getActiveRevisionId();
635 this.db.prepare("UPDATE world_revisions SET status = 'superseded' WHERE revision_id = ?").run(activeId);
636 this.db.prepare("UPDATE world_revisions SET status = 'active' WHERE revision_id = ?").run(pendingId);
637 this.db.prepare("UPDATE world_meta SET value = ? WHERE key = 'active_revision'").run(pendingId);
638 this.db.exec("UPDATE world_meta SET value = NULL WHERE key = 'pending_revision'");
639 return pendingId;
640 });
641 }
642
643 close ()
644 {
645 this.db.close();
646 }
647}