BlueGit

timfa questward

Files

questward / server / src / persistence / worldDb.js

worldDb.js

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