mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 19:16:08 +00:00
98533f3dbe
The settings for the database were one flat record whose url and pool size
were meaningful only for Postgres, so every reader had to re-check the URL.
They are now a discriminated union per engine (DbEngineSettings): the
Postgres arm carries its URL and a pool size already capped at the ceiling,
and the SQLite arm carries nothing else. The env schema uses the same ceiling
constant, so the boot check and the derivation cannot drift apart.
The engine was resolved from the environment by every caller that needed it
(the lifecycle, the unit of work, the backup adapters), each building its own
instance. The engine is now provided once per container by
DatabaseEngineModule and injected everywhere, so the state an engine keeps
(Postgres's reopen hook) is the same wherever it is used. resolveEngine stays
for the MikroORM CLI config and the DI factory, and nothing else calls it.
The engine's reopen no longer carries a `reopenSwapsConnection` flag. The
engine itself decides what a reopen needs: SQLite closes and reconnects the
ORM's connection before the schema bootstrap (its handle is swapped under
Kysely's cache), and Postgres only migrates, because a restore replaces the
contents of the database the pool already reaches. The Postgres pool is never
closed on a reopen, since ending it waits for connections lent out during the
restore.
The backup ports answer every method the same way. verify() now throws a
DomainError for a refused archive on both engines, and the restore path maps
it back to the same { success: false, error, status } result, so the HTTP
response of a refused restore (status and body) is unchanged. The restore
step that swaps the database and then always reopens it is shared in
nest/backup/database-swap.ts, with the error-description helper in
nest/common, instead of two copies that could drift.
254 lines
12 KiB
TypeScript
254 lines
12 KiB
TypeScript
import { SqliteEngine } from '../../../../src/db/engine/sqlite/sqlite-engine';
|
|
import { InviteTokens } from '../../../../src/db/entities/InviteTokens.entity';
|
|
import type { InviteTokensRepository } from '../../../../src/db/repositories/InviteTokens.repository';
|
|
import { withRequestContext } from '../../../../src/nest/database/request-context';
|
|
import { UnitOfWork } from '../../../../src/nest/database/unit-of-work';
|
|
import { createSnapshotTestDb } from '../../../helpers/db-mock';
|
|
import { createInviteToken, createTrip, createUser } from '../../../helpers/factories';
|
|
import { updateRows } from '../../../helpers/factories/rows';
|
|
import { resetTestDb } from '../../../helpers/test-db';
|
|
import { createTestOrm, type TestOrm } from '../../../helpers/test-orm';
|
|
|
|
import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
const testDb = createSnapshotTestDb();
|
|
let t: TestOrm;
|
|
let invites: InviteTokensRepository;
|
|
|
|
beforeAll(async () => {
|
|
t = await createTestOrm(testDb);
|
|
invites = t.repo(InviteTokens);
|
|
});
|
|
beforeEach(() => {
|
|
resetTestDb(testDb);
|
|
t.clear();
|
|
});
|
|
afterAll(async () => {
|
|
await t.close();
|
|
testDb.close();
|
|
});
|
|
|
|
function rawInvite(id: number): unknown {
|
|
// test-sql-allow: the raw full row is the parity oracle the repository's reads are compared against.
|
|
return testDb.prepare('SELECT * FROM invite_tokens WHERE id = ?').get(id);
|
|
}
|
|
|
|
/**
|
|
* Spies on the ORM connection to capture the raw generated SQL of the one
|
|
* query `fn` runs, the same idiom `Categories.repository.test.ts`'s
|
|
* `withQueryCount` uses for a call-count assertion — here for the query
|
|
* text itself, since `listWithCreatorAndTrip`/`findWithCreatorAndTrip` run
|
|
* with `mapResults: false` and return driver rows, not a QueryBuilder a
|
|
* test could inspect directly (Plan 3b Task 3 review, F4).
|
|
*/
|
|
async function captureSql<T>(fn: () => Promise<T>): Promise<{ value: T; sql: string }> {
|
|
const connection = t.orm.em.getConnection();
|
|
const spy = vi.spyOn(connection, 'execute');
|
|
try {
|
|
const value = await fn();
|
|
const call = spy.mock.calls.find((c) => typeof c[0] === 'string' && c[0].includes('invite_tokens'));
|
|
return { value, sql: (call?.[0] as string | undefined) ?? '' };
|
|
} finally {
|
|
spy.mockRestore();
|
|
}
|
|
}
|
|
|
|
describe('InviteTokensRepository', () => {
|
|
describe('findByToken', () => {
|
|
it('INVREPO-001: a row read through findByToken is the SELECT * row, key for key', async () => {
|
|
const created = createInviteToken(testDb, { token: 'find-me' });
|
|
const row = await invites.findByToken('find-me');
|
|
expect(row).toStrictEqual(rawInvite(created.id));
|
|
});
|
|
|
|
it('INVREPO-002: an unknown token is null', async () => {
|
|
expect(await invites.findByToken('does-not-exist')).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('insertInvite', () => {
|
|
it('INVREPO-003: inserts and returns exactly the row the legacy re-select would return', async () => {
|
|
const { user } = createUser(testDb);
|
|
const row = await invites.insertInvite({
|
|
token: 'insert-me',
|
|
max_uses: 3,
|
|
expires_at: null,
|
|
created_by: user.id,
|
|
});
|
|
expect(row).toStrictEqual(rawInvite(row.id));
|
|
expect(row.token).toBe('insert-me');
|
|
expect(row.max_uses).toBe(3);
|
|
expect(row.used_count).toBe(0);
|
|
expect(row.created_by).toBe(user.id);
|
|
expect(row.trip_id).toBeNull();
|
|
expect(typeof row.created_at).toBe('string');
|
|
});
|
|
|
|
it('INVREPO-004: trip_id is written when given (per-trip invite)', async () => {
|
|
const { user } = createUser(testDb);
|
|
const trip = createTrip(testDb, user.id);
|
|
const row = await invites.insertInvite({
|
|
token: 'trip-bound',
|
|
max_uses: 1,
|
|
expires_at: null,
|
|
created_by: user.id,
|
|
trip_id: trip.id,
|
|
});
|
|
expect(row.trip_id).toBe(trip.id);
|
|
});
|
|
});
|
|
|
|
describe('incrementUsedCount', () => {
|
|
it('INVREPO-005: under capacity — increments and returns the updated row', async () => {
|
|
const created = createInviteToken(testDb, { token: 'under-cap', max_uses: 3 });
|
|
const row = await invites.incrementUsedCount('under-cap');
|
|
expect(row).not.toBeNull();
|
|
expect(row?.used_count).toBe(1);
|
|
expect(row).toStrictEqual(rawInvite(created.id));
|
|
});
|
|
|
|
it('INVREPO-006: at capacity — no row matches, returns null, used_count unchanged', async () => {
|
|
const created = createInviteToken(testDb, { token: 'at-cap', max_uses: 1 });
|
|
await updateRows(t, InviteTokens, { id: created.id }, { used_count: 1 });
|
|
const row = await invites.incrementUsedCount('at-cap');
|
|
expect(row).toBeNull();
|
|
expect((rawInvite(created.id) as { used_count: number }).used_count).toBe(1);
|
|
});
|
|
|
|
it('INVREPO-007: max_uses = 0 means unlimited — always increments', async () => {
|
|
createInviteToken(testDb, { token: 'unlimited', max_uses: 0 });
|
|
await updateRows(t, InviteTokens, { token: 'unlimited' }, { used_count: 500 });
|
|
const row = await invites.incrementUsedCount('unlimited');
|
|
expect(row?.used_count).toBe(501);
|
|
});
|
|
|
|
it('INVREPO-008: an unknown token returns null', async () => {
|
|
expect(await invites.incrementUsedCount('nonexistent-token')).toBeNull();
|
|
});
|
|
|
|
it('INVREPO-009: two concurrent increments on a one-use invite — exactly one wins (D6 single-connection race safety)', async () => {
|
|
const created = createInviteToken(testDb, { token: 'race-me', max_uses: 1 });
|
|
const [a, b] = await Promise.all([invites.incrementUsedCount('race-me'), invites.incrementUsedCount('race-me')]);
|
|
const results = [a, b];
|
|
const winners = results.filter((r) => r !== null);
|
|
const losers = results.filter((r) => r === null);
|
|
expect(winners).toHaveLength(1);
|
|
expect(losers).toHaveLength(1);
|
|
expect(winners[0]?.used_count).toBe(1);
|
|
expect((rawInvite(created.id) as { used_count: number }).used_count).toBe(1);
|
|
});
|
|
});
|
|
|
|
// RI1/RI5 — the admin invite list's joined projection.
|
|
describe('listWithCreatorAndTrip / findWithCreatorAndTrip', () => {
|
|
it("INVREPO-010: projects the creator's username and a bound trip's title, newest first", async () => {
|
|
const { user: admin } = createUser(testDb, { username: 'inviter-1' });
|
|
const trip = createTrip(testDb, admin.id, { title: 'Bound Trip' });
|
|
const older = createInviteToken(testDb, { token: 'older', created_by: admin.id });
|
|
await updateRows(t, InviteTokens, { id: older.id }, { created_at: '2026-01-01 00:00:00' });
|
|
const newer = createInviteToken(testDb, { token: 'newer', created_by: admin.id });
|
|
await updateRows(t, InviteTokens, { id: newer.id }, { created_at: '2026-02-01 00:00:00', trip: trip.id });
|
|
|
|
const rows = await invites.listWithCreatorAndTrip();
|
|
|
|
expect(rows.map((r) => r.token)).toEqual(['newer', 'older']); // ORDER BY created_at DESC
|
|
expect(rows[0]).toMatchObject({
|
|
token: 'newer',
|
|
created_by_name: 'inviter-1',
|
|
trip_title: 'Bound Trip',
|
|
trip_id: trip.id,
|
|
});
|
|
expect(rows[1]).toMatchObject({ token: 'older', created_by_name: 'inviter-1', trip_title: null, trip_id: null });
|
|
});
|
|
|
|
it('INVREPO-011: findWithCreatorAndTrip filters the same projection to one id', async () => {
|
|
const { user: admin } = createUser(testDb, { username: 'inviter-2' });
|
|
const invite = createInviteToken(testDb, { token: 'single', created_by: admin.id });
|
|
|
|
const row = await invites.findWithCreatorAndTrip(invite.id);
|
|
expect(row).toMatchObject({ id: invite.id, token: 'single', created_by_name: 'inviter-2', trip_title: null });
|
|
});
|
|
|
|
it('INVREPO-012: findWithCreatorAndTrip is null for an unknown id', async () => {
|
|
expect(await invites.findWithCreatorAndTrip(999_999)).toBeNull();
|
|
});
|
|
|
|
it("INVREPO-015: the generated SQL joins users with an INNER JOIN and trips with a LEFT JOIN — pins RI1's join TYPE (Plan 3b Task 3 review, F4; a `leftJoin` rewrite of the users join must fail this)", async () => {
|
|
const { user: admin } = createUser(testDb, { username: 'join-type-check' });
|
|
createInviteToken(testDb, { token: 'join-type-check', created_by: admin.id });
|
|
|
|
const { sql } = await captureSql(() => invites.listWithCreatorAndTrip());
|
|
|
|
expect(sql).toMatch(/inner join `?users`?/i);
|
|
expect(sql).toMatch(/left join `?trips`?/i);
|
|
expect(sql).not.toMatch(/left join `?users`?/i);
|
|
});
|
|
|
|
it("INVREPO-016: findWithCreatorAndTrip's generated SQL joins users with an INNER JOIN and trips with a LEFT JOIN — pins RI5's join TYPE (task-3-rereview.md R2; a `leftJoin` rewrite of the users join must fail this)", async () => {
|
|
const { user: admin } = createUser(testDb, { username: 'join-type-check-single' });
|
|
const invite = createInviteToken(testDb, { token: 'join-type-check-single', created_by: admin.id });
|
|
|
|
const { sql } = await captureSql(() => invites.findWithCreatorAndTrip(invite.id));
|
|
|
|
expect(sql).toMatch(/inner join `?users`?/i);
|
|
expect(sql).toMatch(/left join `?trips`?/i);
|
|
expect(sql).not.toMatch(/left join `?users`?/i);
|
|
});
|
|
});
|
|
|
|
// RI6/RI7 — deleteInvite's 404 check and the delete itself.
|
|
describe('findIdById / deleteById', () => {
|
|
it('INVREPO-013: findIdById returns the id for a known row, null otherwise', async () => {
|
|
const invite = createInviteToken(testDb, { token: 'exists' });
|
|
expect(await invites.findIdById(invite.id)).toBe(invite.id);
|
|
expect(await invites.findIdById(999_999)).toBeNull();
|
|
});
|
|
|
|
it('INVREPO-014: deleteById removes exactly that row', async () => {
|
|
const keep = createInviteToken(testDb, { token: 'keep' });
|
|
const gone = createInviteToken(testDb, { token: 'gone' });
|
|
|
|
await invites.deleteById(gone.id);
|
|
|
|
expect(rawInvite(gone.id)).toBeUndefined();
|
|
expect(rawInvite(keep.id)).toBeDefined();
|
|
});
|
|
});
|
|
|
|
// Task 7 review, M2: InviteTokensRepository had no D-shape identity-map
|
|
// test at all, although `findByToken`/`insertInvite`'s own docstrings
|
|
// both cite the disableIdentityMap-not-refresh ruling. The shape: wide
|
|
// findByToken (carries used_count) first, narrow findIdById (`fields:
|
|
// ['id']`, no used_count) second, then a nativeUpdate-equivalent write
|
|
// (incrementUsedCount, via the QueryBuilder) inside uow.transactional —
|
|
// this repository is a Plan-3b-created one on a public, unauthenticated
|
|
// route (GET /api/auth/invite/:token) that also runs inside
|
|
// registerUser's transaction.
|
|
describe('identity-map isolation (D-shape, program RULING)', () => {
|
|
it('INVREPO-017: incrementUsedCount inside uow.transactional is not discarded by a stale entity read earlier under a different projection', async () => {
|
|
const { user: admin } = createUser(testDb, { username: 'invrepo-017-admin' });
|
|
const invite = createInviteToken(testDb, { token: 'invrepo-017', max_uses: 5, created_by: admin.id });
|
|
const uow = new UnitOfWork(t.em, new SqliteEngine());
|
|
|
|
await withRequestContext(t.orm, async () => {
|
|
// Projection A — wide, full row, carries used_count.
|
|
const before = await invites.findByToken('invrepo-017');
|
|
expect(before!.used_count).toBe(0);
|
|
// Projection B — narrow, `fields: ['id']`, no used_count.
|
|
await invites.findIdById(invite.id);
|
|
|
|
await uow.transactional(async () => {
|
|
await invites.incrementUsedCount('invrepo-017');
|
|
});
|
|
});
|
|
|
|
// A column only the wide read carried (`max_uses`) must be unchanged,
|
|
// and the write itself must have stuck.
|
|
const after = await invites.findByToken('invrepo-017');
|
|
expect(after!.used_count).toBe(1);
|
|
expect(after!.max_uses).toBe(5);
|
|
expect((rawInvite(invite.id) as { used_count: number }).used_count).toBe(1);
|
|
});
|
|
});
|
|
});
|