Files
TREK/server/scripts/pg-probe/helper-cases.ts
T
Maurice 22973036b5 fix(db): match a stay-linked booking on Postgres in the public stay check
publicStayExists cast reservations.accommodation_id straight to integer,
which Postgres refuses for the stored '14.0', so the calendar feed and the
share links failed for every trip once any booking was linked to a stay.
The correlation now goes through accommodationIdMatches, which compares
through the new dialect helper integerTextEqualsKysely, and the Wallet pass
context uses the same helper instead of its own numeric cast.
2026-11-17 12:23:36 +01:00

471 lines
16 KiB
TypeScript

/**
* The dialect helpers, run on both engines.
*
* Each case puts one row into a scratch table, selects one helper's
* expression over it and checks the value. The same case runs on SQLite
* (an in-memory better-sqlite3 database) and on Postgres, so a Postgres
* branch is held to what its SQLite twin returns, not to a value written
* down once. The cases stay inside what both engines agree on: Postgres
* folds every letter in LOWER and NOCASE while SQLite folds only ASCII (the
* helpers' docstrings say so), and what Postgres does with a non-ASCII
* letter also depends on the database's locale, so the inputs are ASCII. An
* expectation may still name a value per engine where they are meant to
* differ.
*
* Unlike the repository statements, nothing here is baselined: every case
* must pass on both engines.
*/
import {
castIntegerKysely,
concatKysely,
currentTimestampKysely,
integerTextEqualsKysely,
nowPlusSecondsKysely,
startsWithIsoDateKysely,
substringKysely,
unixEpochToIsoKysely,
} from '../../src/db/dialect/kysely-functions';
import {
absDifference,
caseWhenEquals,
caseWhenNotNull,
castInteger,
coalesce,
coalesceOverride,
coalesceOverrideWhileSame,
coalesceParam,
collateNoCase,
columnIncrementedBy,
columnRef,
concat,
countAll,
countAllRef,
currentTimestamp,
dateAdd,
dateOf,
dayDistance,
foundAgainState,
ilike,
lower,
lowerParam,
lowerTrim,
lowerTrimParam,
maxOf,
minOf,
nowDateOffset,
nowMinusDays,
nowMinusHours,
nowPlusSeconds,
startsWithIsoDate,
substring,
trim,
} from '../../src/db/dialect/sql-functions';
import type { Platform } from '@mikro-orm/core';
import type { AliasableExpression, ExpressionBuilder } from 'kysely';
export type Engine = 'sqlite' | 'postgres';
export const VALUES_TABLE = 'trek_pg_probe_values';
export interface ValuesRow {
id: number;
a: string | null;
b: string | null;
n: number | null;
x: number | null;
}
export interface ValuesDB {
trek_pg_probe_values: ValuesRow;
}
export const VALUES_TABLE_DDL: Record<Engine, string> = {
sqlite: `CREATE TABLE ${VALUES_TABLE} (id INTEGER PRIMARY KEY, a TEXT, b TEXT, n INTEGER, x REAL)`,
postgres: `CREATE TABLE ${VALUES_TABLE} (id integer PRIMARY KEY, a text, b text, n bigint, x double precision)`,
};
/** A fragment rendered into `select <sql> [as v] from trek_pg_probe_values`. */
export interface RawSelect {
sql: string;
params: unknown[];
/** The fragment already names its column (`COUNT(*) as c`); read that one instead of `v`. */
column?: string;
}
export type KyselySelect = (
platform: Platform,
eb: ExpressionBuilder<ValuesDB, 'trek_pg_probe_values'>,
) => AliasableExpression<unknown>;
export type Expectation =
| { equals: string | number | boolean | null }
| { timestamp: number }
| { date: number }
| { perEngine: Record<Engine, Expectation> };
export interface HelperCase {
name: string;
row: Partial<Omit<ValuesRow, 'id'>>;
raw?: (platform: Platform) => RawSelect;
kysely?: KyselySelect;
expect: Expectation;
}
const DAY_MS = 86_400_000;
const CLOCK_TOLERANCE_MS = 120_000;
const rawOf = (fragment: { sql: string; params: readonly unknown[] }, column?: string): RawSelect => ({
sql: fragment.sql,
params: [...fragment.params],
column,
});
/** `(<key> = <value>)` for the helpers used as a filter key. */
const comparison = (
key: { sql: string; params: readonly unknown[] },
value: { sql: string; params: readonly unknown[] },
): RawSelect => ({
sql: `(${key.sql} = ${value.sql})`,
params: [...key.params, ...value.params],
});
const bound = (value: unknown): { sql: string; params: unknown[] } => ({ sql: '?', params: [value] });
/** Epoch milliseconds as the ISO text `unixEpochToIsoKysely` renders (whole seconds, `Z`). */
export function isoSeconds(ms: number): string {
return new Date(Math.floor(ms / 1000) * 1000).toISOString().replace('.000Z', 'Z');
}
const EPOCH_MS = 1_758_459_909_123;
export const HELPER_CASES: readonly HelperCase[] = [
{
name: 'dateOf',
row: { a: '2026-09-21 13:05:09' },
raw: (p) => rawOf(dateOf(p, 'a')),
expect: { equals: '2026-09-21' },
},
{
name: 'dateAdd forward',
row: { a: '2026-09-21 13:05:09' },
raw: (p) => rawOf(dateAdd(p, 'a', 10)),
expect: { equals: '2026-10-01' },
},
{
name: 'dateAdd back',
row: { a: '2026-09-21 13:05:09' },
raw: (p) => rawOf(dateAdd(p, 'a', -10)),
expect: { equals: '2026-09-11' },
},
{ name: 'currentTimestamp', row: {}, raw: (p) => rawOf(currentTimestamp(p)), expect: { timestamp: 0 } },
{ name: 'nowMinusDays', row: {}, raw: (p) => rawOf(nowMinusDays(p, 30)), expect: { timestamp: -30 * DAY_MS } },
{ name: 'nowMinusHours', row: {}, raw: (p) => rawOf(nowMinusHours(p, 20)), expect: { timestamp: -20 * 3_600_000 } },
{ name: 'nowPlusSeconds', row: {}, raw: (p) => rawOf(nowPlusSeconds(p, 90)), expect: { timestamp: 90_000 } },
{ name: 'nowDateOffset back', row: {}, raw: (p) => rawOf(nowDateOffset(p, -400)), expect: { date: -400 } },
{ name: 'nowDateOffset forward', row: {}, raw: (p) => rawOf(nowDateOffset(p, 1)), expect: { date: 1 } },
{ name: 'columnRef', row: { n: 7 }, raw: (p) => rawOf(columnRef(p, 'n')), expect: { equals: 7 } },
{
name: 'columnIncrementedBy',
row: { n: 7 },
raw: (p) => rawOf(columnIncrementedBy(p, 'n', -2)),
expect: { equals: 5 },
},
{ name: 'lower', row: { a: 'Probe@X.com' }, raw: (p) => rawOf(lower(p, 'a')), expect: { equals: 'probe@x.com' } },
{
name: 'lower = lowerParam',
row: { a: 'Probe@X.com' },
raw: (p) => comparison(lower(p, 'a'), lowerParam(p, 'PROBE@x.COM')),
expect: { equals: true },
},
{ name: 'trim', row: { a: ' probe ' }, raw: (p) => rawOf(trim(p, 'a')), expect: { equals: 'probe' } },
{ name: 'lowerTrim', row: { a: ' AbC ' }, raw: (p) => rawOf(lowerTrim(p, 'a')), expect: { equals: 'abc' } },
{
name: 'lowerTrim = lowerTrimParam',
row: { a: ' AbC ' },
raw: (p) => comparison(lowerTrim(p, 'a'), lowerTrimParam(p, ' aBc')),
expect: { equals: true },
},
{
name: 'coalesce',
row: { a: null, b: 'fallback' },
raw: (p) => rawOf(coalesce(p, 'a', 'b')),
expect: { equals: 'fallback' },
},
{
name: 'coalesceParam keeps the column',
row: { a: 'stored' },
raw: (p) => rawOf(coalesceParam(p, 'a', 'new')),
expect: { equals: 'stored' },
},
{
name: 'coalesceParam fills a null',
row: { a: null },
raw: (p) => rawOf(coalesceParam(p, 'a', 'new')),
expect: { equals: 'new' },
},
{
name: 'coalesceOverride prefers the value',
row: { a: 'stored' },
raw: (p) => rawOf(coalesceOverride(p, 'new', 'a')),
expect: { equals: 'new' },
},
{
name: 'coalesceOverride keeps on null',
row: { a: 'stored' },
raw: (p) => rawOf(coalesceOverride(p, null, 'a')),
expect: { equals: 'stored' },
},
{ name: 'absDifference', row: { x: 4 }, raw: (p) => rawOf(absDifference(p, 'x', 6.5)), expect: { equals: 2.5 } },
{ name: 'countAll', row: {}, raw: (p) => rawOf(countAll(p, 'c'), 'c'), expect: { equals: 1 } },
{ name: 'countAllRef', row: {}, raw: (p) => rawOf(countAllRef(p)), expect: { equals: 1 } },
{ name: 'minOf', row: { n: 3 }, raw: (p) => rawOf(minOf(p, 'n', 'lo'), 'lo'), expect: { equals: 3 } },
{ name: 'maxOf', row: { n: 3 }, raw: (p) => rawOf(maxOf(p, 'n', 'hi'), 'hi'), expect: { equals: 3 } },
{
name: 'caseWhenEquals',
row: { n: 7 },
raw: (p) => rawOf(caseWhenEquals(p, 'n', 7, 'owner', 'member')),
expect: { equals: 'owner' },
},
{
name: 'caseWhenEquals else',
row: { n: 8 },
raw: (p) => rawOf(caseWhenEquals(p, 'n', 7, 'owner', 'member')),
expect: { equals: 'member' },
},
{
name: 'startsWithIsoDate yes',
row: { a: '2026-09-21T10:00' },
raw: (p) => rawOf(startsWithIsoDate(p, 'a')),
expect: { equals: true },
},
{
name: 'startsWithIsoDate no',
row: { a: 'abcd-ef-gh' },
raw: (p) => rawOf(startsWithIsoDate(p, 'a')),
expect: { equals: false },
},
{
name: 'substring with length',
row: { a: '2026-09-21T10:00' },
raw: (p) => rawOf(substring(p, 'a', 1, 10)),
expect: { equals: '2026-09-21' },
},
{
name: 'substring to the end',
row: { a: '2026-09-21T10:00' },
raw: (p) => rawOf(substring(p, 'a', 12)),
expect: { equals: '10:00' },
},
{
name: 'concat',
row: { a: '2026-09-21', b: '10:00' },
raw: (p) => rawOf(concat(p, { column: 'a' }, { value: 'T' }, { column: 'b' })),
expect: { equals: '2026-09-21T10:00' },
},
{ name: 'castInteger of 14.0', row: { a: '14.0' }, raw: (p) => rawOf(castInteger(p, 'a')), expect: { equals: 14 } },
{ name: 'castInteger of 14', row: { a: '14' }, raw: (p) => rawOf(castInteger(p, 'a')), expect: { equals: 14 } },
{
name: 'dayDistance',
row: { a: '2026-09-21' },
raw: (p) => rawOf(dayDistance(p, 'a', '2026-09-24')),
expect: { equals: 3 },
},
{
name: 'ilike matches in other case',
row: { a: 'Probe Place' },
raw: (p) => ({ sql: ilike(p, ['a']), params: ['%PLACE%'] }),
expect: { equals: true },
},
{
name: 'ilike keeps the escaped wildcard literal',
row: { a: 'Probe Place' },
raw: (p) => ({ sql: ilike(p, ['a']), params: ['probe\\_place'] }),
expect: { equals: false },
},
{
name: 'collateNoCase',
row: { a: 'Probe' },
raw: (p) => comparison(collateNoCase(p, 'a'), bound('pROBE')),
expect: { equals: true },
},
{
name: 'foundAgainState recovers',
row: { a: 'remote_missing', b: 'file-1' },
raw: (p) => rawOf(foundAgainState(p, 'a', 'b')),
expect: { equals: 'synced' },
},
{
name: 'foundAgainState passes through',
row: { a: 'error', b: 'file-1' },
raw: (p) => rawOf(foundAgainState(p, 'a', 'b')),
expect: { equals: 'error' },
},
{
name: 'coalesceOverrideWhileSame keeps for the same key',
row: { a: 'https://a', n: 1 },
raw: (p) => rawOf(coalesceOverrideWhileSame(p, null, 'n', 'a', 'https://a')),
expect: { equals: 1 },
},
{
name: 'coalesceOverrideWhileSame resets for a new key',
row: { a: 'https://a', n: 1 },
raw: (p) => rawOf(coalesceOverrideWhileSame(p, null, 'n', 'a', 'https://b')),
expect: { equals: 0 },
},
{
name: 'caseWhenNotNull',
row: { a: 'x', b: 'route' },
raw: (p) => rawOf(caseWhenNotNull(p, 'a', 'b')),
expect: { equals: 'route' },
},
{
name: 'caseWhenNotNull null',
row: { a: null, b: 'route' },
raw: (p) => rawOf(caseWhenNotNull(p, 'a', 'b')),
expect: { equals: null },
},
{
name: 'startsWithIsoDateKysely',
row: { a: '2026-09-21 10:00:00' },
kysely: (p, eb) =>
eb
.case()
.when(startsWithIsoDateKysely(p, eb, 'a'))
.then('yes')
.else('no')
.end(),
expect: { equals: 'yes' },
},
{
name: 'substringKysely',
row: { a: '2026-09-21T10:00' },
kysely: (p, eb) => substringKysely(p, eb, 'a', 1, 10),
expect: { equals: '2026-09-21' },
},
{
name: 'concatKysely',
row: { a: '2026-09-21', b: 'xx10:00' },
kysely: (p, eb) =>
concatKysely(p, eb, { column: 'a' }, { value: 'T' }, { expression: substringKysely(p, eb, 'b', 3) }),
expect: { equals: '2026-09-21T10:00' },
},
{
name: 'castIntegerKysely',
row: { a: '14.0' },
kysely: (p, eb) => castIntegerKysely(p, eb, 'a'),
expect: { equals: 14 },
},
...['14', '14.0'].map(
(stored): HelperCase => ({
name: `integerTextEqualsKysely matches the text ${stored} to 14`,
row: { a: stored, n: 14 },
kysely: (p, eb) => eb.case().when(integerTextEqualsKysely(p, eb, 'a', 'n')).then('yes').else('no').end(),
expect: { equals: 'yes' },
}),
),
{
name: 'integerTextEqualsKysely matches the number 14 to 14',
row: { n: 14 },
kysely: (p, eb) => eb.case().when(integerTextEqualsKysely(p, eb, 'n', 'n')).then('yes').else('no').end(),
expect: { equals: 'yes' },
},
{
name: 'integerTextEqualsKysely tells 15.0 from 14',
row: { a: '15.0', n: 14 },
kysely: (p, eb) => eb.case().when(integerTextEqualsKysely(p, eb, 'a', 'n')).then('yes').else('no').end(),
expect: { equals: 'no' },
},
{
name: 'unixEpochToIsoKysely',
row: { n: EPOCH_MS },
kysely: (p, eb) => unixEpochToIsoKysely(p, eb, 'n'),
expect: { equals: isoSeconds(EPOCH_MS) },
},
{
name: 'nowPlusSecondsKysely',
row: {},
kysely: (p, eb) => nowPlusSecondsKysely(p, eb, 45),
expect: { timestamp: 45_000 },
},
{ name: 'currentTimestampKysely', row: {}, kysely: (p) => currentTimestampKysely(p), expect: { timestamp: 0 } },
];
const TIMESTAMP_TEXT = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
const DATE_TEXT = /^\d{4}-\d{2}-\d{2}$/;
/** Why `value` does not meet `expectation` on `engine`, or null when it does. `now` is epoch ms around the query. */
export function checkValue(expectation: Expectation, value: unknown, engine: Engine, now: number): string | null {
if ('perEngine' in expectation) return checkValue(expectation.perEngine[engine], value, engine, now);
if ('timestamp' in expectation) {
if (typeof value !== 'string' || !TIMESTAMP_TEXT.test(value))
return `expected timestamp text, got ${JSON.stringify(value)}`;
const off = Date.parse(`${value.replace(' ', 'T')}Z`) - (now + expectation.timestamp);
return Math.abs(off) <= CLOCK_TOLERANCE_MS ? null : `${value} is ${Math.round(off / 1000)}s off`;
}
if ('date' in expectation) {
if (typeof value !== 'string' || !DATE_TEXT.test(value)) return `expected date text, got ${JSON.stringify(value)}`;
const wanted = Date.parse(new Date(now + expectation.date * DAY_MS).toISOString().slice(0, 10));
return Math.abs(Date.parse(value) - wanted) <= DAY_MS
? null
: `${value} is not ${expectation.date} day(s) from today`;
}
const expected = expectation.equals;
if (expected === null) return value === null ? null : `expected null, got ${JSON.stringify(value)}`;
if (typeof expected === 'boolean') {
const truthy = value === true || value === 1 || value === 't' || value === '1';
const falsy = value === false || value === 0 || value === 'f' || value === '0';
return (expected ? truthy : falsy) ? null : `expected ${expected}, got ${JSON.stringify(value)}`;
}
if (typeof expected === 'number') {
const n =
typeof value === 'bigint'
? Number(value)
: typeof value === 'string' || typeof value === 'number'
? Number(value)
: Number.NaN;
return Math.abs(n - expected) < 1e-9
? null
: `expected ${expected}, got ${JSON.stringify(typeof value === 'bigint' ? String(value) : value)}`;
}
return value === expected ? null : `expected ${JSON.stringify(expected)}, got ${JSON.stringify(value)}`;
}
/** How one engine runs a case: write the row, select the expression, hand back the value. */
export interface HelperEngine {
engine: Engine;
platform: Platform;
writeRow(row: ValuesRow): Promise<void>;
selectRaw(select: RawSelect): Promise<unknown>;
selectKysely(select: KyselySelect): Promise<unknown>;
}
export interface HelperResult {
engine: Engine;
name: string;
failure: string | null;
}
export async function runHelperCases(
engine: HelperEngine,
cases: readonly HelperCase[] = HELPER_CASES,
): Promise<HelperResult[]> {
const results: HelperResult[] = [];
for (const helperCase of cases) {
let failure: string | null;
try {
await engine.writeRow({ id: 1, a: null, b: null, n: null, x: null, ...helperCase.row });
const before = Date.now();
let value: unknown;
if (helperCase.raw) value = await engine.selectRaw(helperCase.raw(engine.platform));
else if (helperCase.kysely) value = await engine.selectKysely(helperCase.kysely);
else throw new Error('a case needs raw or kysely');
failure = checkValue(helperCase.expect, value, engine.engine, Math.round((before + Date.now()) / 2));
} catch (error) {
failure = `threw: ${error instanceof Error ? error.message.split('\n')[0] : String(error)}`;
}
results.push({ engine: engine.engine, name: helperCase.name, failure });
}
return results;
}