BlueGit

timfa questward

Files

questward / server / src / persistence / worldDb.js

worldDb.js

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