Files
TREK/server/tests/unit/db/engine/engine.test.ts
T
Isaias Tavares a77705984e feat(db): create and migrate the schema on a Postgres database
With TREK_DB_URL set, TREK now boots on Postgres; without it nothing changes.

- The database engine contract gains open, close, reopen and the schema
  bootstrap; DatabaseLifecycle delegates to the engine resolveEngine() picks.
- An empty Postgres database gets server/assets/postgres/baseline.sql
  (generated from the entities by gen:pg-baseline, with the reference rows
  the migrations up to its cut insert: tour types, provider catalogues,
  addons, app settings) and every migration up to its cut recorded as
  executed, in one transaction. A database holding tables
  without TREK's history is refused before anything is written; a migrated one
  runs the newer-database refusal and its pending migrations, which refuse
  without a copy unless TREK_DB_PRE_MIGRATE_SNAPSHOT=false.
- INTEGER columns are bigint on Postgres (SQLite's INTEGER is 64-bit: an
  epoch-millisecond column overflowed int4), and the engine's driver reads
  bigint and numeric back as numbers, refusing values past 2^53.
- The two SQLite triggers are ported to PL/pgSQL; check:pg-baseline fails
  while a SQLite trigger has no port, and while the baseline drifts from the
  entities before a later migration freezes it.
- Backups and restores on Postgres refuse until they can dump and load one.
- Migration helpers read the catalog per engine (dialect/catalog.ts), and
  the email case index no longer needs group_concat.
- CI runs check:pg-baseline and boots the image on postgres:17 twice.
2026-11-04 22:45:02 -03:00

117 lines
5.7 KiB
TypeScript

