@chaos-overlords/storage 0.8.1 → 0.9.0

package/dist/sqlite/repositories.js

@@ -1,7 +1,9 @@
-import { and, asc, desc, eq, exists, inArray, isNotNull, isNull, lt, lte, ne, notExists, or, sql, } from 'drizzle-orm';
-import { APPEND_ATTEMPTS, insertUnlessTaken, isUniqueViolation } from '../shared/constraints';
-import { firstOrNull, toEvent, toMatch, toMatchInsert, toPlayer, toSnapshot, toSnapshotSummary, toTakeoverVote, toTurn, toTurnOrders, toTurnReport, } from '../shared/mappers';
+import { and, asc, desc, eq, exists, gte, inArray, isNotNull, isNull, lt, lte, ne, notExists, or, sql, } from 'drizzle-orm';
+import { insertUnlessTaken } from '../shared/constraints';
+import { firstOrNull, toMatch, toMatchInsert, toPlayer, toPublicLobbyRow, toSnapshot, toSnapshotSummary, toTurn, toTurnOrders, toTurnReport, } from '../shared/mappers';
+import { sqliteEventRepository } from './events';
 import * as schema from './schema';
+import { sqliteTakeoverRepository } from './takeovers';
 export function createSqliteStorage(db) {
     return {
         matches: sqliteMatchRepository(db),
@@ -13,7 +15,15 @@ export function createSqliteStorage(db) {
     };
 }
 function sqliteMatchRepository(db) {
-    const { matches, players } = schema;
+    const { matches, players, snapshots } = schema;
+    // Children cascade from the match row, so one delete takes the whole match with it.
+    const deleteCollectable = async (collectable) => {
+        const rows = await db
+            .delete(matches)
+            .where(inArray(matches.id, collectable))
+            .returning({ id: matches.id });
+        return rows.length;
+    };
     return {
         async create(match) {
             return insertUnlessTaken(() => db.insert(matches).values(toMatchInsert(match)));
@@ -24,34 +34,45 @@ function sqliteMatchRepository(db) {
         async getByJoinCode(joinCode) {
             return firstOrNull((await db.select().from(matches).where(eq(matches.joinCode, joinCode))).map(toMatch));
         },
+        /**
+         * One statement for the whole listing. The human-seat count and the existence of a snapshot
+         * are correlated subselects rather than a read per listed match: the route is unauthenticated,
+         * and two extra queries per running match is the cost an anonymous caller could ask for
+         * thirty times a minute. A running match no human holds a seat in is left out, which is the
+         * same test `joinRunning` refuses on: a match everyone has left is paused, so joining one is
+         * a seat at a table whose clock is stopped.
+         *
+         * A seat counts as human while it is `takeoverPending` as well as while it is `active`. That
+         * status is a player who missed one deadline, not one who is gone — `humanParticipants` waits
+         * on them and the takeover vote is what decides otherwise — so counting only `active` hid
+         * live matches from the listing and understated the players in the ones it kept.
+         */
         async listPublicLobbies(limit) {
+            const humanSeats = sql `(select count(*) from ${players} where ${players.matchId} = ${matches.id} and ${players.status} in ('active', 'takeoverPending'))`;
             const rows = await db
                 .select({
                 id: matches.id,
                 joinCode: matches.joinCode,
                 name: matches.name,
                 hostDisplayName: players.displayName,
-                playerCount: matches.seatCount,
+                seatCount: matches.seatCount,
+                humanCount: humanSeats,
                 maxPlayers: matches.maxPlayers,
                 passwordHash: matches.passwordHash,
                 status: matches.status,
                 settings: matches.settings,
                 createdAt: matches.createdAt,
+                hasSnapshot: exists(db
+                    .select({ one: sql `1` })
+                    .from(snapshots)
+                    .where(eq(snapshots.matchId, matches.id))),
             })
                 .from(matches)
                 .innerJoin(players, eq(players.id, matches.hostPlayerId))
-                .where(and(inArray(matches.status, ['lobby', 'running']), eq(matches.visibility, 'public')))
+                .where(and(inArray(matches.status, ['lobby', 'running']), eq(matches.visibility, 'public'), or(ne(matches.status, 'running'), sql `${humanSeats} > 0`)))
                 .orderBy(desc(matches.createdAt), asc(matches.id))
                 .limit(limit);
-            return rows.map(({ passwordHash, createdAt, ...rest }) => ({
-                ...rest,
-                status: rest.status,
-                settings: rest.settings,
-                availableSlots: [],
-                availableSeatSummaries: [],
-                passwordProtected: passwordHash !== null,
-                createdAt: createdAt.toISOString(),
-            }));
+            return rows.map(toPublicLobbyRow);
         },
         async claimSeat(matchId) {
             const rows = await db
@@ -102,32 +123,33 @@ function sqliteMatchRepository(db) {
                 .from(matches)
                 .where(and(inArray(matches.status, [...statuses]), lt(matches.updatedAt, before)))
                 .limit(limit);
-            // Children cascade from the match row, so one delete takes the whole match with it.
-            const rows = await db
-                .delete(matches)
-                .where(inArray(matches.id, collectable))
-                .returning({ id: matches.id });
-            return rows.length;
+            return deleteCollectable(collectable);
         },
         /**
          * The same delete, aimed at a live match nobody is in any more. The roster test is a
          * `not exists` over the players rather than a count: one active row is enough to spare the
          * match, and asking whether any exists stops at the first.
          */
-        async deleteAbandonedLive(before, limit) {
+        async deleteAbandonedLive(before, limit, requireEmptyRoster) {
+            const emptyRoster = notExists(db
+                .select({ one: sql `1` })
+                .from(players)
+                .where(and(eq(players.matchId, matches.id), eq(players.status, 'active'))));
             const collectable = db
                 .select({ id: matches.id })
                 .from(matches)
-                .where(and(inArray(matches.status, ['running', 'desynced']), lt(matches.updatedAt, before), notExists(db
-                .select({ one: sql `1` })
-                .from(players)
-                .where(and(eq(players.matchId, matches.id), eq(players.status, 'active'))))))
+                .where(and(inArray(matches.status, ['running', 'desynced']), lt(matches.updatedAt, before), ...(requireEmptyRoster ? [emptyRoster] : [])))
                 .limit(limit);
+            return deleteCollectable(collectable);
+        },
+        async listDesynced(limit, touchedSince) {
             const rows = await db
-                .delete(matches)
-                .where(inArray(matches.id, collectable))
-                .returning({ id: matches.id });
-            return rows.length;
+                .select({ id: matches.id })
+                .from(matches)
+                .where(and(eq(matches.status, 'desynced'), ...(touchedSince ? [gte(matches.updatedAt, touchedSince)] : [])))
+                .orderBy(matches.updatedAt)
+                .limit(limit);
+            return rows.map((row) => row.id);
         },
         async transition(matchId, from, patch) {
             const rows = await db
@@ -139,6 +161,28 @@ function sqliteMatchRepository(db) {
         },
     };
 }
+/**
+ * The select list `create` and `createLate` feed their insert from: the player's own values, each
+ * under the column name it is inserted as.
+ *
+ * The list is written out, which means it does NOT get Drizzle's column mapping: a column added to
+ * `players` later has to be added here too, in the storage form the column expects. The
+ * conformance suite compares a created player against its fixture field by field, so a dropped
+ * column fails there rather than going unnoticed.
+ */
+function playerValues(player) {
+    return {
+        id: sql `${player.id}`.as('id'),
+        matchId: sql `${player.matchId}`.as('match_id'),
+        slot: sql `${player.slot}`.as('slot'),
+        joinOrder: sql `${player.joinOrder}`.as('join_order'),
+        displayName: sql `${player.displayName}`.as('display_name'),
+        portraitId: sql `${player.portraitId}`.as('portrait_id'),
+        tokenHash: sql `${player.tokenHash}`.as('token_hash'),
+        status: sql `${player.status}`.as('status'),
+        joinedAt: sql `${player.joinedAt.getTime()}`.as('joined_at'),
+    };
+}
 function sqlitePlayerRepository(db) {
     const { matches, players } = schema;
     return {
@@ -147,27 +191,12 @@ function sqlitePlayerRepository(db) {
          * by the same statement that writes the player. The seat counter was claimed a moment earlier
          * and the match may have started since; without this the player would land in a running match
          * that had already seated its roster, holding a seat nobody can play.
-         *
-         * The select list is written out, which means it does NOT get Drizzle's column mapping: a
-         * column added to `players` later has to be added here too, in the storage form the column
-         * expects. The conformance suite compares a created player against its fixture field by field,
-         * so a dropped column fails there rather than going unnoticed.
          */
         async create(player) {
             const rows = await db
                 .insert(players)
                 .select(db
-                .select({
-                id: sql `${player.id}`.as('id'),
-                matchId: sql `${player.matchId}`.as('match_id'),
-                slot: sql `${player.slot}`.as('slot'),
-                joinOrder: sql `${player.joinOrder}`.as('join_order'),
-                displayName: sql `${player.displayName}`.as('display_name'),
-                portraitId: sql `${player.portraitId}`.as('portrait_id'),
-                tokenHash: sql `${player.tokenHash}`.as('token_hash'),
-                status: sql `${player.status}`.as('status'),
-                joinedAt: sql `${player.joinedAt.getTime()}`.as('joined_at'),
-            })
+                .select(playerValues(player))
                 .from(matches)
                 .where(and(eq(matches.id, player.matchId), eq(matches.status, 'lobby'))))
                 .returning({ id: players.id });
@@ -181,19 +210,13 @@ function sqlitePlayerRepository(db) {
             const rows = await db
                 .insert(players)
                 .select(db
-                .select({
-                id: sql `${player.id}`.as('id'),
-                matchId: sql `${player.matchId}`.as('match_id'),
-                slot: sql `${player.slot}`.as('slot'),
-                joinOrder: sql `${player.joinOrder}`.as('join_order'),
-                displayName: sql `${player.displayName}`.as('display_name'),
-                portraitId: sql `${player.portraitId}`.as('portrait_id'),
-                tokenHash: sql `${player.tokenHash}`.as('token_hash'),
-                status: sql `${player.status}`.as('status'),
-                joinedAt: sql `${player.joinedAt.getTime()}`.as('joined_at'),
-            })
+                .select(playerValues(player))
                 .from(matches)
-                .where(and(eq(matches.id, player.matchId), eq(matches.status, 'running'), notExists(occupied))))
+                .where(and(eq(matches.id, player.matchId), eq(matches.status, 'running'), notExists(occupied), 
+            // Capacity in the same statement as the insert. Two late joiners for two different
+            // free slots each passed a capacity check taken a moment before the other's insert,
+            // and the match ended up holding more players than `maxPlayers`.
+            sql `(select count(*) from ${players} where ${players.matchId} = ${player.matchId}) < ${matches.maxPlayers}`)))
                 .onConflictDoNothing()
                 .returning({ id: players.id });
             return rows.length === 1;
@@ -212,6 +235,14 @@ function sqlitePlayerRepository(db) {
                 .orderBy(asc(players.slot), asc(players.joinOrder), asc(players.id));
             return rows.map(toPlayer);
         },
+        async listSeats(matchIds) {
+            if (matchIds.length === 0)
+                return [];
+            return db
+                .select({ matchId: players.matchId, slot: players.slot })
+                .from(players)
+                .where(inArray(players.matchId, [...matchIds]));
+        },
         async setStatus(playerId, status) {
             await db.update(players).set({ status }).where(eq(players.id, playerId));
         },
@@ -238,32 +269,29 @@ function sqlitePlayerRepository(db) {
                 .where(inArray(players.id, assignments.map(({ playerId }) => playerId)));
         },
         async delete(playerId) {
-            await db.delete(players).where(eq(players.id, playerId));
+            const rows = await db
+                .delete(players)
+                .where(eq(players.id, playerId))
+                .returning({ id: players.id });
+            return rows.length === 1;
         },
     };
 }
-function sqliteTurnRepository(db) {
-    const { matches, turns, turnOrders, turnReports } = schema;
+/**
+ * The orders half of the turn repository: one player's row, the whole set, and the
+ * projection that reads a turn's readiness and digests without the documents. Split out of
+ * the repository so neither half grows past what fits on a screen.
+ */
+function sqliteTurnOrderMethods(db) {
+    const { turns, turnOrders } = schema;
+    const orderSummaryColumns = {
+        matchId: turnOrders.matchId,
+        turn: turnOrders.turn,
+        playerId: turnOrders.playerId,
+        ordersHash: turnOrders.ordersHash,
+        ready: turnOrders.ready,
+    };
     return {
-        async open(turn, playerIds) {
-            const created = await insertUnlessTaken(() => db.insert(turns).values(turn));
-            if (playerIds.length > 0) {
-                // Topped up rather than assumed: a re-run of the open step (a repaired seal) fills any row
-                // an interrupted one never wrote, and a player who already has a row keeps it untouched.
-                await db
-                    .insert(turnOrders)
-                    .values(playerIds.map((playerId) => ({ matchId: turn.matchId, turn: turn.number, playerId })))
-                    .onConflictDoNothing();
-            }
-            return created;
-        },
-        async get(matchId, number) {
-            const rows = await db
-                .select()
-                .from(turns)
-                .where(and(eq(turns.matchId, matchId), eq(turns.number, number)));
-            return firstOrNull(rows.map(toTurn));
-        },
         async submitOrders(matchId, number, playerId, submission) {
             const turnIsOpen = exists(db
                 .select({ one: sql `1` })
@@ -283,6 +311,13 @@ function sqliteTurnRepository(db) {
                 .where(and(eq(turnOrders.matchId, matchId), eq(turnOrders.turn, number), eq(turnOrders.playerId, playerId)));
             return firstOrNull(rows.map(toTurnOrders));
         },
+        async getOrderSummary(matchId, number, playerId) {
+            const rows = await db
+                .select(orderSummaryColumns)
+                .from(turnOrders)
+                .where(and(eq(turnOrders.matchId, matchId), eq(turnOrders.turn, number), eq(turnOrders.playerId, playerId)));
+            return firstOrNull(rows);
+        },
         async listOrders(matchId, number) {
             const rows = await db
                 .select()
@@ -293,17 +328,36 @@ function sqliteTurnRepository(db) {
         },
         async listOrderSummaries(matchId, number) {
             return db
-                .select({
-                matchId: turnOrders.matchId,
-                turn: turnOrders.turn,
-                playerId: turnOrders.playerId,
-                ordersHash: turnOrders.ordersHash,
-                ready: turnOrders.ready,
-            })
+                .select(orderSummaryColumns)
                 .from(turnOrders)
                 .where(and(eq(turnOrders.matchId, matchId), eq(turnOrders.turn, number)))
                 .orderBy(asc(turnOrders.playerId));
         },
+    };
+}
+function sqliteTurnRepository(db) {
+    const { matches, turns, turnOrders, turnReports } = schema;
+    return {
+        ...sqliteTurnOrderMethods(db),
+        async open(turn, playerIds) {
+            const created = await insertUnlessTaken(() => db.insert(turns).values(turn));
+            if (playerIds.length > 0) {
+                // Topped up rather than assumed: a re-run of the open step (a repaired seal) fills any row
+                // an interrupted one never wrote, and a player who already has a row keeps it untouched.
+                await db
+                    .insert(turnOrders)
+                    .values(playerIds.map((playerId) => ({ matchId: turn.matchId, turn: turn.number, playerId })))
+                    .onConflictDoNothing();
+            }
+            return created;
+        },
+        async get(matchId, number) {
+            const rows = await db
+                .select()
+                .from(turns)
+                .where(and(eq(turns.matchId, matchId), eq(turns.number, number)));
+            return firstOrNull(rows.map(toTurn));
+        },
         async transition(matchId, number, from, patch) {
             const rows = await db
                 .update(turns)
@@ -312,6 +366,25 @@ function sqliteTurnRepository(db) {
                 .returning({ number: turns.number });
             return rows.length === 1;
         },
+        async freezeSeal(matchId, number, frozen) {
+            const rows = await db
+                .update(turns)
+                .set(frozen)
+                .where(and(eq(turns.matchId, matchId), eq(turns.number, number), ne(turns.status, 'open'), 
+            // The compare-and-swap is on what is being frozen, not on the status: the status is
+            // `sealed` for the whole window two callers can be computing a set in.
+            isNull(turns.orderSetHash)))
+                .returning({ number: turns.number });
+            return rows.length === 1;
+        },
+        async claimDesyncAnnouncement(matchId, number, at) {
+            const rows = await db
+                .update(turns)
+                .set({ desyncedAt: at })
+                .where(and(eq(turns.matchId, matchId), eq(turns.number, number), eq(turns.status, 'desynced'), isNull(turns.desyncedAt)))
+                .returning({ number: turns.number });
+            return rows.length === 1;
+        },
         async rescheduleDeadline(matchId, number, deadlineAt) {
             const rows = await db
                 .update(turns)
@@ -320,10 +393,25 @@ function sqliteTurnRepository(db) {
                 .returning({ number: turns.number });
             return rows.length === 1;
         },
+        /**
+         * An insert fed by a select over the turn row, so "the turn is still unsettled" is tested by
+         * the same statement that writes the report; the conflict clause makes it a replacement of the
+         * player's earlier one.
+         */
         async upsertReport(report) {
-            await db
+            const rows = await db
                 .insert(turnReports)
-                .values(report)
+                .select(db
+                .select({
+                matchId: sql `${report.matchId}`.as('match_id'),
+                turn: sql `${report.turn}`.as('turn'),
+                playerId: sql `${report.playerId}`.as('player_id'),
+                stateHash: sql `${report.stateHash}`.as('state_hash'),
+                finished: sql `${report.finished ? 1 : 0}`.as('finished'),
+                reportedAt: sql `${report.reportedAt.getTime()}`.as('reported_at'),
+            })
+                .from(turns)
+                .where(and(eq(turns.matchId, report.matchId), eq(turns.number, report.turn), inArray(turns.status, ['sealed', 'desynced']))))
                 .onConflictDoUpdate({
                 target: [turnReports.matchId, turnReports.turn, turnReports.playerId],
                 set: {
@@ -331,7 +419,9 @@ function sqliteTurnRepository(db) {
                     finished: report.finished,
                     reportedAt: report.reportedAt,
                 },
-            });
+            })
+                .returning({ playerId: turnReports.playerId });
+            return rows.length === 1;
         },
         async listReports(matchId, number) {
             const rows = await db
@@ -353,7 +443,11 @@ function sqliteTurnRepository(db) {
             return db
                 .select({ matchId: turns.matchId, number: turns.number })
                 .from(turns)
-                .where(and(eq(turns.status, 'open'), isNotNull(turns.deadlineAt), lte(turns.deadlineAt, now)))
+                .innerJoin(matches, eq(matches.id, turns.matchId))
+                .where(and(eq(turns.status, 'open'), isNotNull(turns.deadlineAt), lte(turns.deadlineAt, now), 
+            // Only a running match can seal. A desynced one keeps its expired deadline for the
+            // whole pause and would otherwise squat at the head of this page.
+            eq(matches.status, 'running')))
                 .orderBy(asc(turns.deadlineAt))
                 .limit(limit);
         },
@@ -362,19 +456,31 @@ function sqliteTurnRepository(db) {
          * `start` that died before opening turn 1) is as stalled as one whose seal stopped halfway,
          * and an inner join would never see it. The repair opens the successor in both cases.
          */
-        async listStalledSeals(limit) {
-            return db
+        async listStalledSeals(limit, touchedSince) {
+            return (db
                 .select({ matchId: matches.id, number: matches.currentTurn })
                 .from(matches)
                 .leftJoin(turns, and(eq(turns.matchId, matches.id), eq(turns.number, matches.currentTurn)))
-                .where(and(inArray(matches.status, ['running', 'desynced']), or(isNull(turns.status), ne(turns.status, 'open'))))
-                .orderBy(asc(matches.id))
-                .limit(limit);
+                .where(and(inArray(matches.status, ['running', 'desynced']), or(isNull(turns.status), ne(turns.status, 'open')), ...(touchedSince ? [gte(matches.updatedAt, touchedSince)] : [])))
+                // Ordered by the recency the window is taken on, so a match that keeps throwing cannot pin
+                // the head of the page and hide every other stall behind it.
+                .orderBy(desc(matches.updatedAt), asc(matches.id))
+                .limit(limit));
         },
     };
 }
 function sqliteSnapshotRepository(db) {
     const { snapshots } = schema;
+    const snapshotSummaryColumns = {
+        matchId: snapshots.matchId,
+        turn: snapshots.turn,
+        formatVersion: snapshots.formatVersion,
+        protocolVersion: snapshots.protocolVersion,
+        sessionVersion: snapshots.sessionVersion,
+        stateHash: snapshots.stateHash,
+        uploadedByPlayerId: snapshots.uploadedByPlayerId,
+        uploadedAt: snapshots.uploadedAt,
+    };
     return {
         async put(snapshot) {
             await db
@@ -384,6 +490,10 @@ function sqliteSnapshotRepository(db) {
                 target: [snapshots.matchId, snapshots.turn],
                 set: {
                     formatVersion: snapshot.formatVersion,
+                    // Re-uploading a turn replaces the bytes, so the versions they were written under have
+                    // to move with them; leaving them behind described the new body with the old client's.
+                    protocolVersion: snapshot.protocolVersion,
+                    sessionVersion: snapshot.sessionVersion,
                     stateHash: snapshot.stateHash,
                     uploadedByPlayerId: snapshot.uploadedByPlayerId,
                     uploadedAt: snapshot.uploadedAt,
@@ -398,6 +508,13 @@ function sqliteSnapshotRepository(db) {
                 .where(and(eq(snapshots.matchId, matchId), eq(snapshots.turn, turn)));
             return firstOrNull(rows.map(toSnapshot));
         },
+        async getSummary(matchId, turn) {
+            const rows = await db
+                .select(snapshotSummaryColumns)
+                .from(snapshots)
+                .where(and(eq(snapshots.matchId, matchId), eq(snapshots.turn, turn)));
+            return firstOrNull(rows.map(toSnapshotSummary));
+        },
         async getLatest(matchId) {
             const rows = await db
                 .select()
@@ -409,16 +526,7 @@ function sqliteSnapshotRepository(db) {
         },
         async getLatestSummary(matchId) {
             const rows = await db
-                .select({
-                matchId: snapshots.matchId,
-                turn: snapshots.turn,
-                formatVersion: snapshots.formatVersion,
-                protocolVersion: snapshots.protocolVersion,
-                sessionVersion: snapshots.sessionVersion,
-                stateHash: snapshots.stateHash,
-                uploadedByPlayerId: snapshots.uploadedByPlayerId,
-                uploadedAt: snapshots.uploadedAt,
-            })
+                .select(snapshotSummaryColumns)
                 .from(snapshots)
                 .where(eq(snapshots.matchId, matchId))
                 .orderBy(desc(snapshots.turn))
@@ -444,135 +552,4 @@ function sqliteSnapshotRepository(db) {
         },
     };
 }
-function sqliteTakeoverRepository(db) {
-    const { takeoverPrompts, takeoverVotes } = schema;
-    return {
-        async openPrompt(matchId, playerId, turn, openedAt) {
-            const rows = await db
-                .insert(takeoverPrompts)
-                .values({ matchId, playerId, turn, openedAt })
-                .onConflictDoNothing()
-                .returning({ playerId: takeoverPrompts.playerId });
-            return rows.length === 1;
-        },
-        async closePrompt(matchId, playerId) {
-            // Votes first: a death between the two leaves an open prompt with no votes, which is the
-            // safe state, rather than votes that a later prompt for the same seat would inherit.
-            await db
-                .delete(takeoverVotes)
-                .where(and(eq(takeoverVotes.matchId, matchId), eq(takeoverVotes.targetPlayerId, playerId)));
-            await db
-                .delete(takeoverPrompts)
-                .where(and(eq(takeoverPrompts.matchId, matchId), eq(takeoverPrompts.playerId, playerId)));
-        },
-        async hasOpenPrompts(matchId) {
-            const rows = await db
-                .select({ playerId: takeoverPrompts.playerId })
-                .from(takeoverPrompts)
-                .where(eq(takeoverPrompts.matchId, matchId))
-                .limit(1);
-            return rows.length > 0;
-        },
-        async listOpenPrompts(matchId) {
-            const rows = await db
-                .select({ playerId: takeoverPrompts.playerId })
-                .from(takeoverPrompts)
-                .where(eq(takeoverPrompts.matchId, matchId))
-                .orderBy(asc(takeoverPrompts.playerId));
-            return rows.map((row) => row.playerId);
-        },
-        /**
-         * An insert fed by a select over the prompt row, so "the prompt is open" is tested by the same
-         * statement that writes the vote; the conflict clause makes it a replacement of the voter's
-         * earlier choice.
-         */
-        async castVote(matchId, targetPlayerId, voterPlayerId, decision, castAt) {
-            const rows = await db
-                .insert(takeoverVotes)
-                .select(db
-                .select({
-                matchId: sql `${matchId}`.as('match_id'),
-                targetPlayerId: sql `${targetPlayerId}`.as('target_player_id'),
-                voterPlayerId: sql `${voterPlayerId}`.as('voter_player_id'),
-                decision: sql `${decision}`.as('decision'),
-                castAt: sql `${castAt.getTime()}`.as('cast_at'),
-            })
-                .from(takeoverPrompts)
-                .where(and(eq(takeoverPrompts.matchId, matchId), eq(takeoverPrompts.playerId, targetPlayerId))))
-                .onConflictDoUpdate({
-                target: [
-                    takeoverVotes.matchId,
-                    takeoverVotes.targetPlayerId,
-                    takeoverVotes.voterPlayerId,
-                ],
-                set: { decision, castAt },
-            })
-                .returning({ voterPlayerId: takeoverVotes.voterPlayerId });
-            return rows.length === 1;
-        },
-        async listVotes(matchId, targetPlayerId) {
-            const rows = await db
-                .select()
-                .from(takeoverVotes)
-                .where(and(eq(takeoverVotes.matchId, matchId), eq(takeoverVotes.targetPlayerId, targetPlayerId)))
-                .orderBy(asc(takeoverVotes.voterPlayerId));
-            return rows.map(toTakeoverVote);
-        },
-    };
-}
-function sqliteEventRepository(db) {
-    const { matchEvents } = schema;
-    return {
-        /**
-         * The sequence number comes from the log itself inside the insert, so the allocation cannot be
-         * separated from the write: a committed `seq` therefore implies every lower one is committed,
-         * which is the invariant a stream cursor relies on. Concurrent appends collide on the primary
-         * key and the loser simply re-reads the maximum.
-         */
-        async append(event) {
-            const nextSeq = sql `(select coalesce(max(${matchEvents.seq}), 0) + 1 from ${matchEvents} where ${eq(matchEvents.matchId, event.matchId)})`;
-            for (let attempt = 1; attempt <= APPEND_ATTEMPTS; attempt += 1) {
-                try {
-                    const rows = await db
-                        .insert(matchEvents)
-                        .values({
-                        matchId: event.matchId,
-                        seq: nextSeq,
-                        type: event.type,
-                        payload: event.payload,
-                        createdAt: new Date(event.createdAt),
-                    })
-                        .returning({ seq: matchEvents.seq });
-                    const row = rows[0];
-                    if (!row)
-                        throw new Error(`append to ${event.matchId} reported no row`);
-                    return { ...event, seq: row.seq };
-                }
-                catch (error) {
-                    if (!isUniqueViolation(error) || attempt === APPEND_ATTEMPTS)
-                        throw error;
-                }
-            }
-            throw new Error(`could not append an event for ${event.matchId}`);
-        },
-        async listAfter(matchId, afterSeq, limit) {
-            const rows = await db
-                .select()
-                .from(matchEvents)
-                .where(and(eq(matchEvents.matchId, matchId), sql `${matchEvents.seq} > ${afterSeq}`))
-                .orderBy(asc(matchEvents.seq))
-                .limit(limit);
-            return rows.map(toEvent);
-        },
-        async lastSeq(matchId) {
-            const rows = await db
-                .select({ seq: matchEvents.seq })
-                .from(matchEvents)
-                .where(eq(matchEvents.matchId, matchId))
-                .orderBy(desc(matchEvents.seq))
-                .limit(1);
-            return rows[0]?.seq ?? 0;
-        },
-    };
-}
 //# sourceMappingURL=repositories.js.map