From 61ea6b648c1bdcc18eaf8579857eb80f36052c51 Mon Sep 17 00:00:00 2001 From: Maurice Date: Tue, 17 Nov 2026 14:14:29 +0100 Subject: [PATCH] fix(db): take the write lock in every transaction that writes UnitOfWork took the engine's write lock, but four repositories opened transactions of their own: the demo addon set, the plugin user erasure's savepoints, and the plugin metadata and scheduler cap checks. On Postgres those ran beside the others on the pool. writeTransaction (src/db/engine/write-transaction.ts) is now the one transaction that writes: UnitOfWork wraps it, and the demo seed and reset, which run outside the container, call it with the engine the environment names. The capped plugin writes run in their caller's unit of work instead of a transaction of their own, and the plugin erasure runs in the erasure's transaction without savepoints, since its three tables come with the migrations on both engines. lint:tx counts writeTransaction as a transaction. --- server/scripts/tx-writes.mjs | 8 +++-- server/src/db/engine/write-transaction.ts | 30 +++++++++++++++++++ server/src/db/repositories/DemoRepository.ts | 9 ++++-- .../db/repositories/MaintenanceRepository.ts | 25 +++++++--------- .../PluginEntityMetadata.repository.ts | 27 ++++++++--------- .../PluginScheduledTasks.repository.ts | 24 +++++++-------- server/src/nest/database/unit-of-work.ts | 11 +++---- .../MaintenanceRepository.test.ts | 13 ++++++-- .../plugin-repository-sql-parity.test.ts | 24 ++++++++++----- 9 files changed, 107 insertions(+), 64 deletions(-) create mode 100644 server/src/db/engine/write-transaction.ts diff --git a/server/scripts/tx-writes.mjs b/server/scripts/tx-writes.mjs index 6fa61f65a..2df7e032a 100644 --- a/server/scripts/tx-writes.mjs +++ b/server/scripts/tx-writes.mjs @@ -19,8 +19,8 @@ * A method's "write units" are then counted over its body: * - a call to a write, on a constructor-injected field (`this.trips.x()`) * or on its own class (`this.x()`), is one unit; - * - a `.transactional(...)` call that holds any write is one unit, however - * many writes it holds; + * - a `.transactional(...)` or `writeTransaction(...)` call that holds any + * write is one unit, however many writes it holds; * - a call to a method of another class that is itself reported counts as * one unit here (the fault is reported once, where it lives); * - a write inside a loop, or inside a callback handed to forEach/map/ @@ -343,7 +343,9 @@ export function analyse(classes) { const receiver = ts.isPropertyAccessExpression(callee) ? count(cls, callee.expression, covered) : count(cls, callee, covered); - if (method === 'transactional') { + // `writeTransaction(em, engine, fn)` (src/db/engine/write-transaction.ts) is the + // transaction `UnitOfWork.transactional` opens, for code outside the container. + if (method === 'transactional' || (ts.isIdentifier(callee) && callee.text === 'writeTransaction')) { let inner = 0; frames.push([]); // what runs inside is one unit, not a list of its own for (const arg of node.arguments) inner += count(cls, arg, true); diff --git a/server/src/db/engine/write-transaction.ts b/server/src/db/engine/write-transaction.ts new file mode 100644 index 000000000..22a6cd50b --- /dev/null +++ b/server/src/db/engine/write-transaction.ts @@ -0,0 +1,30 @@ +import type { DatabaseEngine } from './engine'; +import type { EntityManager } from '@mikro-orm/core'; + +/** + * The one way TREK opens a transaction that writes: `em.transactional()` with + * its default `NESTED` propagation (a call inside an open transaction becomes + * a savepoint), whose first statement takes the engine's write lock + * (`DatabaseEngine.serializeWrites`). + * + * On SQLite the lock is free, since one connection already writes one + * transaction at a time. On Postgres a pool runs transactions side by side, + * and without the lock two of them would both read the same `MAX(...) + 1`, + * the same count under a cap or the same "not there yet" before an insert. + * With it, a check read inside the transaction still holds at its write. + * + * `UnitOfWork.transactional` is this for the Nest container; code that runs + * outside it (the demo seed and reset) calls it directly. ESLint + * (`trek/transactions-through-unit-of-work`) refuses any other transaction + * under src/ outside the engine and the boot-time schema files. + */ +export function writeTransaction( + em: EntityManager, + engine: Pick, + fn: (em: EntityManager) => Promise, +): Promise { + return em.transactional(async (tx) => { + await engine.serializeWrites(tx); + return fn(tx); + }); +} diff --git a/server/src/db/repositories/DemoRepository.ts b/server/src/db/repositories/DemoRepository.ts index f8b89576e..5891f774f 100644 --- a/server/src/db/repositories/DemoRepository.ts +++ b/server/src/db/repositories/DemoRepository.ts @@ -1,4 +1,6 @@ import { currentTimestampKysely } from '../dialect/kysely-functions'; +import { resolveEngine } from '../engine'; +import { writeTransaction } from '../engine/write-transaction'; import { Addons } from '../entities/Addons.entity'; import { AppSettings } from '../entities/AppSettings.entity'; import { DocumentProviders } from '../entities/DocumentProviders.entity'; @@ -420,7 +422,10 @@ export class DemoRepository { /** * Writes the demo's addon states in one transaction, so a reset that fails - * halfway does not leave half the shelf switched. One UPDATE per shelf and + * halfway does not leave half the shelf switched. The transaction takes the + * engine's write lock (`writeTransaction`), as a `UnitOfWork` one does: the + * seed and the reset run outside the Nest container, so the engine is the + * one the environment names. One UPDATE per shelf and * state (generic inherited `nativeUpdate` over `id IN (...)`, the statement * `setEnabled` issues for one row) and one upsert for all the switches * (`AppSettingsRepository#setValue`'s), however long the lists are. A named @@ -430,7 +435,7 @@ export class DemoRepository { async applyAddonStates(states: DemoAddonStates): Promise { this.validateRequestContext(); const switches = Object.entries(states.appSettings).map(([key, value]) => ({ key, value })); - await this.em.transactional(async () => { + await writeTransaction(this.em, resolveEngine(), async () => { const addons = this.em.getRepository(Addons); await addons.nativeUpdate({ id: { $in: [...states.addons.on] } }, { enabled: true }); await addons.nativeUpdate({ id: { $in: [...states.addons.off] } }, { enabled: false }); diff --git a/server/src/db/repositories/MaintenanceRepository.ts b/server/src/db/repositories/MaintenanceRepository.ts index f492cfb88..311089770 100644 --- a/server/src/db/repositories/MaintenanceRepository.ts +++ b/server/src/db/repositories/MaintenanceRepository.ts @@ -1,4 +1,3 @@ -import { isMissingTableError } from '../dialect/driver-errors'; import type { EntityManager } from '@mikro-orm/core'; /** @@ -39,24 +38,20 @@ export class MaintenanceRepository { * `plugin_oauth_tokens`, `plugin_oauth_state`), called inside the erasure's * own `UnitOfWork.transactional(...)`. * - * A table that does not exist (a slimmed-down test schema) is skipped; any - * other failure propagates. Each statement runs in its own savepoint, since - * on Postgres a failed statement aborts the whole transaction it is in. - * `em.getTransactionContext()` hands the statement the open transaction's - * connection, which a bare `execute()` would wait on forever. + * The three tables come with the migrations on both engines, so a failure + * here is a real one and propagates, rolling the erasure back. (A table + * missing from a slimmed-down test schema used to be skipped in a savepoint + * of its own; there is no such schema any more, and the savepoint was a + * transaction outside `UnitOfWork`.) `getTransactionContext()` hands the + * statement the open transaction's connection, which a bare `execute()` + * would wait on forever. */ async deletePluginUserData(userId: number): Promise { this.validateRequestContext(); for (const table of ['plugin_user_config', 'plugin_oauth_tokens', 'plugin_oauth_state']) { - try { - await this.em.transactional((em) => - em - .getConnection() - .execute(`DELETE FROM ${table} WHERE user_id = ?`, [userId], 'run', em.getTransactionContext()), - ); - } catch (err: unknown) { - if (!isMissingTableError(err)) throw err; - } + await this.em + .getConnection() + .execute(`DELETE FROM ${table} WHERE user_id = ?`, [userId], 'run', this.em.getTransactionContext()); } } } diff --git a/server/src/db/repositories/PluginEntityMetadata.repository.ts b/server/src/db/repositories/PluginEntityMetadata.repository.ts index 63e487614..63cc05eb4 100644 --- a/server/src/db/repositories/PluginEntityMetadata.repository.ts +++ b/server/src/db/repositories/PluginEntityMetadata.repository.ts @@ -90,12 +90,11 @@ export class PluginEntityMetadataRepository extends TrekRepository { - return this.getEntityManager().transactional(async () => { - const exists = (await this.findValue(pluginId, entityType, entityId, key)) !== null; - if (!exists) { - const n = await this.countForEntity(pluginId, entityType, entityId); - if (n >= maxKeys) return false; - } - await this.upsertValue(pluginId, entityType, entityId, key, value); - return true; - }); + const exists = (await this.findValue(pluginId, entityType, entityId, key)) !== null; + if (!exists) { + const n = await this.countForEntity(pluginId, entityType, entityId); + if (n >= maxKeys) return false; + } + await this.upsertValue(pluginId, entityType, entityId, key, value); + return true; } } diff --git a/server/src/db/repositories/PluginScheduledTasks.repository.ts b/server/src/db/repositories/PluginScheduledTasks.repository.ts index f0c0acc33..e765640a6 100644 --- a/server/src/db/repositories/PluginScheduledTasks.repository.ts +++ b/server/src/db/repositories/PluginScheduledTasks.repository.ts @@ -137,22 +137,20 @@ export class PluginScheduledTasksRepository extends TrekRepository { - return this.getEntityManager().transactional(async () => { - const exists = await this.existsForPluginAndName(input.plugin_id, input.name); - if (!exists) { - const n = await this.countForPlugin(input.plugin_id); - if (n >= maxTasks) return false; - } - await this.upsertTask(input); - return true; - }); + const exists = await this.existsForPluginAndName(input.plugin_id, input.name); + if (!exists) { + const n = await this.countForPlugin(input.plugin_id); + if (n >= maxTasks) return false; + } + await this.upsertTask(input); + return true; } } diff --git a/server/src/nest/database/unit-of-work.ts b/server/src/nest/database/unit-of-work.ts index 1e92efece..d8fe60ae6 100644 --- a/server/src/nest/database/unit-of-work.ts +++ b/server/src/nest/database/unit-of-work.ts @@ -1,4 +1,5 @@ import type { DatabaseEngine } from '../../db/engine'; +import { writeTransaction } from '../../db/engine/write-transaction'; import { DATABASE_ENGINE } from './database-engine.module'; import { EntityManager } from '@mikro-orm/core'; import { Inject, Injectable } from '@nestjs/common'; @@ -23,7 +24,10 @@ import { Inject, Injectable } from '@nestjs/common'; * The services read `MAX(...) + 1` inside these transactions on the strength * of SQLite's single writer. On Postgres a pool of connections would let two * of them read the same MAX, so every transaction first takes the engine's - * write lock (`DatabaseEngine.serializeWrites`), which keeps that guarantee. + * write lock (`DatabaseEngine.serializeWrites`, through `writeTransaction`), + * which keeps that guarantee. No other transaction is opened under src/ + * (ESLint, `trek/transactions-through-unit-of-work`), so a check read + * inside one of these is never raced by a write outside the lock. */ @Injectable() export class UnitOfWork { @@ -33,9 +37,6 @@ export class UnitOfWork { ) {} transactional(fn: () => Promise): Promise { - return this.em.transactional(async (em) => { - await this.engine.serializeWrites(em); - return fn(); - }); + return writeTransaction(this.em, this.engine, () => fn()); } } diff --git a/server/tests/unit/db/repositories/MaintenanceRepository.test.ts b/server/tests/unit/db/repositories/MaintenanceRepository.test.ts index 414b28e96..55e09694d 100644 --- a/server/tests/unit/db/repositories/MaintenanceRepository.test.ts +++ b/server/tests/unit/db/repositories/MaintenanceRepository.test.ts @@ -47,12 +47,19 @@ describe('MaintenanceRepository', () => { } }); - it('MAINTREPO-005: deletePluginUserData skips an absent table and rethrows any other failure', async () => { + it('MAINTREPO-005: deletePluginUserData empties the three plugin tables and rethrows any failure, a missing table included', async () => { const spy = vi.spyOn(t.em.getConnection(), 'execute'); try { - // The first statement is the user_config delete, so the one-shot rejection lands on it. - spy.mockRejectedValueOnce(new TableNotFoundException(new Error('no such table: plugin_user_config'))); await expect(maintenance.deletePluginUserData(1)).resolves.toBeUndefined(); + expect(spy.mock.calls.map((call) => call[0]).filter((sql) => String(sql).startsWith('DELETE'))).toEqual([ + 'DELETE FROM plugin_user_config WHERE user_id = ?', + 'DELETE FROM plugin_oauth_tokens WHERE user_id = ?', + 'DELETE FROM plugin_oauth_state WHERE user_id = ?', + ]); + + // No savepoint swallows it: the erasure's transaction rolls back instead. + spy.mockRejectedValueOnce(new TableNotFoundException(new Error('no such table: plugin_user_config'))); + await expect(maintenance.deletePluginUserData(1)).rejects.toThrow('no such table'); spy.mockRejectedValueOnce(new Error('connection lost')); await expect(maintenance.deletePluginUserData(1)).rejects.toThrow('connection lost'); diff --git a/server/tests/unit/plugins/plugin-repository-sql-parity.test.ts b/server/tests/unit/plugins/plugin-repository-sql-parity.test.ts index 029b7b2cc..83df2f1cb 100644 --- a/server/tests/unit/plugins/plugin-repository-sql-parity.test.ts +++ b/server/tests/unit/plugins/plugin-repository-sql-parity.test.ts @@ -12,12 +12,14 @@ * (`existsById` ignored) from the review's mutation table, none of which any other * suite killed. */ +import { SqliteEngine } from '../../../src/db/engine/sqlite/sqlite-engine'; import { Days } from '../../../src/db/entities/Days.entity'; import { PluginEntityMetadata } from '../../../src/db/entities/PluginEntityMetadata.entity'; import { PluginScheduledTasks } from '../../../src/db/entities/PluginScheduledTasks.entity'; import { TripMembers } from '../../../src/db/entities/TripMembers.entity'; import { Trips } from '../../../src/db/entities/Trips.entity'; import { Users } from '../../../src/db/entities/Users.entity'; +import { UnitOfWork } from '../../../src/nest/database/unit-of-work'; import { createSnapshotTestDb } from '../../helpers/db-mock'; import { countRows, findRow, findRows, insertRow, updateRows } from '../../helpers/factories/rows'; import { resetTestDb } from '../../helpers/test-db'; @@ -218,13 +220,15 @@ describe('R3J-PARITY (Plan 3j Task 7 fix wave, must-land 4c)', () => { it('must-land 2: 130 concurrent PluginEntityMetadata.upsertValueCapped calls for the SAME (plugin, entity), 130 DIFFERENT new keys, never exceed the 100 cap', async () => { // The REAL repository method, raced through Promise.all — not a sequential loop — // so the exists+count+write really overlaps (task-7-review.md: live, 130 rows landed - // on a 100 cap before this fix). Red without `upsertValueCapped`'s - // `getEntityManager().transactional` wrap: the old three-separately-awaited-calls - // shape let every racer's stale `count < 100` read pass before any of their writes - // landed. + // on a 100 cap before this fix). Each call runs in a unit of work, as `MetaRpc#set` + // runs it: the three-separately-awaited-calls shape outside one let every racer's + // stale `count < 100` read pass before any of their writes landed. const repo = t.repo(PluginEntityMetadata); + const uow = new UnitOfWork(t.em, new SqliteEngine()); const results = await Promise.all( - Array.from({ length: 130 }, (_, i) => repo.upsertValueCapped('capbomb', 'trip', 1, `k${i}`, String(i), 100)), + Array.from({ length: 130 }, (_, i) => + uow.transactional(() => repo.upsertValueCapped('capbomb', 'trip', 1, `k${i}`, String(i), 100)), + ), ); expect(results.filter(Boolean).length).toBe(100); // exactly 100 writes accepted expect(await repo.countForEntity('capbomb', 'trip', 1)).toBe(100); // never more than 100 rows @@ -232,13 +236,17 @@ describe('R3J-PARITY (Plan 3j Task 7 fix wave, must-land 4c)', () => { }); it('must-land 3: 130 concurrent PluginScheduledTasks.upsertTaskCapped calls for the SAME plugin, 130 DIFFERENT new names, never exceed the 100 cap', async () => { + // In a unit of work, as `HostSurfaceRpc#schedulerSet` runs it. const repo = t.repo(PluginScheduledTasks); + const uow = new UnitOfWork(t.em, new SqliteEngine()); const due = Date.now() + 60_000; const results = await Promise.all( Array.from({ length: 130 }, (_, i) => - repo.upsertTaskCapped( - { plugin_id: 'schedbomb', name: `t${i}`, due_at: due, payload: '1', every_ms: null }, - 100, + uow.transactional(() => + repo.upsertTaskCapped( + { plugin_id: 'schedbomb', name: `t${i}`, due_at: due, payload: '1', every_ms: null }, + 100, + ), ), ), );