import { deriveDb } from '../../../../src/app-config/derive';
import { buildOrmConfig, resolveEngine } from '../../../../src/db/engine';
import { TrekPostgreSqlDriver } from '../../../../src/db/engine/postgres/postgres-driver';
import { sslOptionFor } from '../../../../src/db/engine/postgres/postgres-engine';
import { redactUrl } from '../../../../src/db/engine/redact-url';
import { SharedSqliteDriver } from '../../../../src/db/orm-driver';
import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import path from 'node:path';
import { describe, expect, it } from 'vitest';
const PG_URL = 'postgresql://trek:s3cret@db.example:5432/trek';
describe('resolveEngine', () => {
it('ENGINE-001: SQLite when no TREK_DB_URL is set, which is the test environment', () => {
const engine = resolveEngine();
expect(engine.id).toBe('sqlite');
expect(engine.ormOptions()).toEqual({ driver: SharedSqliteDriver, dbName: ':memory:' });
expect(engine.describe()).toBe('SQLite file :memory:');
});
it('ENGINE-002: Postgres when TREK_DB_URL names a database, with the pool size and no SSL by default', () => {
const engine = resolveEngine(deriveDb({ TREK_DB_URL: PG_URL, TREK_DB_POOL_MAX: '7' }));
expect(engine.id).toBe('postgres');
expect(engine.ormOptions()).toEqual({
driver: TrekPostgreSqlDriver,
clientUrl: PG_URL,
pool: { min: 0, max: 7 },
driverOptions: {},
});
});
it('ENGINE-003: describes a Postgres database without its password', () => {
const engine = resolveEngine(deriveDb({ TREK_DB_URL: `${PG_URL}?sslmode=require&password=other` }));
expect(engine.describe()).toBe('Postgres postgresql://trek:***@db.example:5432/trek');
expect(engine.describe()).not.toContain('s3cret');
expect(engine.describe()).not.toContain('other');
});
});
describe('sslOptionFor', () => {
it('ENGINE-010: maps sslmode onto the pg pool option (MikroORM drops the URL query), always verifying the certificate', () => {
// As the pg driver itself reads them: require and verify-ca are verify-full.
expect(sslOptionFor(PG_URL)).toBeUndefined();
expect(sslOptionFor(`${PG_URL}?sslmode=disable`)).toBe(false);
for (const mode of ['require', 'verify-ca', 'verify-full']) {
expect(sslOptionFor(`${PG_URL}?sslmode=${mode}`), mode).toEqual({ rejectUnauthorized: true });
}
});
it('ENGINE-011: refuses an sslmode it does not know or that would skip verification', () => {
expect(() => sslOptionFor(`${PG_URL}?sslmode=requrie`)).toThrow(/sslmode "requrie"/);
expect(() => sslOptionFor(`${PG_URL}?sslmode=no-verify`)).toThrow(/sslmode "no-verify"/);
expect(() => sslOptionFor(`${PG_URL}?sslmode=prefer`)).toThrow(/sslmode "prefer"/);
});
it('ENGINE-012: passes the SSL option to the pool when the URL asks for one', () => {
const engine = resolveEngine(deriveDb({ TREK_DB_URL: `${PG_URL}?sslmode=require` }));
expect(engine.ormOptions().driverOptions).toEqual({ ssl: { rejectUnauthorized: true } });
});
it('ENGINE-013: trusts the CA in sslrootcert (a managed host that signs its own certificates), and refuses a missing file', () => {
const dir = mkdtempSync(path.join(tmpdir(), 'trek-ca-'));
try {
const ca = path.join(dir, 'root.crt');
writeFileSync(ca, '-----BEGIN CERTIFICATE-----\nprobe\n-----END CERTIFICATE-----\n');
expect(sslOptionFor(`${PG_URL}?sslmode=verify-full&sslrootcert=${encodeURIComponent(ca)}`)).toEqual({
rejectUnauthorized: true,
ca: readFileSync(ca, 'utf8'),
});
expect(() =>
sslOptionFor(`${PG_URL}?sslmode=require&sslrootcert=${encodeURIComponent(path.join(dir, 'no.crt'))}`),
).toThrow(/sslrootcert/);
expect(() => sslOptionFor(`${PG_URL}?sslrootcert=${encodeURIComponent(ca)}`)).toThrow(
/sslrootcert without sslmode/,
);
} finally {
rmSync(dir, { recursive: true, force: true });
}
});
});
describe('redactUrl', () => {
it('ENGINE-020: hides the password and drops the query, which can carry one too', () => {
expect(redactUrl('postgres://u:p@h/d?password=x&sslmode=require')).toBe('postgres://u:***@h/d');
expect(redactUrl('postgres://u@h:5433/d')).toBe('postgres://u@h:5433/d');
expect(redactUrl('not a url')).toBe('<unparseable URL>');
});
});
describe('buildOrmConfig', () => {
it('ENGINE-030: the SQLite config carries the entities, migrations and seeders with the engine options', () => {
const config = buildOrmConfig(resolveEngine());
expect(config.driver).toBe(SharedSqliteDriver);
expect(config.dbName).toBe(':memory:');
expect(config.migrations).toMatchObject({ pathTs: 'src/db/migrations', snapshot: false });
expect(config.seeder).toMatchObject({ defaultSeeder: 'DatabaseSeeder' });
expect(Array.isArray(config.entities) && config.entities.length).toBeGreaterThan(100);
});
it('ENGINE-031: the Postgres config carries the same entities and migrations, on the pg driver', () => {
const config = buildOrmConfig(resolveEngine(deriveDb({ TREK_DB_URL: PG_URL })));
expect(config.driver).toBe(TrekPostgreSqlDriver);
expect(config.clientUrl).toBe(PG_URL);
expect(config.migrations).toMatchObject({ pathTs: 'src/db/migrations', snapshot: false });
expect(config.entities).toBe(buildOrmConfig(resolveEngine()).entities);
});
it('ENGINE-032: a Postgres engine opens and closes nothing of its own, and refuses a reopen (no restore yet)', async () => {
const engine = resolveEngine(deriveDb({ TREK_DB_URL: PG_URL }));
expect(() => engine.open(() => undefined)).not.toThrow();
expect(() => engine.close()).not.toThrow();
await expect(engine.reopen()).rejects.toThrow(/not available in this release/);
});
});