mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-20 11:06:06 +00:00
a77705984e
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.
117 lines
5.7 KiB
TypeScript
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/);
|
|
});
|
|
});
|