Feat/orm : mikroorm (#2416)

* base entities * update deps * fix date as string * rename entities * migrations + seeders * feat(db): DbTimestampType keeps DATETIME columns as the CURRENT_TIMESTAMP text * feat(db): discover entities from an explicit list instead of a glob * test(db): createTestOrm binds an ORM to a suite's own SQLite handle * feat(db): dialect helper is the one place SQL functions are spelled * test(db): dialect helper refuses malformed column references and day counts * feat(db): snake_case entity shape and the first three repositories (Days, DayNotes, Trips) * fix(db): repositories mirror the statement's column set and guard their row types * feat(db): request-context and unit-of-work helpers for the ORM, with concurrency tests * test(server): integration suites boot on the migrated schema snapshot * test(server): snapshot harness keeps the legacy id semantics * fix(test): route MikroORM's dynamic imports through vitest from the setup file, not the ORM config * test(db): coverage ratchet entries for the ORM foundation * test(server): websocket suites boot on the migrated schema snapshot * test(server): coverage's uncovered-file pass goes through the SWC transform * fix(db): dialect helpers dispatch on the platform; lint gate for the repository layer * test(server): ORM suites open the schema snapshot; RESET_TABLES derived from the schema * chore(server): promise safety net and sweep tooling for the async migration * refactor(realtime, systemNotices, addons, airports, audit, categories, permissions, query-helpers, tags, transit, trip-membership): async DB-touching methods; transactions through UnitOfWork * fix(server): observe every promise the async sweep left unobserved (timer, handshake, plugin-runtime test) * test(doc-sync): unit suites await the methods the async sweep made async * refactor(atlas, school-holidays, settings): async DB-touching methods; transactions through UnitOfWork * chore(server): lint rule refusing a Promise used as a plain value, and the misses it found * test(server): suites await the methods Task 1's forced edits made async * refactor(budget, common, day-notes, days): async DB-touching methods; transactions through UnitOfWork * test(oauth): controller suite awaits the async service * chore(server): db-call-graph --unawaited lists calls to async methods whose result is used without await * refactor(llm-parse, mcp-shared, oauth, place-shadow, route-usage, storage, todo, trip-invite): async DB-touching methods; transactions through UnitOfWork * refactor(plugins): async DB-touching methods; transactions through UnitOfWork * chore(server): db-call-graph --sync stops its transitive walk at an async callee * chore(plugins): drop gate-only asyncs; observe the scheduler's rejection; async event-sink stub * refactor(notifications, place-photos, backup): async DB-touching methods; transactions through UnitOfWork * refactor(auth, files): async DB-touching methods; transactions through UnitOfWork * test(server): suites await the methods earlier sweep groups made async * refactor(tokens): async DB-touching methods; the auth token handlers await them * test(files): upload filters fail closed on an excluded or unresolvable type * refactor(collab, collections, maps): async DB-touching methods; transactions through UnitOfWork * refactor(memories, photos, packing, share): async DB-touching methods; transactions through UnitOfWork * chore(server): lint rule also refuses a Promise handed to expect() without resolves/rejects * refactor(vacay, admin, doc-sync): async DB-touching methods; transactions through UnitOfWork * fix(vacay): type the loop accumulators the async sweep introduced * refactor(journey, oidc, place-enrichment, tokens, trip-members): async DB-touching methods; transactions through UnitOfWork * fix(server): the journey hooks are awaited by their callers, not detached * refactor(assignments, public-api, accommodations, places): async DB-touching methods; transactions through UnitOfWork * refactor(trips): rewrite AccommodationsService.createAccommodation .bind alias Recipe R4 trap named in the Task 12 brief: a .bind alias of an AssignmentsService/AccommodationsService method is typed any and hides a missing await from tsc and the promise lint rules. createAccommodation belongs to this task's group, so rewritten as an arrow forwarding to the method instead of a bound reference. * refactor(assignments): drop the unused Trip type alias * refactor(reservations, booking-import, calendar, integrations, roadtrip): async DB-touching methods; transactions through UnitOfWork * refactor(roadtrip, reservations): return await on transactional; document the single-flight promises * refactor(trip-read-model, trips, feeds): async DB-touching methods; transactions through UnitOfWork * refactor(server): remove DatabaseService.transaction — every transaction runs through UnitOfWork * refactor(trips, feeds): drop added return annotations; no double await on the feed guard * fix(server): phase 1 review follow-ups — awaited returns, logged upload-filter rejections, covered handshake/notice branches, call-graph gate in CI, dead test imports * fix(server): upload filters answer multer once on a throwing callback; positive call-graph gate test * test(db): entity metadata must match the migrated schema; fix the four drifts it found * feat(db): primary-relation entities proven (BudgetCategoryOrder, VacayUserSettings) * test(db): parity gate also holds declared pivot entities; per-field column types; missing-set ratchets both ways * test(db): numeric ids for the primary-relation spike * feat(db): re-runnable entity generator encoding the snake_case/DbTimestampType rules * fix(db): generator guard rails — validation cannot mask hidden()/index loss; typed JSON; loud failures * fix(db): generator keeps NOT NULL boolean defaults; fails if a JSON interface import survives * refactor(db): every entity in the snake_case shape; document-sync entities added; one repository per entity * fix(db): no NaN class-field initialisers; entity generator --check gate in CI; parity normaliser keeps literal case * chore(db): entity --check reports stray files; class-field census is a ratchet; migrate-encryption typechecked * feat(db): AppSettings and Users repositories; forFeature wiring pattern * refactor(permissions): permission flags through AppSettingsRepository * fix(server): boot-time settings read runs inside an explicit ORM request context * refactor(audit): audit log writes through AuditLogRepository * fix(db): PK reads refresh past the identity map; typed owned-lookup generics; e2e ORM module mirrors production config * docs(db): owned-lookup call-site convention; refresh side effect; e2e ORM module spread notes * fix(audit): audit rows are native inserts, not a unit-of-work flush; closed test ORMs * fix(server): non-HTTP entrypoints run inside an ORM request context; permission loads fail closed on context errors * refactor(categories, tags): repositories replace raw SQL * refactor(addons): addon catalog and photo providers through repositories * fix(db): generator captures inline UNIQUE constraints SqliteSchemaHelper.getIndexes() drops every unnamed sqlite_autoindex_ entry before entity-generator ever sees it, so a table-level UNIQUE(...) constraint with no separate named CREATE UNIQUE INDEX (settings' UNIQUE(user_id, key) among ~40 others) never reached the generated entity's uniques: metadata. Adds a general RULE9_addImplicitUniqueConstraints (skips a column set identical to the table's own primary key — AppSettings.key/Addons.id noise) fed by a PRAGMA index_list/index_info scan, and regenerates every entity. * chore(addons): well-known gate wraps only the addon read in a request context; drop unused test factories * fix(platform): well-known gate tolerates a synchronous addon read from the context helper * fix(db): PK lookups inside patch refresh past the identity map; corrected identity-map notes * refactor(settings): user and instance settings through repositories SettingsRepository (getForUser/upsertForUser/getOne/deleteForUser) replaces the per-user settings table's raw SQL; SettingsService drops DatabaseService entirely. instance-api-keys.ts's readInstanceApiKey/writeInstanceApiKey/ resolveApiKey take an explicit AppSettingsRepository/UsersRepository instead of a raw connection. An earlier version resolved those two repositories itself from the active MikroORM request context, so none of its six callers needed to change. That worked in production and e2e (always inside a real request) but broke service construction in plain unit tests across every calling domain (addons, auth x2, maps, transit, unsplash - 185 failures on a full run), since none of them wrap a request context. Each of those six services now injects its own AppSettingsRepository/UsersRepository and passes them through explicitly, matching how every other converted repository in this migration is consumed; their own SQL is untouched (outside Plan 3a). * test(server): harness constructors follow the Task 5 repository signatures; one test ORM per handle in the plugin host * fix(db): generator names relation properties in captured UNIQUE constraints * fix(settings): drop dead wiring and the speculative deleteForUser; strict row assertions * fix(server): plan 3a review follow-ups — fail closed without an ORM at every choke point; seam and D5 ratchet tests; dead method and DDL copies removed * fix(server): plan 3a re-review follow-ups — plugin boot activation and the airports backfill inside a request context; the supervisor answers the child before failing closed; BOOT-SWEEP-001 drives the real boot hooks; ws adapter seam pinned * feat(db): generated entities declare their repository type; test casts dropped * fix(server): plan 3a re-review 2 follow-ups — absent-ORM boot branch pinned; airports boot hook never rejects; BOOT-SWEEP-001 asserts the seven routes; duplicate comment removed * feat(server): pre-init photo route and WS handshake run in a request context; InviteTokensRepository * refactor(auth): users table through UsersRepository; JWT and MFA lookups repository-backed * refactor(tokens): MCP and API tokens through McpTokensRepository * refactor(auth): passkeys and registration invites through repositories * fix(db): row-out repository reads bypass the identity map — stale write-back over nativeUpdate at flush; insertUser via em.insert; settings round-trip pinned * fix(server): non-numeric route ids answer the legacy not-found, never NaN (tokens, categories, tags); mint path back to two statements; identity-map regression pinned * refactor(oauth): OAuth server tables through repositories OauthClientsRepository/OauthTokensRepository/OauthConsentsRepository replace OauthService's raw SQL (OA1-OA33). revokeChain's recursive CTE and the oauth_clients join (its FK actually targets client_id, not the row id the generated relation assumes) go through em.getKysely(); OA19's chain revoke is one nativeUpdate($in); OA12's consent grant is em.upsert on the (client, user) unique key. revokeAllForUser built now for Task 5. Every row-out read is disableIdentityMap: true; inserts go through em.insert. * fix(auth): non-numeric passkey and invite ids answer the legacy 404, never NaN; invite join type pinned * fix(db): generator emits the referenced column for non-PK foreign keys; OAuth client joins through the relation; FK parity un-skipped * refactor(db): TrekRepository base — every repository path validates the request context and reads bypass the identity map by default * refactor(auth): AuthService and account cleanup through repositories * refactor(oidc): OIDC identities and settings through repositories * fix(auth): invite validation keeps expires_at null on the wire; password transaction scopes and reset-token burn pinned * fix(server): plan 3b close-out — case folding on both sides for identifier lookups (non-ASCII login regression); coverage ratchet restored; repository scaffold and instanceof ratchet on TrekRepository; D-shape tests load-bearing * refactor(server): trip-access primitives async at every caller * refactor(trips): trip access through TripsRepository; demo seed in a request context; dialect helpers for the trips cluster * refactor(days): days and day notes through repositories * refactor(assignments): day assignments through repositories * refactor(server): trip-membership, place-shadow, place-enrichment, place-photos and query helpers through repositories * refactor(trip-members): membership, guests and the trip read model through repositories * refactor(places): places, tags, ratings and place images through repositories * fix(server): place-shadow source counts ordered in SQL; identity-map ratchets load-bearing; photo-cache race pinned * refactor(places): import paths through repositories * refactor(trips): trips through repositories * fix(server): trip ids parsed once at the gate for places and assignments; NUL-safe value quoting on the SQLite platform; places parity tests completed * refactor(trips): trip copy through repositories for the owned tables * fix(server): plan 3c close-out — non-finite ids bound as NULL, trip id parsed once at every places/days/ws gate Platform: NulSafeSqlitePlatform now renders a bound NaN as NULL and +/-Infinity as 9e999/-9e999, matching better-sqlite3's own legacy binding (rule 22 extension) — the program-wide fail-safe for any caller that still passes an unguarded Number(untrusted) into a converted statement. PlacesService.verifyTripAccess and RealtimeGateway.handleJoin stop doing that: verifyTripAccess parses once with toRowId and threads the parsed id through create/import/bulk/rating/export.gpx (deleting the seven toRowId(tripId) ?? -1 sites), and handleJoin gets a Number.isFinite guard. DaysService gets the same treatment across list/create/getDay/reorder/ insert/resyncAccommodationDays, closing the gap where a hex-spelled trip id could renumber a real trip's days while the raw-bind inverted-accommodation guard silently matched nothing. DatabaseService.getTripTitle is deleted; PlacesService injects TripsRepository directly and calls getTitle itself. Template/cheap-item cleanup: DayAssignmentsRepository.listForTimeSort uses $castTo instead of an unknown bridge; the duplicated TagRow interface in Places.repository.ts is now imported from Tags.repository.ts; AssignmentWithPlaceRow extends the guarded DayAssignmentRow instead of restating its columns; PlaceShadowPicksRepository.totals drops its unreachable ??-fallback branch; Places.repository.ts's updatePlace types the NOT NULL name column as string; trip-members.service.ts's transferOwnership threads one parsed trip id through all three writes and corrects two stale "raw-bind seam" docstrings that were actually Number() seams; a dead canAccessTrip mock is removed from reservations.e2e.test.ts. Tests: the 23 new no-explicit-any warnings in TRIP-SVC-069 are typed (lint back to 2416); HTTP and WS regression coverage for the non-finite and non-canonical id shapes across places/days routes, mutation-proved; TRIP-JOIN-005 asserts the exact concurrent-join settlement instead of >= 1; a new tests/unit/db/transaction-yield.test.ts pins rule 24's measured transaction-yield/dirty-read/nested-BEGIN behaviour. * test(server): plan 3c close-out — copy-source full-row parity, Kysely rollback proofs, identity-map relabels, trips e2e on the snapshot DB * fix(server): plan 3c close-out — days create/insert answer the guard 404 for non-canonical trip ids instead of 500; exact settlement and cross-request yield ratchets * feat(server): plan 3d groundwork — dialect helpers, visibility predicate, feed and cron context ratchets * refactor(roadtrip): roadtrip tables through repositories * refactor(reservations): reservations, endpoints and travelers through repositories * refactor(feeds): ICS feed tokens and anonymous feeds through repositories * refactor(accommodations): stays through repositories inside the existing transactions * test(server): plan 3d — MCP test helper constructors follow the accommodations and days services * refactor(trips): trip copy through repositories for the roadtrip, accommodation and reservation tables * refactor(calendar): calendar reads and reservation visibility through one predicate * feat(server): plan 3e groundwork — packing visibility predicate, memories access-gate audit * fix(server): plan 3d close-out — legacy text shape for stored accommodation ids restores the date-change restamp; reservation ids parsed once at the gate; parity tests for the reservation repositories * refactor(photos): trek photos, memories access and cache sweeps through repositories * refactor(files): trip files and file links through repositories, with transactions added * test(server): plan 3e — hand-built FilesService, FilesRpc and AllowedFileTypesService calls follow the repository constructors * refactor(memories): unified, immich and synology photo sync through repositories * refactor(collab): notes, polls, messages and links through repositories * refactor(budget): budget items, members, payers and settlements through repositories * refactor(todo): todo items through repositories * refactor(packing): packing items, bags and templates through repositories * feat(server): plan 3f groundwork — systemNotices DI shape, TRAVELER_OWNS predicate, ntfy/storage-health specs, composite-PK pins * refactor(school-holidays): country and region catalog through repositories * refactor(notifications): in-app notifications and channel preferences through repositories * refactor(notifications): reminder crons, mailer, ntfy and webhook transports through repositories * fix(server): plan 3e close-out — repository registrations restore the boot; packing assignee and bag updates parse and no-op as legacy; coverage and scoping ratchets for the budget, packing and collab repositories * refactor(vacay): vacation plans, entries, shares and holiday calendars through repositories * refactor(system-notices): notice dismissals through a Nest provider and repository * refactor(atlas): visited countries, regions and bucket list through repositories * feat(server): plan 3g groundwork — GALLERY_CHRONOLOGICAL_ORDER Kysely ordering, unixEpochToIsoKysely helper, composite-PK DDL pins, JB5/R7 confirmations * refactor(journey): journey and trip access control, CRUD and the trip-sync engine through repositories * feat(server): plan 3h groundwork — date-offset dialect helpers, entity/repository fitness confirmations, pre-init and encryption pattern confirmations, survivor re-grep * fix(server): plan 3f close-out — ntfy operator-scope test on the live send path; vacay date-offset and shift-order parity; todo reminder window; coverage and parity ratchets for the atlas and vacay repositories * refactor(journey): journey stats, entries, photos, contributors and suggestions through repositories * refactor(journey): public share links, TREK Studio books and the journal facades through repositories * refactor(collections): access model, hydration, export/import and list CRUD through repositories * refactor(server): journey-table survivors in trips, photos, memories, auth-cleanup and plugin-contributions through repositories * refactor(integrations): dawarich connection, sync, tracks and review-flow through repositories * refactor(collections): saved places, copy-to-trip, labels and invitations through repositories * refactor(integrations,booking-import,airports,maps,route-usage): airtrail, booking import, airport backfill, maps cache and route-usage counters through repositories * refactor(doc-sync): connections, reconciler and controller-SQL relocation through repositories * test(integrations): add AirTrail saveSettings tx-asymmetry ratchet (Plan 3h Task 4 addendum) * fix(server): plan 3g close-out — transactional book first-save, skeleton reconcile and share-link create; unknown-key entry patches are no-ops again; parity and authorization pins for the journey repositories * feat(server): plan 3i groundwork — AuditLogRepository's reserved methods, the demo connection-swap spike, repository-fitness confirmations * feat(server): plan 3j groundwork — scheduler onto CronRegistrarService, SDK-contract confirmation, repository fitness * refactor(storage): backend/category config and usage stats through AppSettingsRepository; fix the seed-file test race and the shared-replica migration-flip gap * refactor(share): public share links, the pre-init photo fallback, and collection-places survivors through repositories * feat(server): plan 3j — the withCamelCase utility, unwired, pending a contract decision * refactor(admin): user CRUD, stats, audit log, version check and addon config through repositories * test(admin): pin createUser's pre-existing non-transactional uniqueness-check race (AD2-4) * refactor(plugins): the trip-write role gate through a repository, in isolation * refactor(demo,backup): seed and reset through DemoRepository, live-connection backup statements through MaintenanceRepository, isDemoUserId through an injected DemoService * fix(server): plan 3h close-out — new-value-wins COALESCE restores stay/reservation propagation; doc-sync state filter truthiness; request-context and parity ratchets for share, doc-sync and the integrations * refactor(plugins): runtime lifecycle, config CRUD and the uninstall cascade through repositories * fix(server): plan 3i close-out — DemoModule imported where its service is consumed (e2e restored); admin addons list selects the provider relation; saveDemoBaseline awaited; backup tests on the maintenance repository * refactor(plugins): outbound OAuth tokens and per-user plugin settings through repositories * refactor(plugins): install-time gates, the capability-audit hash chain and the registry through repositories * refactor(plugins): contribution-hook controllers, the small plugin controllers and the plugins-table survivors through repositories * test(server): plan 4 — collapse mcp tool test harnesses onto the ORM snapshot * test(server): plan 4 — collapse nest service test harnesses onto the ORM snapshot * fix(server): plan 3j close-out — serialized audit-chain appends, atomic metadata and scheduler limits, rollback and race proofs for the plugin repositories * refactor(server): plan 4 — convert the program's orphaned raw-SQL callers * fix(server): plan 4 — un-skip PARITY-009 (FK deleteRule and index-name parity) * refactor(server): plan 4 — inline canAccessTrip/isOwner off DatabaseService (trip-domain services) * refactor(server): plan 4 — inline canAccessTrip/isOwner off DatabaseService (plugins + MCP surfaces) * fix(server): plan 4 — RULE12 paren-count scanner ignores string literals The entity generator's RULE12_fixGarbledCheckExpressions CHECK-expression paren-balance scanner counted every `(`/`)` character regardless of whether it fell inside a single-quoted SQL string literal. A CHECK expression like `status IN ('confirmed)', 'tentative')` has a literal `)` inside its first string value; the scanner would hit depth 0 at that in-string character and truncate the expression, losing its own real closing paren. The scanner now tracks single-quote string state (handling the doubled `''` SQLite escape) and skips parens while inside one. Latent-bug fix — no shipped entity's CHECK expression has hit this shape yet (3d's ledger: "nothing affected today"). * refactor(server): plan 4 — unify the trip-access predicate's Kysely copies TripsRepository.findForViewer/listForUser/activeTrip each hand-wrote the identical trip-access boolean (t.user_id = ? OR m.user_id IS NOT NULL) through the Kysely expression builder. Task 7's security review (M1) evaluated a shared helper and set it aside for time, falling back to the TRIPREPO-041 cross-method parity test as a regression guard instead. Extracted the boolean into one generic helper, tripAccessExpr (_shared/trip-access.ts), following the reservation-visibility.ts publicReservationExpr precedent: fully generic over <DB, TB> since the predicate has no correlated subquery, so it composes across TripSelectKyselyDB and ActiveTripKyselyDB without needing a narrower fixed-alias shape. The LEFT JOIN itself stays hand-written at each call site — tripSelectQuery's own docstring already explains why a shared join helper can't be typed across these differently-joined outer queries. feeds.service.ts and memories-access.service.ts no longer duplicate this predicate at all (Task 2's facade-inline sweep already converted both onto TripsRepository.findAccessible/getFeedTokenIfReachable/ listReachableActiveTrips, which read through the canonical MikroORM QueryBuilder form, accessibleTripsQuery) — the remaining duplication this task closes is the three Kysely copies inside this file. TRIPREPO-041 (64/64 in the file) stays green as the unification's own regression guard. * fix(server): plan 4 — trek_photo_cache_meta.cache_key NOT NULL The column was a bare TEXT PRIMARY KEY, which SQLite does not implicitly make NOT NULL (unlike an INTEGER PRIMARY KEY rowid alias). Every writer (TrekPhotoCacheMetaRepository.upsertMeta, the table's only INSERT path) has always bound a real string — 3e's R5 confirmed this. Appends a new migration rebuilding the table with cache_key NOT NULL (SQLite has no ALTER COLUMN, so this follows the same rebuild recipe Migration20200101020000 uses in the opposite direction) and updates the entity/generated metadata to match. Schema tightening, not a behaviour change. * refactor(server): plan 4 — retire the safely-convertible string-form where conditions (rule 23) Places.repository.ts's existsInTrip/findInTrip/findRaw/reclaimInputs/ listByTripAndIds and Trips.repository.ts's findPublicForShare all took a raw `.where('col = ?', [v])` string condition even though their id/trip_id parameters were already plain `number` (or, for findPublicForShare, narrowed to `number` here after confirming its one caller, share.service.ts#getSharedTripData, only ever passes a number sourced from a Kysely-typed share_tokens row, never an unconverted URL param) — converted all six to MikroORM's typed `.where({...})` filter object. The remaining raw string-form conditions in src/db/repositories/** are NOT converted here: they are the `number | string` raw-bind seam findAccessible/isOwner's own docstrings describe (trip_id/id threaded through unconverted from req.params), which structurally requires the deferred guard-level single toRowId parse to land first — narrowing any of those methods' signatures now would either break the '0x10'/'007' id parity those docstrings warn about, or duplicate the deferred item's own work ahead of it landing. * refactor(server): plan 4 — trek-photos.repository.ts finishes its rename 3e Task 6 renamed the CLASS (TrekPhotosRepository -> TrekPhotoRegistrationService, since the name collided with the generated ORM TrekPhotos.repository.ts) but left the FILE and its test file's names unchanged. Renames both to trek-photo-registration.service.ts / .test.ts. The old path is kept as a thin re-export stub (the src/websocket.ts shape) rather than repointed at every one of its ~20 importers in this pass: several of those files sit in two sibling tasks' exclusively-owned windows on this shared branch (Task 3's budget/packing/todo/accommodations/places ripple, reached through tests/helpers/plugin-host.ts and mcp-test-controllers.ts; Task 5c's held-back tests/unit/services/{trekPhotoMedia,conflictUpdate}.test.ts) and are off limits here. Flagged for a follow-up once those tasks land: delete the stub and repoint every remaining importer at ./trek-photo-registration.service. * fix(server): plan 4 — plugin discovery's delete+reinsert pairs are atomic install/discovery.ts#upsert refreshed a plugin's actions and settings-field descriptors as two independent delete-then-reinsert pairs (DI5-DI8) with no transaction spanning either pair, let alone both: a crash between a delete and its own reinsert left that plugin with an EMPTY actions or settings-field set until the next discovery run, instead of its previous still-valid rows. Wraps both pairs in one uow.transactional, so a discovery refresh for a plugin's descriptors is now all-or-nothing. Deliberate behaviour change, named for the user per the task brief. DiscoveryRepos grows a UnitOfWork; PluginRegistryService (the other production caller, registry.service.ts) picks it up the same @Optional() way PluginRuntimeService already does, with the same guard-throw. Updates the two hand-constructed test call sites that actually exercise discovery (discovery.test.ts, registry.test.ts) to pass a real UnitOfWork. * refactor(server): plan 4 — facade inline sweep part B (rosterUserIds/getPlaceWithTags) Inline DatabaseService.rosterUserIds onto TripMembersRepository.rosterUserIds directly in budget.service.ts, budget.mcp.ts and todo.service.ts, and DatabaseService.getPlaceWithTags onto PlacesRepository.findWithTagsAndRatings in accommodations.service.ts (placesRepo was already injected there). BudgetService/BudgetMcp/TodoService collapse their constructors, dropping the now-fully-unused DatabaseService param (budget.module.ts/todo.module.ts register TripMembers on forFeature). PackingService keeps DatabaseService as a vestigial param behind an optional TripMembersRepository with a fallback in tripRosterIds: an in-flight Task 5c file (tests/unit/services/conflictUpdate.test.ts) hand-constructs PackingService positionally without the new repository, so its arity cannot change this task; the fallback keeps that file's DatabaseService.rosterUserIds spy working until Task 4 drops the param with the class itself. * test(server): plan 4 — constructor ripple for the rosterUserIds/getPlaceWithTags inline Hand-built BudgetService/BudgetMcp/TodoService call sites drop the removed DatabaseService constructor arg (budgetRepoArgs() now appends a TripMembersRepository so most spread call sites need no other change); budget.service.test.ts's rosterHas() helper and svc() factory move from a spied DatabaseService to a stubbed TripMembersRepository. The AccommodationsService helper (tests/helpers/accommodations-service.ts) and its two direct callers drop the same arg. PackingService call sites are untouched (its new param is optional, so every existing hand-built instance still resolves rosterUserIds through the DatabaseService fallback). * fix(server): plan 4 — thread the discovery UnitOfWork through PluginRuntimeService too Complements the just-landed discovery atomicity fix (DiscoveryRepos.uow): PluginRuntimeService's own discoveryRepos getter still built the bundle without a uow field. Threads its already-injected, @Optional() uow through so its own onApplicationBootstrap/reload/dev-link discovery calls also get the transactional DI5-DI8 refresh, not just PluginRegistryService's. No throwing guard here, unlike PluginRegistryService's: several hand-built partial-DI-graph test instances of this class (boot-registry-order.test.ts, in a sibling task's held file window) construct it with uow omitted and exercise onApplicationBootstrap's discovery call directly. Discovery must never refuse outright just because a test built a partial graph, so it degrades to the pre-existing untransacted sequence when uow is absent (DiscoveryRepos.uow's own docstring covers this), the same "boot must never block app init" defensiveness this file already applies elsewhere. * fix(server): plan 4 — guard-level single parse: verify + correct the overclaiming verifyTripAccess docstring (L-2) TripAccessGuard/TripOwnerGuard already parse :tripId exactly once (Number(), guarded by Number.isFinite) and hand the resolved TripAccess row to the handler via request[TRIP_REQUEST_KEY], TripOwnerGuard reusing TripAccessGuard's own lookup when both are on the same route rather than re-querying — verified by reading both guards directly, no change needed there. PlacesService.verifyTripAccess's own docstring separately claimed its returned `tid` gets "returned... for every downstream call to reuse (never re-parsing)" (3c's Task 9 review, L-2, carried to Plan 4). Reading every call site (not assumed) shows this is false: `.tid` has exactly one reader (PlacesController.requireTrip itself), which discards it — none of requireTrip's 13 callers read `.tid` off the trip it returns; each passes the original raw tripId string on to the write/read method it calls next, which toRowId-parses it again itself. That second parse cannot be eliminated by this gate alone: the same service methods are called directly by places.mcp.ts too, an entry point with no requireTrip gate at all (its own numeric tripId is re-stringified, String(tripId), to call them), so each method owns its own id validation regardless of entry point. Threading `tid` all the way through would mean giving every one of ~15 methods a second, number-only call shape for the REST path alone to use — a real refactor, out of this docstring fix's own scope. Corrected the docstring to say so plainly instead of repeating the false claim. * refactor(server): plan 4 — relocate JS7/10/13/14 off the journey-share fallback stub JourneyShareTokensRepository's own JS7/JS10/JS13/JS14 Kysely reads were a 3g Task 3 fallback (Task 2's JourneyPhotosRepository/JourneyEntriesRepository/ JourneyEntryPhotosRepository were still mid-flight). Now that those repositories are stable, relocate: JS7/JS10 (photo/asset validation joins) onto JourneyPhotosRepository (already injected into JourneyShareService as photosRepo, no constructor change); JS13 (public entry list) onto JourneyEntriesRepository.listPublicEntries; JS14 (public per-entry photo read) onto JourneyEntryPhotosRepository.listForPublicJourney, deduped against that repository's own JP_COLUMNS select list instead of a hand-duplicated copy. JourneyShareService gains two new @InjectRepository params (both already registered in journey-domain.module.ts's forFeature), rippled through mcp-test-controllers.ts and journey-share.service.test.ts (P04/P05 parity tests now pin the new homes). * refactor(server): plan 4 — document unreachable ?? default arms after single-row aggregates 3f Task 7's fix wave flagged a cluster of `row?.x ?? default` arms after unqualified, ungrouped aggregate reads (MAX/COUNT/COALESCE(SUM,0)) as "same class as OauthClients:147" but left them unexamined per-site. Decided per site: document, don't delete — TypeScript still types executeTakeFirst()'s result as `| undefined` even though SQL guarantees exactly one row for these unqualified aggregates, so the optional chain can't be removed without a non-null assertion (worse, not safer). Six sites: JourneyEntries.repository.ts (maxSortOrderForDate JG42, countStatsPlaces JG67), JourneyEntryPhotos.repository.ts (maxSortOrderForEntry JG91), JourneyPhotos.repository.ts (maxSortOrder JG88/JG99), VacayEntries.repository.ts (sumFraction VC1, sumCompFraction VC2). No behavior change — comments only. * refactor(server): plan 4 — unify the two user-data-erasure enqueue paths UserCleanupService.erasePluginUserData (the account-deletion transaction's own UC2/UC3 enqueue) and PluginRuntimeService.enqueueUserErasure (the emitUserDeleted sink's post-commit enqueue) independently walked the identical SELECT id, permissions FROM plugins + JSON.parse + hook:user-data filter + INSERT OR IGNORE — and both genuinely run for every account deletion, since every emitUserDeleted call site (auth.service.ts, admin.service.ts, trip-members.service.ts's guest removal) fires immediately after deleteUserCompletely. Extracted the shared filter into enqueueHookUserDataErasures (nest/plugins/user-erasure-enqueue.ts) and pointed both call sites at it. UC2/UC3 also come off DatabaseService onto PluginsRepository/ PluginUserErasureQueueRepository in the same change (they were the last raw statements standing in the way of sharing one implementation) — this narrows the Plan 3b Task 5 "stays raw, owned by Plan 3j" ruling to UC1 only (plugin_user_config/plugin_oauth_tokens/plugin_oauth_state), which still stays raw, unaffected. UserCleanupService's orphan-data-directory scan (a plugin uninstalled with data retained) has no equivalent on the enqueueUserErasure side and stays there, now via the same repository. Both enqueue calls still run per deletion (INSERT OR IGNORE keeps this idempotent) — this unifies the IMPLEMENTATION, not the call count; not touching the emitUserDeleted event-sink wiring itself was a deliberate, smaller-blast-radius choice for this task. * refactor(server): plan 4 — narrow TripMembersRepository.remove/TripsRepository.setOwner to number Both accepted trip_id: number | string per 3c's carry note (their "stays loose for other callers" reasoning), pending the guard-level single parse landing first. Re-checked every caller directly: setOwner's one production caller (trip-members.service.ts#transferOwnership) already passes trip.id, a real number resolved earlier in the same transaction; remove's callers are trips.rpc.ts (num(), already a validated number), trips.mcp.ts (Zod- typed tool input, already a number) and TripMembersController.removeMember (the one genuine raw-string caller, :id off the route with no class-level TripAccessGuard on this controller by design). TripMembersController.removeMember now parses :id once (toRowId, not Number() — rule 15's NaN-into-SQL trap) and threads the parsed number to both its own access check and removeMember, instead of passing the raw string through twice. TripMembersService.removeMember and both repository methods narrow to number accordingly; setOwner's WHERE also moves off its raw-bind escape hatch onto nativeUpdate now that trip_id is typed, and remove's trip_id half moves onto a typed .where({ trip: trip_id }) filter (user_id keeps its own raw bind — a different, still-live NaN-safety seam, unrelated to this narrowing). TRIPREPO-018 and TMEMREPO-023, which pinned the retired string-bind seam on setOwner/remove, no longer typecheck against the narrowed signatures and are removed with an explanatory comment in their place. * refactor(server): plan 4 — U6 gate-level id parsing for todo item ids Rule 21's carry from 3e Task 8's review: TodoController.update/.remove passed the raw :id route string all the way to TodoItemsRepository, relying on SQLite's column-affinity CAST to match it instead of a typed filter. Parse :id ONCE at the controller (toRowId, matching Task 8a's TripAccessGuard/removeMember shape), 404 on a non-canonical id, and thread the number down through TodoService.updateItem/deleteItem into TodoItemsRepository.findInTrip/existsInTrip/update/deleteById, all narrowed from number | string to number. todo.rpc.ts's num()-derived todoId no longer needs its String() wrapper. tripId stays string | number — a separate, already-accepted carry (23c292f2f). Two new e2e tests pin the non-numeric-id 404 at the gate. * test(server): plan 4 — full-key parity tests for ShareTokensRepository (3h L4) 3h L4's carry: ShareTokensRepository (SH1-SH6/SH17/UC6) had zero tests. 17 cases pinning every read against the legacy statement run raw on the same connection — findRawByTrip/findTokenByTrip with every nullable column both null and set, findValidByToken/findTripAndShareMapByToken/ findTripIdByToken's shared token+expiry predicate (valid, future-expiry, past-expiry, unknown token), plus insertNew/updateFlagsByTrip/deleteByTrip/ deleteByCreator's write correctness (deleteByCreator's cross-trip erasure kept distinct from deleteByTrip's single-trip scope, per the repository's own docstring). The listPublicForShare family (the other half of 3h L4) is a separate, larger carry — not in this file. * test(server): plan 4 — full-key parity for Reservations share/public-api reads (3d carry) Task 8b-2 item 1 (partial): the 8 share.service.ts/public-api.service.ts reads on ReservationsRepository flagged by the 3d Task 7 review as having no repository-level toEqual(<legacy raw>) coverage (listEndpointsForShare, listDayPositionsForShare, listPublicForShare, listPublicAccommodationsForShare, listScheduledForPublicApi, listUnscheduledForPublicApi, listAccommodationsForPublicApi, listUnplannedPlacesForPublicApi). 12 new cases against the legacy statement run raw on the same connection. * test(server): plan 4 — concurrency pins for boundaries-upsert and token-mint races (3d carry) Task 8b-2 item 2: R7's two remaining un-transacted-statement races flagged by the 3d Task 7 review (L4) but never pinned — RoadtripDayBoundariesService .save's belongs-check-then-upsert, and FeedsService.generateTripToken's read-then-write. Both tests pin today's actual outcome (an atomic ON CONFLICT upsert survives cleanly; the token mint has a last-write-wins loser) with the same concurrent-request-shape Promise.all/allSettled pattern roadtrip.service.test.ts's existing R7 vias pin uses. Not a fix. * test(server): plan 4 — full-key parity for Days/DayAssignments/Places roadtrip reads (3d carry) Task 8b-2 item 1 (remainder): the 3 non-share/public-api reads from the 3d Task 7 review's missing-parity list — DaysRepository.listPlanDays (RPL1), DayAssignmentsRepository.listRoadtripVisits (RPL2, the correlated-subquery LEFT JOIN), and PlacesRepository.isTrackInTrip (RT13, the review's "findTrackInTrip" — the actual method name). Completes the 11-file carry together with 434113937's 8 share/public-api reads. * test(server): plan 4 — dedupe overlapping listPlanDays/isTrackInTrip parity blocks 235f03665 landed two versions of the same DaysRepository.listPlanDays and PlacesRepository.isTrackInTrip parity coverage side by side (a merge artifact from concurrent work on the same carry item). Keeps one block per method, drops the duplicate describe/it blocks and their colliding test ids. * test(server): plan 4 — budget calc suite onto real repositories (3e carry) * test(server): plan 4 — at-rest encryption pins for AirTrail/doc-sync/webhook secrets (3h L3) Task 8b-2 item 4: the three credential columns the 3h Task 7 review flagged as having no at-rest pin — users.airtrail_api_key (AirtrailService#saveSettings), document_connections.secrets (DocSyncConfigService's whole-secret-map column), and trip_document_links.webhook_secret (createLink's per-binding mint). Each test saves through the real service, reads the raw column via better-sqlite3, asserts it is enc:v1:-prefixed ciphertext that never contains the plaintext, and asserts the service's own decrypt path rounds it back to the original value. * test(server): plan 4 — at-rest encryption pins for AirTrail/doc-sync secrets (3h L3 carry) Task 8b-2 item 4: the 3h Task 7 review's L3 finding ("users.airtrail_api_key has no at-rest pin", "document_connections.secrets ... has no enc:v1: check", "trip_document_links.webhook_secret - no at-rest pin"). Three targets, each proven by reading the raw column and asserting the stored value is enc:v1:-prefixed ciphertext that round-trips, never the plaintext: UsersRepository.setAirtrailSettingsWithKey/getAirtrailConnRow at the repository layer, AirtrailService.saveSettings/getAirtrailCredentials at the service layer, and DocSyncConfigService's connection secrets map plus createLink's webhook secret. * test(server): plan 4 — drop duplicate AirTrail encryption repository test Task 8b-2 item 4 follow-up: 6965869dd already covers UsersRepository.setAirtrailSettingsWithKey/getAirtrailConnRow's at-rest ciphertext at the service layer (airtrail.service.test.ts's AIRTRAIL-SVC-ENC-001/002) plus the doc-sync secrets/webhook pins (DOCSYNC-ENC-001/002); this repository-level file duplicated the same AirTrail assertion a second time. * test(server): plan 4 — atlas read-model parity remainder (3f L6 carry) Task 8b-2 item 3 (atlas half): full-key toEqual(<legacy raw>) coverage for the atlas read models the 3f Task 7 review's L6 finding listed as missing (minus AT1/TRAVELER_OWNS-consumer, already landed) — AT2 (Places. listForTripIds), AT3/AT28 (PlaceRegions.listCountryCodesForPlaceIds/ listForPlaceIds), AT5/AT10/AT43 (VisitedCountries.listCodesForUser/ listForUser), AT21/AT24/AT25 (VisitedRegions.listForUser/ listRegionCodesForCountry/findCountryCode), AT22 (HiddenRegions.listForUser), AT23/AT40/AT44 (PlaceRegions.listDistinctRegionCodesForCountryAndPlaces/ countPlacesByCountryForTrip/listVisitedCountryCodesForUser), AT30/33/34 (BucketList.listForUser/findById/findForUser), AT41 (Places. listAddressesForUser), AT42 (Trips.countTripsAndDaysForUser). New standalone files for HiddenRegions/VisitedCountries/VisitedRegions/PlaceRegions, which had none. AT6/45/46 (the TRAVELER_OWNS endpoint reads) are proven on ids only by the existing consumer test — full-row parity for those three is NOT done here (carried forward, same as the review's own open item). * test(server): plan 4 — vacay read-model parity remainder (3f L6 carry) Task 8b-2 item 3 (vacay half): full-key toEqual(<legacy raw>) coverage for the vacay read models the 3f Task 7 review's L6 finding listed as missing (minus VC81/82, already landed) — VacayPlans.findByOwner/findById (the getPlanData/getStats composite's own plan read), VacayYears.listForPlan (listYears), VacayCompanyHolidays.listForPlan (the company-holidays list), VacayHolidayCalendars.listForPlan/findById (holiday-calendar reads), VacayUserSettings.findForUser (user year settings), VacayUserYears. findForYear (getStats rows, including the NULL vacation_days case the review named explicitly), and VacayPlanMembers.listAvailableForFusion/ listPendingForPlan/listPendingForUser (the fusion and share pickers). Seven new standalone files — only VacayShares had a repository-level test before this. getSharedCalendars itself is a service-level composite over these same reads plus VacayCompanyHolidays.listDatesForRange (already exercised elsewhere); its own dedicated test is NOT added here. * test(server): plan 4 — full-key parity for PackingItemsRepository.listPublicForShare (3h L4) Task 8b-4a: no repository-level toEqual(<legacy raw>) coverage existed for the share.service.ts SH13 read. Seeds Common items with every nullable column both null and set, plus Personal and Shared-with-people items on both sides of the is_private/owner/recipient predicate, and proves only the Common tier surfaces. * test(server): plan 4 — full-key parity for BudgetItemsRepository.listPublicForShare (3h L4) Task 8b-4a: no repository-level toEqual(<legacy raw>) coverage existed for the share.service.ts SH14 read. Seeds two items — every nullable column set and every nullable column null — plus a foreign-trip item, and proves the ORDER BY category ASC shape (unlike BG72's listAllForTrip, which has none). * test(server): plan 4 — full-key parity for CollabMessagesRepository.listPublicForShare (3h L4) Task 8b-4a: no repository-level toEqual(<legacy raw>) coverage existed for the share.service.ts SH16 read. Seeds a root message, a reply (reply_to set), a deleted message (must be excluded) and a foreign-trip message, and proves the narrower username/avatar-only join shape (no reply_text/ reply_username, unlike joinedQuery). * test(server): plan 4 — full-key parity for PlacesRepository.listPublicForShare (3h L4) Task 8b-4a: no repository-level toEqual(<legacy raw>) coverage existed for the share.service.ts SH12 read. Seeds a categorised place with every nullable column set and an uncategorised place with every nullable column null, plus a foreign-trip place, and proves the named 20-column allow-list never leaks an owner-only column (reservation_status, google_place_id, …). * test(server): plan 4 — full-key parity for DayAssignmentsRepository.listPublicForShare (3h L4) Task 8b-4a: no repository-level toEqual(<legacy raw>) coverage existed for the SH9 read. Seeds assignments across multiple days (one excluded day_id never leaks in), every nullable place/assignment column both null and set, and proves the six owner-only columns SharePublicAssignmentRow omits (google_place_id, google_ftid, osm_id, amap_poi_id, stop_type, fill_percent) never appear on the row at all. * test(server): plan 4 — collapse remaining test harnesses; triage legacy migration tests * test(server): plan 4 — todo controller test expects the gate-parsed item id (U6 follow-up) * fix(server): add the missing numbered migration for the booked-night reseat step (#242) reseatBookedNights (legacy step 242) was never invoked from any shipped MikroORM migration -- only from the retired db/migrations.ts array -- so an install upgrading through the numbered chain never got the one-time reorder. Adds Migration20200101040300, which calls the frozen function through the native better-sqlite3 handle so it runs inside the migration's own transaction. orm-driver.ts's BoundSqliteConnection now also captures that handle onto the field SqliteConnection.getNativeClient() reads, which its createKyselyDialect() override previously left unset -- needed for this migration (and any future one) to reach it in production, not just under the bare test driver. RESEAT-009 moves off the legacy createTables+runMigrations builder onto the real Migrator via tests/helpers/migration-step.ts, plus a new fresh-install guard (RESEAT-011). * test(server): plan 4 — swap 4 of 5 straggler nest test harnesses off legacy schema builder day-notes.service.test.ts, public-api-scopes.test.ts, registration-invites.service.test.ts, trip-invite.service.test.ts onto createSnapshotTestDb() via the async vi.mock idiom (5a/5b/5c precedent), dropping their own hand-rolled createTables()+runMigrations() harness. trip-invite.service.test.ts and registration-invites.service.test.ts also drop their now-redundant DatabaseService wrapper (its .connection was always just the same test db handle). expect( assertions unchanged. user-cleanup.service.test.ts held back: its constructor call was updated to match UserCleanupService's new EntityManager-based shape, but deleteUserCompletely() now deadlocks against a real UnitOfWork (reproduced in isolation, independent of this test file -- see the report), which looks like a genuine bug in erasePluginUserData's new MaintenanceRepository(em) call versus UnitOfWork.transactional(), not a test-harness problem. * test(server): plan 4 — move auto-backup.test.ts and demo-reset-path.test.ts off createTestDb() Both build a schema db while 'fs'/'node:fs' are mocked (wholesale in auto-backup.test.ts, selectively spied in demo-reset-path.test.ts) for their own archiver/filesystem assertions, which broke createSnapshotTestDb()'s read of the schema snapshot through schema-snapshot.ts's own fs import. auto-backup.test.ts: fs is mocked wholesale, so the snapshot db is now built via a small helper that points fsMock's three calls at the real filesystem (fetched through vi.importActual, bypassing the mock) just long enough to build the db, before the test installs its own existsSync stub -- never touching schema-snapshot.ts itself. demo-reset-path.test.ts: fs.existsSync is selectively spied to answer only for the baseline path, so the db is now built before that spy is installed instead of after. * test(server): plan 4 — retire the legacy-runner-only migration hygiene checks migration-hygiene.test.ts deleted outright: every block in it (the destructive-op allowlist, the empty-catch guard, the full-chain smoke) scans or runs the legacy db/migrations.ts array being deleted this plan, never the numbered src/db/migrations/*.ts chain, so there is nothing in it to carry forward. leg-mode-incoming.test.ts: deleted its first describe block (the legacy-runner column-add + replay-safety smoke, also against db/migrations.ts); the read-path parity block, already on the modern createSnapshotTestDb() harness, is untouched. * chore(server): delete the legacy schema/migration/seed builders MikroORM's migrations are the only schema source now, including for tests: src/db/schema.ts, src/db/migrations.ts and src/db/seeds.ts are gone, along with tests/unit/db/schema-parity.test.ts (the parity gate that guarded them, already red on 8a's cache_key NOT NULL) and createTestDb() + its now-dead imports out of tests/helpers/test-db.ts (its last two callers moved onto createSnapshotTestDb() this plan). Their three entries drop from eslint.config.mjs's better-sqlite3 allow-list -- the files they exempted no longer exist. Ruling 7's frozen files (migration-utils.ts, reseat-booked-nights.ts, document-provider-seed.ts) and every numbered migration in src/db/migrations/ are untouched. Precondition grep (server/tests + server/src, from the task brief) is now empty: grep -rlE "from ['\"].*db/schema['\"]|from ['\"].*db/migrations['\"]|from ['\"].*db/seeds['\"]" server/tests server/src --include="*.ts" * docs: plan 4 — the repository layer is the only data access path DatabaseService/DatabaseModule are gone; queries go through repositories (server/src/db/repositories/) and UnitOfWork (server/src/nest/database/ unit-of-work.ts) for transactions. MikroORM's migrations are the only schema source, including for tests — the hand-kept schema.ts/migrations.ts/ seeds.ts test builders and their parity test are deleted. Documents the db/database.ts (connection only) / db/orm-driver.ts (bound driver) / UnitOfWork / repository shape, withRequestContext for non-HTTP entrypoints, the better-sqlite3 ESLint restriction, and the entity generator (gen:entities/ check:entities) as the schema-parity guard. Corrects two stale nest/README.md mentions (realtime.gateway.ts's now-repository constructor, the BE-Phase 1 trip-access bullet) and marks the legacy src/services/ migration recipe as a historical changelog rather than current guidance. * refactor(server): plan 4 — drop the 13 vestigial DatabaseService params/getters Removes the now-dead DatabaseService injection (or private get db() getter) from addons.service.ts, trips.service.ts, trip-invite.mcp.ts, place-photo-cache.service.ts, trek-photo-registration.service.ts, categories.mcp.ts, journey-domain.service.ts, plugins.service.ts, plugin-runtime.service.ts, plugin-mcp-tools.service.ts, places.service.ts and packing.service.ts — every one of them was fully repository-backed already (Task 2/3's facade inline sweep), just still carrying the param. PackingService's TripMembersRepository is required now (the this.db.rosterUserIds fallback is gone with it) and PluginRuntimeService's uow is no longer @Optional() — both moved ahead of the optional registry?/hostFactory? params, since TypeScript refuses a required parameter after an optional one; install/discovery.ts's DiscoveryRepos.uow is required to match, and its upsert() always runs the descriptor refresh inside one transaction instead of falling back to an un-transacted sequence. user-cleanup.service.ts's UC1 (the one genuinely live raw site, Plan 3b's "stays raw" plugin-table trio) moves off DatabaseService onto a new MaintenanceRepository.deletePluginUserData method — the rule-4-permitted connection.execute() home, built from a directly-injected EntityManager. Threads the active UnitOfWork.transactional's transaction context through execute()'s ctx param: without it, a raw connection.execute() call issued from inside deleteUserCompletely's open transaction contends for the same single-connection checkout the transaction already holds and deadlocks (never released, since the transaction is itself awaiting the call). tests/unit/db/transaction-yield.test.ts's probe B already pinned this exact hazard class for a raw better-sqlite3 statement; this is the same mechanism reached through the ORM's connection pool instead. nest/photos/trek-photos.repository.ts (the Plan 4 Task 8a re-export shim) is deleted, with every importer repointed to trek-photo-registration.service directly. The ~7 files that only imported the TripAccess/PlaceWithTags type re-export from database.service.ts now import them from Trips.repository.ts/Places.repository.ts directly, the actual single source. * refactor(server): plan 4 — delete DatabaseService, DatabaseModule and database.tokens.ts Grep gate confirmed zero src/ importers of DatabaseService left outside these three files (Task 1/2/3's earlier conversions + this task's own vestigial-param sweep). Deletes database.service.ts, database.module.ts and database.tokens.ts, drops DatabaseModule from app.module.ts's imports and the five other modules that still listed it (accommodations/calendar/doc-sync/feeds/trip-members) — none of them had a live DatabaseService injection left, so the import was already dead. OrmModule is the module that survives DatabaseModule's deletion, per the Phase 0 ledger's own ruling; untouched. db/database.ts's `db` Proxy export itself stays, deliberately: ~190 test files' vi.mock('…/db/database', …) factories return a { db: <mock handle>, … } shape, and their own `import { db as testDb } from '…/db/database'` is typed against this file's real exports regardless of the runtime mock — vi.mock swaps the module at runtime, but tsc resolves the import statically. Deleting the export would fail typecheck:tests across the whole suite for a test-harness idiom this task's file set doesn't own (Track B's territory). src/ has zero remaining importers, so the ESLint no-restricted-imports gate this task also shrinks still holds this file to its permanent allow-list entry either way. * test(server): plan 4 — repoint the test suite off the deleted DatabaseService/DatabaseModule Mechanical follow-through of the previous two commits across ~110 test files: - The 41 tests/e2e/*.e2e.test.ts suites composed DatabaseModule into their partial Test.createTestingModule graphs; the import and the array entry are dropped (nothing in any composed domain module injected DatabaseService any more, so the entry was already dead weight). - The shared test helpers (mcp-test-controllers.ts, plugin-host.ts, accommodations-service.ts, notifications.ts, test-addons.ts, test-uow.ts) each held a DatabaseService/DatabaseService-shaped param used only for its raw better-sqlite3 handle; every one now takes that handle directly, and every constructor call site the helpers make (PackingService, PlacesService, JourneyDomainService, PlacePhotoCacheService, TrekPhotoRegistrationService, TripsService, UserCleanupService, AddonsService, PluginsService, PluginRuntimeService) drops the removed param and, where PluginRuntimeService's uow is involved, reorders it ahead of the optional registry?/hostFactory? params to match the real constructor. - ~60 further unit/integration test files hand-constructed one or more of those same services directly; same fix, file by file. Four of them (memories-access.service.test.ts, places.directions.test.ts, places.service.test.ts, unified-memories.service.test.ts) also drop a vi.spyOn(DatabaseService.prototype | instance, 'canAccessTrip' | 'isOwner' | 'rosterUserIds' | 'getPlaceWithTags') spy left over from when those methods delegated through DatabaseService — dead now that the services read the owning repository directly. - database-service.test.ts and database-service.delegation.test.ts tested DatabaseService directly and are deleted with it. - tests/unit/db/transaction-yield.test.ts's probe B, which pinned a raw DatabaseService statement's dirty-read behaviour inside an open transaction (rule 24), now issues the same raw better-sqlite3 statement directly against the shared test handle — the exact shape DatabaseService.get/run used to wrap (this.conn.prepare(sql).get/run(), bypassing MikroORM/Kysely entirely) — so the hazard it documents is unchanged. Verified still green. No expect(...) assertion changed in any file; only construction/import plumbing. typecheck, typecheck:tests and the full touched-file run (101 files / 2668 tests) are green, plus the compiled boot (bootstrap.test.ts + boot-sweeps-request-context.test.ts) and one real e2e boot file (trips.e2e.test.ts). tests/unit/nest/user-cleanup.service.test.ts is deliberately NOT in this commit — see the next one. * test(server): plan 4 — finish user-cleanup.service.test.ts's harness swap; regression-test the UC1 transactional deadlock fix This file arrived already modified and unstaged in the shared tree — Task 6 (the parallel legacy-schema-deletion task) had swapped its DB harness onto createSnapshotTestDb() and updated the UserCleanupService construction to this task's new EntityManager-first shape while landing its own commits. Finished here: USER-CLEANUP-005 ("survives a slim schema without the plugin tables") passed a fake `{} as unknown as EntityManager`, which doesn't reach the real UC1 path any more (the previous raw DatabaseService.run swallowed everything in a try/catch regardless); it now builds a real EntityManager bound to the slim handle via sharedTestOrm(slim), so the per-statement query against the missing plugin_user_config/plugin_oauth_tokens/plugin_oauth_state tables is what's actually being proven caught, not a construction-time throw. USER-CLEANUP-006 through -010 (deleteUserCompletely, all of them exercising UC1 inside the real uow.transactional wrap) are the regression test for the previous commit's deadlock fix in user-cleanup.service.ts/MaintenanceRepository.ts: before that fix, every one of these hung and timed out. Green now, verified directly. * chore(server): plan 4 — shrink the better-sqlite3 ESLint allow-list Per ruling 6: database.service.ts's entry comes off (the file is deleted). The five plugin entries (plugin-route-normalize.ts, plugin-host-state.ts, install/discovery.ts, settings-defaults.ts, signature-status.ts) come off too — re-verified none of the five import better-sqlite3 or DatabaseService any more (3j's own conversion). The src/demo/** blanket entry was already gone (3i's own task landed it). reseat-booked-nights.ts and document-provider-seed.ts stay, with the `// TODO(plan 4)` comment corrected: they're frozen forever (ruling 7), invoked from inside numbered, already-shipped MikroORM migrations, never Plan 4's or any future plan's to touch. Permanent allow-list after this commit: src/db/database.ts, src/db/orm-driver.ts, src/db/durability.ts (the driver homes), src/nest/plugins/host/plugin-data.service.ts (3j's R-out-of-scope — a plugin's own sqlite file is never TREK's schema), src/nest/backup/backup.impl.ts (3i's R1, exactly the untrusted-upload-file probe), src/db/reseat-booked-nights.ts and src/db/document-provider-seed.ts (frozen forever). src/db/{schema,migrations,seeds}.ts entries were already removed by Task 6 when it deleted those files. 0 new lint errors; warning count unchanged at 2123 (well under the 2247 lean-gate ceiling) — every file the shrink touches was already fully converted. * refactor(server): plan 4 — U6 gate-level id parsing for budget item/settlement ids Rule 21's 3e carry, same discipline 218f75d0f applied to todo: every :id/:settlementId/:userId route param in BudgetController is parsed ONCE at the gate with toRowId, matching the legacy affinity-seam "not found" outcome for a malformed id on each route (404 'Budget item not found'/'Settlement not found', except toggleMemberPaid — the one legacy handler that never 404'd an unknown item/member either, so a malformed id there skips the write and keeps the same 200 { member } + Number(id)/Number(userId) broadcast shape it always had). The parsed numbers thread down through BudgetService's update/updateMembers/ setPayers/toggleMemberPaid/remove/updateSettlement/deleteSettlement (and their updateBudgetItem/deleteBudgetItem/setItemPayers/getBudgetItem/ applySettlementUpdate/getSettlement internals) into BudgetItemsRepository's getCurrency/findInTrip/existsInTrip/findForDelete/findById/update/deleteById and BudgetSettlementsRepository's findWithUsers/findGuard/update/deleteById, all narrowed from number | string to number; trip_id stays loose, a separate, already-accepted carry. costs.rpc.ts's num()-derived itemId no longer needs its String() wrapper on the update/delete calls; budget.mcp.ts was already Zod-typed to number throughout. Two new e2e tests pin the non-numeric-id 404 at the gate; controller/service unit tests cover the narrowed call args and the toggleMemberPaid malformed-id parity case. * refactor(server): plan 4 — U6 gate-level id parsing for packing item/bag/template ids Rule 21's 3e carry, same discipline 218f75d0f applied to todo: every :id/:bagId/:templateId/:userId route param in PackingController is parsed ONCE at the gate with toRowId, matching the legacy affinity-seam "not found" outcome for a malformed id on the routes with a pre-ORM Express precedent (update/remove -> 'Item not found', updateBag/deleteBag/setBagMembers -> 'Bag not found', applyTemplate -> 'Template not found or empty'). #858's sharing/contributors routes (setSharing/clone/addContributor/ removeContributor) are native Nest code with no pre-ORM precedent (landed in 7eabf6066, after the migration) — a malformed id there just 404s the same way an unknown one already does. removeContributor's :userId used to reach contributorsRepo.deleteOne through a bare Number.parseInt(), the exact NaN-into-SQL trap row-id.ts documents; it now parses through toRowId too. The parsed numbers thread down through PackingService's updateItem/ setItemSharing/addContributor/removeContributor/cloneItem/deleteItem/ getItemPrivacy/updateBag/deleteBag/setBagMembers/applyTemplate, all narrowed from number | string to number; tripId stays loose, a separate, already-accepted carry. PackingItemsRepository's getPrivacy/findVisibleInTrip/ update/updateSharing/delete/findById, PackingBagsRepository's findInTrip/ update/findWithAssignee/delete and PackingTemplateItemsRepository.listForApply narrow the same way. packing.rpc.ts's num()-derived itemId/bagId no longer need their String() wrappers on the update/delete/updateBag/deleteBag/ setBagMembers calls; packing.mcp.ts was already Zod-typed to number throughout. Two new e2e tests pin the non-numeric-id 404 at the gate; controller/rpc unit tests cover the narrowed call args and the removeContributor malformed-userId parity case. AdminPackingTemplatesController (/api/admin/packing-templates) is out of scope — a separate admin-gated surface with its own string-typed template CRUD, not part of this trip-scoped controller's :id chain. * test(server): plan 4 review — three pins catch up with the gate-parsed ids and the cache_key NOT NULL (M1–M3) * fix(server): boot baselines legacy-runner installs before running MikroORM migrations (B1) An install the retired positional runner migrated has a schema_version row and no mikro_orm_migrations rows, so its first boot on this branch replayed all 244 migrations over an already-migrated schema: eight refuse the boot, and the replay-safe ones overwrite user data (step 26 rewrites every day_assignments.assignment_time). runSchemaBootstrap now records the baseline plus every migration whose "Legacy migration step N" docstring is <= schema_version as executed, in one transaction through the migrator's own storage, before the ordinary run applies the rest. The step map is derived from the discovered migrations' source, never hand-kept, and anything unmappable (a newer or malformed schema_version, a duplicated, missing or out-of-order step) refuses the boot. * test(server): boot the app on three legacy-runner fixtures to pin the B1 baseline SQL dumps of databases the retired runner itself built: schema_version 205 (main at fa406b708), 242 (417d0445b, the runner's last commit) and 82 (v2.9.14, so seven of the eight non-replay-safe migrations still lie ahead and run for the first time). Each gets canary rows: user-set assignment times and a booked night. buildApp() on each asserts the baseline and the applied rest in order, the assignment times untouched, the booked-night reseat run exactly once on 205 and 82 and not at all on 242, schema_version kept, no half-built *_new table, a schema identical to a fresh install's, and an idempotent re-run. * refactor(server): demo-reset reads the live path off getRawConnection, not the db Proxy (m1) demo-reset.ts was the one src/ consumer of the db Proxy left, reached through a runtime require that a grep on `from` misses. It now imports closeDb/getRawConnection/reinitialize statically, the way backup.impl.ts does, so the Proxy genuinely has no src/ importer (the claim in database.ts and server/CLAUDE.md now holds). The path test mocks the module with vi.mock instead of teaching Node's require loader to answer for a .ts file. * test(server): renumber the duplicate ASSIGNREPO/PLACEREPO test ids Plan 4 introduced (m3) ASSIGNREPO-031/032 (the legacy-statement parity pair) become 034/035, and the later PLACEREPO-030..038 block becomes 053..061, the next free ids, so each id names one test again. No test body changes. * refactor(server): derive the two restated public row types instead of copying their columns (m4) JourneyPublicEntryPhotoRow restated JourneyPublicGalleryRow's nineteen columns with only the parent key changed; it is now that row with journey_id swapped for entry_id. PublicApiAssignedPlaceRow and its Kysely table shape restated PlaceRow's columns; both now Pick them off PlaceRow. Types only. The review's CPD method over Plan 4's new src lines drops from about 3.4% to 0.64%. * test(server): full-key parity for TripsRepository.findPublicForShare and VacaySharesRepository.listAvailableForShare (m5) Neither read had any test reference. Each is now pinned with toEqual(<legacy statement run raw on the same connection>), the listPublicForShare family shape: SH7 on a filled and a NULL-heavy trip plus a missing id (TRIPREPO-067/068), and VC90 over one world exercising every exclusion (caller, guest, existing share, plan owner, accepted member) and a missing plan. * fix(server): the legacy baseline runs createTables() instead of marking it, atomically with the run (N1) The legacy runner ran the running release's createTables() on every boot before its pending steps, and about 30 tables exist only there. Marking the baseline migration as executed left installs older than those tables (below legacy step 68) failing with "no such table: photo_provider_fields" and, since the rows were committed before the run, stuck half-baselined for every later boot. Only steps 1..N are recorded now, so the baseline's IF NOT EXISTS DDL runs first, as the legacy boot did. The rows are logged inside the same transaction as migrator.up({ transaction }), so a failed first boot records nothing and the next boot baselines again. A v66 fixture (the runner at 5be2e9b26) boots: 66 recorded, 178 applied, canaries kept. Its two schema differences from a fresh install (users.immich_access_token, reservations.accommodation_id INTEGER) come from the legacy chain itself and are pinned as carried. * fix(deps): sync the lockfiles with the bumped manifests and follow lucide's icon renames feat/orm raised react to ^19.3.0 and several plugin-sdk dependencies without regenerating the lockfiles, so npm ci failed on every CI job. The root overrides now pin react 19.3.0, both lockfiles are regenerated with npm 11, and the tests that select lucide icons by their old class names use the current ones. Two tests cover the Immich prefs reads and the boot restore branch that the coverage thresholds were missing. * ci: give the server lint step an 8 GB heap for the type-aware rules * test(server): keep the no-promise-as-value rule tester out of single-run mode on CI With CI=true typescript-eslint infers single-run mode, builds the program from the fixture file on disk and ignores the code each case passes in, so all 24 invalid cases reported nothing on the runner. Both testers now set disallowAutomaticSingleRunInference. * refactor(server): name the new migrations after the first seven words of their purpose, like the rest * fix(server): keep tsx a production dependency so image key rotation can load it * test(server): re-pin the repositories branch floor at the measured 89.83% * test(planner): keep the sidebar fixtures on past dates so the jump to today never fires in jsdom * test(server): keep console output for failing tests only and teach Nest's logger LOG_LEVEL * test(client): keep console output for failing tests only and answer the health probe * test(client): drop the health handler, it races the admin page's first load * chore(sonar): assert explicitly in two e2e cases, Number.NaN, and ignore S2187 on the legacy-upgrade fixtures --------- Co-authored-by: Maurice <mauriceboe@icloud.com>
2026-10-22 23:16:46 +00:00 · 2026-10-06 19:27:30 +02:00
parent b6115d48f3
commit de8caa81a2
1613 changed files with 137631 additions and 43502 deletions
@@ -0,0 +1,981 @@
+import { raw, type Platform, type RawQueryFragment } from '@mikro-orm/core';
+import { SqlitePlatform } from '@mikro-orm/sql';
+import { sql, type Expression, type ExpressionBuilder, type ExpressionWrapper, type RawBuilder, type ReferenceExpression, type SqlBool, type StringReference } from 'kysely';
+
+/**
+ * The only place a repository may spell a database function.
+ *
+ * Every helper takes the MikroORM `Platform` the caller's EntityManager is
+ * running on (`em.getPlatform()`) plus an already-qualified column reference
+ * (`'t.created_at'`), and dispatches on that platform at runtime. TREK ships
+ * one binary and the database is chosen by configuration, so the dialect is a
+ * runtime property of the live connection, not a build-time swap: when the
+ * Postgres driver arrives this file grows a second branch and no repository
+ * changes. An unknown platform fails closed rather than guessing a spelling.
+ *
+ * Values are never interpolated — the day count in `dateAdd` is checked to be
+ * an integer before it is spelled.
+ */
+
+function column(ref: string): string {
+  if (!/^[a-z_][a-z0-9_]*(\.[a-z_][a-z0-9_]*)?$/i.test(ref)) {
+    throw new Error(`sql-functions: not a column reference: ${ref}`);
+  }
+  return ref;
+}
+
+function unsupported(platform: Platform): never {
+  throw new Error(`sql-functions: no implementation for platform ${platform.constructor.name}`);
+}
+
+/** The calendar date (`YYYY-MM-DD`) of a timestamp column. */
+export function dateOf(platform: Platform, ref: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`date(${column(ref)})`);
+  return unsupported(platform);
+}
+
+/** The timestamp column shifted by whole days, as a calendar date. */
+export function dateAdd(platform: Platform, ref: string, days: number): RawQueryFragment {
+  if (!Number.isInteger(days)) throw new Error(`sql-functions: dateAdd needs an integer day count, got ${days}`);
+  if (platform instanceof SqlitePlatform) {
+    const sign = days < 0 ? '-' : '+';
+    return raw(`date(${column(ref)}, '${sign}${Math.abs(days)} days')`);
+  }
+  return unsupported(platform);
+}
+
+/** The database clock, in the same text the column defaults produce. */
+export function currentTimestamp(platform: Platform): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw('CURRENT_TIMESTAMP');
+  return unsupported(platform);
+}
+
+/**
+ * A bare reference to another column of the same row, for a filter or update
+ * value that must compare against or combine with a sibling column instead
+ * of a bound parameter (e.g. `used_count < max_uses` — `InviteTokensRepository
+ * .incrementUsedCount`'s capacity guard). Portable across dialects on its own,
+ * but still routed through this file (not spelled with `raw()` in a
+ * repository) so every escape hatch stays in one place ESLint's
+ * `no-restricted-syntax` rule for `src/db/repositories/**` can enforce.
+ */
+export function columnRef(platform: Platform, ref: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(column(ref));
+  return unsupported(platform);
+}
+
+/** A column shifted by a signed integer amount: `<col> + n` / `<col> - n`. */
+export function columnIncrementedBy(platform: Platform, ref: string, amount: number): RawQueryFragment {
+  if (!Number.isInteger(amount)) {
+    throw new Error(`sql-functions: columnIncrementedBy needs an integer amount, got ${amount}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    const sign = amount < 0 ? '-' : '+';
+    return raw(`${column(ref)} ${sign} ${Math.abs(amount)}`);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * A case-insensitive column reference, for use as a filter's object key:
+ * `{ [lower(platform, 'email')]: <value-side> }` produces
+ * `WHERE LOWER(email) = <value-side>`.
+ *
+ * **SQLite's `LOWER()` is ASCII-only; JavaScript's `String.prototype
+ * .toLowerCase()` is full-Unicode.** They do NOT agree on every input this
+ * codebase stores — a locally-registered e-mail can carry any non-whitespace
+ * character (`EMAIL_REGEX`), including non-ASCII letters (program rule 18;
+ * Plan 3b Task 7 review, H1: `JOSÉ@x.com` proved a live login lockout). Two
+ * value-side shapes are legitimate, and they are NOT interchangeable:
+ *
+ * - `LOWER(col) = LOWER(?)` — pair with `lowerParam()` below, binding the
+ *   RAW value. Both sides are folded by the SAME engine (SQLite's), so they
+ *   agree on every input. This is the shape for every legacy
+ *   `LOWER(col) = LOWER(?)` statement (AU9, AU12, UP5, UP6, O12).
+ * - `LOWER(col) = ?` — pair with a value the CALLER has already lowered in
+ *   JS (`value.toLowerCase()`) as a plain string, matching a legacy
+ *   `LOWER(col) = ?` statement exactly (only O4 today —
+ *   `OidcService.findOrCreateUser` JS-lowers the email once upfront and the
+ *   legacy statement it replaced never re-lowered it in SQL). Do not use
+ *   this shape for a value the caller has not already lowered.
+ *
+ * Typed `RawQueryFragment & symbol` (not the bare `RawQueryFragment` the
+ * other helpers in this file return): TypeScript only accepts a
+ * `string | number | symbol` as a computed property name, and a raw
+ * fragment is only usable as an object key because `raw()`'s default
+ * generic already brands it with a `[Symbol.toPrimitive]`. The other
+ * helpers here are only ever used as VALUES, where that brand isn't needed.
+ */
+export function lower(platform: Platform, ref: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`LOWER(${column(ref)})`);
+  return unsupported(platform);
+}
+
+/**
+ * The value-side twin of `lower()`: `LOWER(?)` bound with the RAW,
+ * untransformed value, for the right-hand side of a `lower(platform, col)`
+ * filter key. Together they render `LOWER(<column>) = LOWER(?)`,
+ * byte-for-byte a legacy `LOWER(col) = LOWER(?)` statement, because SQLite
+ * folds BOTH sides with the same (ASCII-only) engine — proven directly
+ * against `better-sqlite3`: `SELECT LOWER(?)` on `'JOSÉ@x.com'` yields
+ * `'josÉ@x.com'` (only the ASCII letters fold; the `É` is untouched), the
+ * same transform SQLite would apply to a stored column. Do NOT pre-lower
+ * the value in JS before calling this (program rule 18) — that reintroduces
+ * the mixed-engine bug this helper exists to close.
+ */
+export function lowerParam(platform: Platform, value: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw('LOWER(?)', [value]);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3c Task 0b (R6) — no consumer yet: Tasks 1–8 wire these in as each
+// converts the statement that needs them (`place-shadow.service.ts:192`,
+// `places.service.ts:642,651-652`, the ~16 `COALESCE` sites across
+// `days`/`assignments`/`trip-members`/`places`). Added here, with their own
+// SQLF-0xx tests pinning the SQLite text against a raw statement, so a later
+// task imports a tested helper instead of writing one inline.
+// ---------------------------------------------------------------------------
+
+/**
+ * `datetime('now', '-N days')` — the SQLite clock shifted backwards by whole
+ * days, as TEXT (not a stored column's value — `dateAdd` above is the wrong
+ * shape for this: it shifts a *column*, not "now"). `days` is validated to be
+ * a non-negative integer and spelled directly into the fragment rather than
+ * bound: the legacy statement (`place-shadow.service.ts:192`) binds the
+ * WHOLE modifier string (`'-30 days'`) as one parameter, and MikroORM's raw
+ * fragments do not accept a placeholder inside the modifier argument of a
+ * SQLite date/time function — `datetime('now', ?)` with `'-30 days'` bound
+ * does work in raw SQLite, but composing that shape through a `raw()`
+ * fragment used as a QueryBuilder value needs the modifier already in the
+ * SQL text, the same way `dateAdd` above spells its own day count.
+ */
+export function nowMinusDays(platform: Platform, days: number): RawQueryFragment {
+  if (!Number.isInteger(days) || days < 0) {
+    throw new Error(`sql-functions: nowMinusDays needs a non-negative integer day count, got ${days}`);
+  }
+  if (platform instanceof SqlitePlatform) return raw(`datetime('now', '-${days} days')`);
+  return unsupported(platform);
+}
+
+/**
+ * `TRIM(<col>)`, standalone. **Does NOT compose with `lower()`** to build
+ * `LOWER(TRIM(name))` (Task 0b review M3): `lower()`'s `ref` argument goes
+ * through `column()`, whose regex rejects anything but a bare
+ * `alias.column` reference — `TRIM(name)` fails it — and even if it didn't,
+ * `coalesce()`'s own docstring in this file documents that a
+ * `RawQueryFragment` cannot be nested inside another one (`raw()`'s
+ * `[Symbol.toPrimitive]` only implements the `'string'` coercion hint, which
+ * is the object-key position, not template-literal interpolation). Use
+ * `lowerTrim()` below for the composed shape.
+ */
+export function trim(platform: Platform, ref: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`TRIM(${column(ref)})`);
+  return unsupported(platform);
+}
+
+/**
+ * `LOWER(TRIM(<col>))` as one fragment — the shape `places.service.ts:642`
+ * (`lower(trim(name))`, PL26) actually needs; `lower()`/`trim()` above
+ * cannot be composed to build it (see `trim()`'s docstring, Task 0b review
+ * M3). Typed `RawQueryFragment & symbol`, the same brand `lower()` carries,
+ * for use as a filter KEY: `{ [lowerTrim(platform, 'name')]: lowerParam(...) }`.
+ * SQLite's `LOWER()` is ASCII-only (program rule 18) — unchanged by the
+ * `TRIM()`.
+ */
+export function lowerTrim(platform: Platform, ref: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`LOWER(TRIM(${column(ref)}))`);
+  return unsupported(platform);
+}
+
+/**
+ * `COALESCE(<col>, <fallbackCol>)` — both sides column references, for the
+ * `COALESCE(a, b)` SELECT-projection shape (`days.service.ts:93-94`,
+ * `assignments.service.ts:103-104`, `trip-members.service.ts:116-143`, …).
+ *
+ * Not composed by nesting a `RawQueryFragment` inside this one: MikroORM's
+ * `RawQueryFragment[Symbol.toPrimitive]` only returns a usable value for the
+ * `'string'` coercion hint (object-key position) — a template-literal
+ * `${fragment}` embed uses the `'default'` hint and throws
+ * (`node_modules/@mikro-orm/core/utils/RawQueryFragment.js`, verified
+ * directly, not assumed). So `coalesce`'s second argument is a second
+ * `column()`-validated identifier, spelled into the same fragment as the
+ * first — two columns, one statement, matching `lower`/`lowerParam`'s
+ * two-function split for the same reason (a filter KEY vs a bound VALUE
+ * are different shapes).
+ */
+export function coalesce(platform: Platform, ref: string, fallbackRef: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`COALESCE(${column(ref)}, ${column(fallbackRef)})`);
+  return unsupported(platform);
+}
+
+/**
+ * `COALESCE(<col>, ?)` — the value-side twin of `coalesce()` above, for the
+ * `COALESCE(col, ?)` UPDATE-SET shape (`places.service.ts:344,351,363,…`).
+ * `value` is bound as a genuine parameter, never interpolated.
+ *
+ * Typed `RawQueryFragment & symbol` (widened from a bare `RawQueryFragment`
+ * in Plan 3d Task 0, R3 — `_shared/reservation-visibility.ts`'s
+ * `publicReservationCondition` needs `COALESCE(alias.ingest_state, 'live')`
+ * as a `.where({...})` filter KEY, `{ [coalesceParam(...)]: { $ne: 'staged'
+ * } }`, the same brand `lower()`/`lowerTrim()`/`castInteger()` carry for
+ * that use): every existing UPDATE-SET caller (`Places.repository.ts`'s six
+ * `coalesceParam(...)` assignments into a loosely-typed `data` object) keeps
+ * typechecking unchanged — `RawQueryFragment & symbol` is assignable
+ * anywhere a plain `RawQueryFragment` is expected, a strict widening with no
+ * behaviour change (the function body is untouched).
+ */
+export function coalesceParam(platform: Platform, ref: string, value: string | number | null): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`COALESCE(${column(ref)}, ?)`, [value]);
+  return unsupported(platform);
+}
+
+/**
+ * `COALESCE(?, <col>)` — the MIRROR-IMAGE value-side shape of
+ * {@link coalesceParam} above: the bound value goes FIRST, the column is
+ * the fallback. NOT interchangeable with `coalesceParam` — that one keeps
+ * the EXISTING column unless it is NULL (`places.service.ts`'s own legacy
+ * shape); this one prefers the NEW value unless IT is null, keeping the
+ * existing column only then. `doc-sync.service.ts`'s DS23/DS24
+ * (`upsertItem`'s `file_id=COALESCE(?,file_id)`,
+ * `remote_id=COALESCE(?,remote_id)`, … eight columns, both the plain
+ * `nativeUpdate` and the Kysely `ON CONFLICT` forms) is the shape this
+ * exists for — confirmed genuinely the opposite direction from
+ * `coalesceParam`'s own doc'd precedent by reading the legacy SQL text
+ * literally, not assumed from the function name alone (a same-named
+ * "coalesce" helper reused in the wrong direction silently drops every
+ * incoming update — verified directly against a live row: a `recordAttempt`
+ * call passing a genuinely new `remote_version`/`content_sha256` left both
+ * columns exactly as they were before, since `coalesceParam`'s `COALESCE(col,
+ * ?)` always preferred the non-null existing value).
+ */
+export function coalesceOverride(platform: Platform, value: string | number | null, ref: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`COALESCE(?, ${column(ref)})`, [value]);
+  return unsupported(platform);
+}
+
+/**
+ * `ABS(<col> - ?)`, for use as a filter KEY (the `'string'`-hint coercion
+ * `lower()` above relies on) so it composes with `$lte`/`$gte`:
+ * `{ [absDifference(platform, 'lat', targetLat)]: { $lte: tolerance } }`
+ * renders `WHERE ABS(lat - ?) <= ?`, matching `places.service.ts:651-652`'s
+ * `abs(lat - ?) <= ?` (and the sibling `lng` comparison at `:652`) exactly.
+ * Typed `RawQueryFragment & symbol`, same reason `lower()` is: only a
+ * `string | number | symbol` is a valid computed property name, and the
+ * brand only lives on that typing for values meant to be used as a key.
+ */
+export function absDifference(platform: Platform, ref: string, value: number): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`ABS(${column(ref)} - ?)`, [value]);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3c Task 1 — aggregate SELECT projections (`PlaceShadowPicksRepository
+// .totals`/`countBySource`/`countByLiveRank`, `place-shadow.service.ts:144,
+// 149, 157`). `alias` is a hand-written literal at every call site today
+// (never user input), validated the same way `column()` validates a column
+// reference, so a future caller cannot smuggle SQL through it either.
+// ---------------------------------------------------------------------------
+
+function alias(name: string): string {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`sql-functions: not an alias: ${name}`);
+  }
+  return name;
+}
+
+/** `COUNT(*) as <alias>`, for a single-row totals read or a `GROUP BY` count column. */
+export function countAll(platform: Platform, aliasName: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`COUNT(*) as ${alias(aliasName)}`);
+  return unsupported(platform);
+}
+
+/** `MIN(<col>) as <alias>`. */
+export function minOf(platform: Platform, ref: string, aliasName: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`MIN(${column(ref)}) as ${alias(aliasName)}`);
+  return unsupported(platform);
+}
+
+/** `MAX(<col>) as <alias>`. */
+export function maxOf(platform: Platform, ref: string, aliasName: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`MAX(${column(ref)}) as ${alias(aliasName)}`);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3c Task 6 — `TripMembersRepository.listWithUserAndInviter`
+// (`trip-members.service.ts:117`, TM2): the `role` column, a `CASE WHEN`
+// comparing the joined user's id against the trip's owner id.
+// ---------------------------------------------------------------------------
+
+/**
+ * `CASE WHEN <col> = ? THEN ? ELSE ? END`, for use as a `.select()` value
+ * (chain `.as(aliasName)` at the call site, the same way `coalesce()`'s
+ * callers do — this file does not bake the alias into the SQL text itself
+ * for this one, unlike `countAll`/`minOf`/`maxOf`, because `.as()` already
+ * covers it and a `value`-bearing fragment cannot reuse `alias()`'s bare
+ * identifier validation the same way an aggregate's literal alias does).
+ * `value`/`whenTrue`/`whenFalse` are all passed through `raw()`'s own
+ * parameter escaping, never spliced into the SQL text by this function —
+ * even though today's only caller (TM2's owner/member role label) passes
+ * fixed literal strings, parity is by VALUE, not by whether the string
+ * happens to be a source-code literal at the call site. (Task 6 review's
+ * I1: downstream, MikroORM still formats the FINAL query with every
+ * parameter inlined as an escaped literal in the SQL text it hands
+ * better-sqlite3 — not as a separate bound-params array — so a non-finite
+ * `value` renders as the bare token `NaN`/`Infinity` and fails at PREPARE
+ * time regardless of this function's own escaping; callers must guard a
+ * non-finite `value` before calling.)
+ */
+export function caseWhenEquals(platform: Platform, ref: string, value: number, whenTrue: string, whenFalse: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw(`CASE WHEN ${column(ref)} = ? THEN ? ELSE ? END`, [value, whenTrue, whenFalse]);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3c Task 1 fix round (review M1) — `PlaceShadowPicksRepository
+// .countBySource` (PS5): `.orderBy()` on `countAll()`'s aliased column throws
+// ("Trying to query by not existing property" — `raw()`'s alias carries no
+// literal type for `ExtractRawAliases` to register), and sorting the fetched
+// rows in JS is NOT equivalent to the legacy `ORDER BY count DESC`: SQLite's
+// own sorter is not stable, so on a tie it orders descending by GROUP BY key,
+// while `Array.prototype.sort` (stable) leaves ties in the rows' incoming
+// (ascending) order — verified directly (five sources, two tied pairs).
+// ---------------------------------------------------------------------------
+
+/**
+ * `COUNT(*)` as an ORDER BY EXPRESSION (not an alias — `.orderBy()` cannot
+ * order by `countAll()`'s aliased column; ordering by the expression itself
+ * works and reproduces the legacy `ORDER BY count DESC` tie order exactly).
+ * Typed `RawQueryFragment & symbol`, the same brand `lower()`/`lowerTrim()`
+ * carry, so it is usable as an `.orderBy()` object key:
+ * `.orderBy({ [countAllRef(platform)]: 'desc' })`.
+ */
+export function countAllRef(platform: Platform): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw('COUNT(*)');
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3d Task 0 (R6) — no consumer yet: Tasks 2/4 wire these in as each
+// converts the statement that needs them (`reservations.service.ts` RS11 and
+// RS20 `listUpcoming`, `reservation-visibility.ts` RV2, DY23 in
+// `days.service.ts`). Added here, with their own SQLF-0xx tests pinning the
+// SQLite text against a raw statement on seeded rows, so Tasks 1-6 import a
+// tested helper instead of writing one inline.
+// ---------------------------------------------------------------------------
+
+/**
+ * `<col> GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*'` — "does this
+ * column's TEXT value start with an ISO calendar date (`YYYY-MM-DD`)?", the
+ * legacy `DATED` constant (`reservations.service.ts:120`:
+ * `` `r.reservation_time GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*'` ``,
+ * used at `:453-454` inside RS20's two `CASE WHEN` arms). Spelled with
+ * SQLite's `[0-9]` character-class glob syntax, NOT the plan's shorthand
+ * `'????-??-??*'` — verified directly against the legacy source, not
+ * assumed: a `?` in SQLite GLOB matches any single character (letters
+ * included), so `????-??-??*` is a strictly WIDER, non-equivalent pattern
+ * (it would also match `abcd-ef-gh...`); only the digit-class form matches
+ * the legacy's actual behaviour byte-for-byte.
+ *
+ * A full boolean expression, not a bare value — pair with a `CASE WHEN`
+ * builder or a QB/Kysely raw condition, never nest inside another raw
+ * fragment (see `coalesce()`'s docstring on why nesting doesn't work).
+ * Kysely has no `GLOB` comparison operator (`operator-node.d.ts`'s
+ * `ComparisonOperator` union omits it — verified against the installed
+ * 0.29.6 typings, per the inventory's §19 MikroORM/Kysely capability table)
+ * — this helper's SQLite-only reach is therefore the only portable spelling
+ * for this shape until a second platform is added.
+ */
+export function startsWithIsoDate(platform: Platform, ref: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) {
+    return raw(`${column(ref)} GLOB '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*'`);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * `substr(<col>, <start>[, <length>])`, 1-based on both ends — the legacy
+ * shape at `reservations.service.ts:453` (`substr(r.reservation_time, 1,
+ * 10)`, three-arg), `:454` (`substr(r.reservation_time, 12)`, two-arg — "from
+ * position 12 to the end of the string") and `days.service.ts` DY23
+ * (`SUBSTR(reservation_time, 11)`, same two-arg shape, spelled uppercase in
+ * that statement — SQL function names are case-insensitive, so this helper's
+ * lowercase spelling is behaviourally identical). `length` is optional,
+ * matching SQLite's own two-arg `substr(X, Y)` form (everything from `Y` to
+ * the end) — passing it renders the three-arg form instead. `start` and
+ * `length` are validated integers and spelled directly (not bound): they are
+ * always source-code constants at every known call site (`1`, `10`, `11`,
+ * `12`), never user input, the same trust boundary `dateAdd`'s day count and
+ * `columnIncrementedBy`'s amount already rely on in this file.
+ */
+export function substring(platform: Platform, ref: string, start: number, length?: number): RawQueryFragment {
+  if (!Number.isInteger(start) || start < 1) {
+    throw new Error(`sql-functions: substring needs a 1-based integer start, got ${start}`);
+  }
+  if (length !== undefined && (!Number.isInteger(length) || length < 0)) {
+    throw new Error(`sql-functions: substring needs a non-negative integer length, got ${length}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    if (length === undefined) return raw(`substr(${column(ref)}, ${start})`);
+    return raw(`substr(${column(ref)}, ${start}, ${length})`);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * A part of a `concat()` expression: either a column reference (rendered
+ * through `column()`, the same identifier validation every other helper in
+ * this file applies) or a plain value bound as a genuine parameter (`?`) —
+ * never interpolated, even for what today's only legacy caller spells as a
+ * literal (`'T'` in `d.date || 'T' || a.check_in`,
+ * `reservations.service.ts:475, :493`): a bound constant and an interpolated
+ * one produce byte-identical SQLite behaviour for a plain string, and
+ * binding is the shape every other value-side helper in this file already
+ * prefers (`coalesceParam`, `lowerParam`, `absDifference`).
+ */
+export type ConcatPart = { column: string } | { value: string };
+
+/**
+ * `<part> || <part> || …` — SQLite (and Postgres) string concatenation, the
+ * legacy shape at `reservations.service.ts:475, :493`
+ * (`d.date || 'T' || a.check_in`, RS20's two check-in/check-out arms) and
+ * `days.service.ts` DY23 (`:date || SUBSTR(reservation_time, 11)`, inside an
+ * `UPDATE … SET`). Needs at least two parts — a one-part "concatenation" is
+ * a caller bug, not a legitimate call. Each part is a `ConcatPart` (see its
+ * own docstring) rather than a bare string, so a column reference and a
+ * bound literal can never be confused with each other the way an untyped
+ * `...parts: string[]` would invite (a plain string could mean either).
+ *
+ * Deliberately does NOT accept a nested `RawQueryFragment` as a part (e.g.
+ * the output of `substring()` above) — the same limitation `coalesce()`'s
+ * docstring documents: `RawQueryFragment`'s `[Symbol.toPrimitive]` only
+ * implements the `'string'` coercion hint (the object-key position), not the
+ * `'default'` hint a template-literal embed or an array-join would need, so
+ * composing `concat(platform, substring(...), ...)` throws at the `raw()`
+ * boundary rather than rendering silently wrong SQL. A caller that needs
+ * `SUBSTR(...)` as one side of a `||` builds that one statement directly
+ * (Kysely's `'||'` binary operator, per the inventory's §17a/§19), the same
+ * way RS20's own CASE/CTE shape is built outside this file's helpers.
+ */
+export function concat(platform: Platform, ...parts: readonly ConcatPart[]): RawQueryFragment {
+  if (parts.length < 2) {
+    throw new Error(`sql-functions: concat needs at least two parts, got ${parts.length}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    const bindings: string[] = [];
+    const sql = parts
+      .map((part) => {
+        if ('column' in part) return column(part.column);
+        bindings.push(part.value);
+        return '?';
+      })
+      .join(' || ');
+    return raw(sql, bindings);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * `CAST(<col> AS INTEGER)` — the legacy shape at `reservations.service.ts:471,
+ * :489` (inside RS20's correlated `stay_first_reservation_id`/title
+ * subqueries: `CAST(res.accommodation_id AS INTEGER) = a.id`) and
+ * `reservation-visibility.ts:106-107` (RV2's `publicStaySql`:
+ * `CAST(vr.accommodation_id AS INTEGER) = ${alias}.id`). Exists specifically
+ * for `reservations.accommodation_id`, a TEXT column holding integer ids
+ * with no FK (§18.1 of the inventory — some rows read back as `"14.0"`):
+ * casting it to INTEGER before comparing against a genuine INTEGER column
+ * (`day_accommodations.id`) applies numeric affinity to BOTH sides, matching
+ * `"14"` and `"14.0"` alike, the same way the legacy statement does.
+ *
+ * Typed `RawQueryFragment & symbol`, the same brand `lower()`/`lowerTrim()`
+ * carry: both known legacy call sites compare the cast against ANOTHER
+ * COLUMN, not a bound value (`= a.id`, `= ${alias}.id`) — the shape is
+ * `{ [castInteger(platform, 'vr.accommodation_id')]: columnRef(platform,
+ * 'a.id') }`, pairing this helper's filter-KEY brand with `columnRef()`'s
+ * existing VALUE-side column reference. The brand also lets it appear in a
+ * `.select()` projection via `.as(alias)` (the `lowerTrim`/SQLF-027 dual-use
+ * precedent) for a caller that only needs the cast INTEGER value itself.
+ */
+export function castInteger(platform: Platform, ref: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`CAST(${column(ref)} AS INTEGER)`);
+  return unsupported(platform);
+}
+
+/**
+ * `ABS(JULIANDAY(<col>) - JULIANDAY(?))` — the legacy shape at
+ * `reservations.service.ts:307` (RS11, `resolveDayIdFromTime`'s
+ * nearest-day fallback: `ORDER BY ABS(JULIANDAY(date) - JULIANDAY(?)) ASC,
+ * date ASC LIMIT 1`), which clamps an imported booking's date to the
+ * closest day row in the trip when no exact match exists. `isoDate` is
+ * bound as a genuine parameter (never interpolated), matching the legacy
+ * statement's own bind. Distinct from `absDifference()` above:
+ * `absDifference` is `ABS(<col> - ?)` on plain NUMERIC values (for a
+ * lat/lng tolerance filter); this helper compares two `JULIANDAY(...)`
+ * calendar values. Typed `RawQueryFragment & symbol`, the same brand
+ * `countAllRef()` carries, so it is usable as an `.orderBy()` object key —
+ * `.orderBy({ [dayDistance(platform, 'date', isoDate)]: 'asc' })` —
+ * matching the legacy's own `ORDER BY ABS(JULIANDAY(...) - JULIANDAY(?)) ASC`
+ * shape exactly (an aliased column cannot be ordered by, the same
+ * `ExtractRawAliases` limitation `countAllRef`'s own docstring / SQLF-024's
+ * comment documents; ordering by the EXPRESSION itself is what works).
+ */
+export function dayDistance(platform: Platform, ref: string, isoDate: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`ABS(JULIANDAY(${column(ref)}) - JULIANDAY(?))`, [isoDate]);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3d Task 0 review (H1/L1) — the five helpers above return a MikroORM
+// `RawQueryFragment`. Handed into a Kysely statement, a `RawQueryFragment`
+// stringifies through its own `[Symbol.toPrimitive]('string')` coercion into
+// the literal text `?` (its parameter-placeholder marker, meant for the
+// MikroORM QueryBuilder's OWN parameter interpolation, not Kysely's) — Kysely
+// binds it as an actual `?` value parameter and the statement fails at
+// execution (verified directly, not assumed: `db.selectFrom(...).where(...,
+// startsWithIsoDate(platform, 'col'))` throws `SqliteError: near "?": syntax
+// error` the first time it runs). Task 2 absorbed this finding (its report,
+// H1/L1) — these are genuinely separate functions, not a wrapper over the
+// ones above, because a Kysely `Expression` and a MikroORM `RawQueryFragment`
+// are different types with no conversion between them. Each takes the
+// caller's own `ExpressionBuilder<DB, TB>` (the same "no consumer-facing
+// generic DB" shape `_shared/reservation-visibility.ts`'s `publicStayExists`
+// documents is the only one that survives `tsc` for a shared Kysely helper —
+// unlike that one, these ARE fully generic over `<DB, TB>`, because they only
+// ever call `eb.fn`/`eb.cast`/`eb(...)`, none of which hit the QueryBuilder
+// method-chaining inference limit that forced `publicStayExists` to fix its
+// shape). Platform-dispatched and fail-closed like every helper above; each
+// has an SQLF-0xx test pinning its compiled `{sql, parameters}` AND a
+// raw-statement equivalence on seeded rows (`tests/unit/db/dialect/sql-functions.test.ts`).
+// ---------------------------------------------------------------------------
+
+/**
+ * The Kysely-expression twin of {@link startsWithIsoDate}: `<ref> GLOB
+ * '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*'`, spelled through SQLite's
+ * function form (`glob(X, Y)` is exactly `Y GLOB X` — the inventory's own
+ * §19 finding, since Kysely's `ComparisonOperator` union has no `GLOB`
+ * entry). Returns a boolean `Expression<SqlBool>`, usable in a `.where()`
+ * or inside a `CASE WHEN` condition. Same digit-class pattern as the
+ * MikroORM version — NOT the wider `'????-??-??*'` shorthand (a `?` in
+ * SQLite GLOB matches any character, letters included).
+ */
+export function startsWithIsoDateKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  ref: ReferenceExpression<DB, TB>,
+): ExpressionWrapper<DB, TB, SqlBool> {
+  if (platform instanceof SqlitePlatform) {
+    return eb.fn<SqlBool>('glob', [eb.val('[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*'), ref]);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * The Kysely-expression twin of {@link substring}: `substr(<ref>,
+ * <start>[, <length>])`, 1-based on both ends. `start`/`length` are
+ * validated integers, the same guard `substring()` above applies, and bound
+ * as genuine parameters here (`eb.val`) rather than spelled into the SQL
+ * text — Kysely's `fn()` takes `ReferenceExpression`s, not a raw text
+ * fragment, so there is no equivalent "spell a constant into the SQL"
+ * shape to match; a bound integer literal renders identically.
+ */
+export function substringKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  ref: ReferenceExpression<DB, TB>,
+  start: number,
+  length?: number,
+): ExpressionWrapper<DB, TB, string> {
+  if (!Number.isInteger(start) || start < 1) {
+    throw new Error(`sql-functions: substringKysely needs a 1-based integer start, got ${start}`);
+  }
+  if (length !== undefined && (!Number.isInteger(length) || length < 0)) {
+    throw new Error(`sql-functions: substringKysely needs a non-negative integer length, got ${length}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    const args: ReferenceExpression<DB, TB>[] = length === undefined
+      ? [ref, eb.val(start)]
+      : [ref, eb.val(start), eb.val(length)];
+    return eb.fn<string>('substr', args);
+  }
+  return unsupported(platform);
+}
+
+/** A part of a `concatKysely()` expression — a column reference, a bound value, or a nested Kysely `Expression<string>` (composes freely, unlike `concat()`'s MikroORM `RawQueryFragment` form). */
+export type KyselyConcatPart<DB, TB extends keyof DB> =
+  | { column: StringReference<DB, TB> }
+  | { value: string }
+  | { expression: Expression<string> };
+
+/**
+ * The Kysely-expression twin of {@link concat}: `<part> || <part> || …`,
+ * SQLite's/Postgres's string concatenation operator, built through the
+ * expression builder's own binary-operator call (`eb(lhs, '||', rhs)`) so
+ * it composes with {@link substringKysely}/{@link castIntegerKysely} —
+ * exactly the composition `concat()`'s MikroORM form cannot do (its
+ * docstring explains why).
+ */
+export function concatKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  ...parts: readonly KyselyConcatPart<DB, TB>[]
+): ExpressionWrapper<DB, TB, string> {
+  if (parts.length < 2) {
+    throw new Error(`sql-functions: concatKysely needs at least two parts, got ${parts.length}`);
+  }
+  if (!(platform instanceof SqlitePlatform)) return unsupported(platform);
+  const operand = (part: KyselyConcatPart<DB, TB>): Expression<string> =>
+    'column' in part ? eb.ref(part.column).$castTo<string>() : 'value' in part ? eb.val(part.value) : part.expression;
+  let acc: Expression<string> = operand(parts[0]!);
+  for (const part of parts.slice(1)) {
+    acc = eb(acc, '||', operand(part));
+  }
+  // The loop above always runs at least once (the `parts.length < 2` guard
+  // above throws otherwise), so `acc` is always the result of the `eb(...)`
+  // binary-operator call — a real `ExpressionWrapper`, not the bare
+  // `Expression` interface `operand()`'s own return type declares.
+  return acc as ExpressionWrapper<DB, TB, string>;
+}
+
+/**
+ * The Kysely-expression twin of {@link castInteger}: `CAST(<ref> AS
+ * INTEGER)`, for `reservations.accommodation_id` (TEXT) compared against an
+ * INTEGER column inside a Kysely statement (RS20/RV2's join shape — a
+ * correlated `EXISTS`/scalar-subquery context the MikroORM QueryBuilder
+ * cannot express, per the inventory's own T6 ruling).
+ */
+export function castIntegerKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  ref: ReferenceExpression<DB, TB>,
+): ExpressionWrapper<DB, TB, number> {
+  if (platform instanceof SqlitePlatform) return eb.cast<number>(ref, 'integer');
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3f Task 0 (R9) — no consumer yet: Task 2 (`collateNoCase`, SH9's
+// `school-holidays.service.ts#checkName` duplicate-name guard) and Task 4
+// (`nowMinusHours`, RJ4's `reminder-jobs.service.ts#todoTick`
+// `datetime('now', '-20 hours')`) wire these in when each converts the
+// statement that needs them. `lowerTrimParam` (AT31's value side, atlas's
+// bucket-list dedup) is Task 1's. Added here, with their own SQLF-0xx tests
+// pinning the SQLite text against a raw statement on seeded rows, so each
+// task imports a tested helper instead of writing one inline.
+// ---------------------------------------------------------------------------
+
+/**
+ * A case-insensitive column reference via SQLite's `NOCASE` collating
+ * sequence, for use as a filter's object key — the same `{ [collateNoCase(
+ * platform, 'name')]: value }` shape `lower()` documents, rendering `WHERE
+ * name COLLATE NOCASE = <value-side>`. The legacy statement this replaces
+ * (`school-holidays.service.ts:50`, SH9) spells the COLLATE on the VALUE
+ * side instead (`name = ? COLLATE NOCASE`) — textually different, but SQLite
+ * resolves a binary comparison's collating sequence from the FIRST operand
+ * that carries an explicit `COLLATE`, scanning left to right, so `col
+ * COLLATE NOCASE = ?` and `col = ? COLLATE NOCASE` select the same collation
+ * (NOCASE) for the whole comparison either way — verified directly
+ * (SQLF-060: both forms select the identical row set on a mixed-case
+ * fixture), not assumed from the operator's documented precedence alone.
+ *
+ * **Not the same helper as `lower()`, and not reusable in its place.**
+ * SQLite's built-in `NOCASE` collation is documented to fold ONLY the 26
+ * ASCII letters, exactly like `LOWER()`'s own ASCII-only fold (program rule
+ * 18) — verified directly against `better-sqlite3` (SQLF-061): on every
+ * non-ASCII fixture this file's own `LOWER()` test (SQLF-014) already
+ * carries, `x = y COLLATE NOCASE` and `LOWER(x) = LOWER(y)` agree, letter for
+ * letter — neither engine folds a non-ASCII case pair. So `collateNoCase`
+ * does NOT diverge from `lower()` on any input constructed here; it is a
+ * NEW helper anyway (per R9's own instruction) because the two are
+ * textually different SQL constructs matching two textually different
+ * legacy statements (`COLLATE NOCASE` vs `LOWER(...)`), and because a
+ * `COLLATE`-based comparison lets SQLite use an index on the un-wrapped
+ * column in a way `LOWER(col) = ?` cannot — a real, if not row-visible,
+ * difference between the two shapes.
+ */
+export function collateNoCase(platform: Platform, ref: string): RawQueryFragment & symbol {
+  if (platform instanceof SqlitePlatform) return raw(`${column(ref)} COLLATE NOCASE`);
+  return unsupported(platform);
+}
+
+/**
+ * `datetime('now', '-N hours')` — the hour-granularity sibling of
+ * `nowMinusDays()` above, for `reminder-jobs.service.ts#todoTick`'s
+ * `datetime('now', '-20 hours')` (RJ4) — 20 hours is not expressible as
+ * `nowMinusDays` with a fractional day. Same validation shape as
+ * `nowMinusDays` (a non-negative integer, spelled directly into the
+ * fragment rather than bound — MikroORM's raw fragments do not accept a
+ * placeholder inside a SQLite date/time function's modifier argument, the
+ * same reasoning `nowMinusDays`'s own docstring gives).
+ */
+export function nowMinusHours(platform: Platform, hours: number): RawQueryFragment {
+  if (!Number.isInteger(hours) || hours < 0) {
+    throw new Error(`sql-functions: nowMinusHours needs a non-negative integer hour count, got ${hours}`);
+  }
+  if (platform instanceof SqlitePlatform) return raw(`datetime('now', '-${hours} hours')`);
+  return unsupported(platform);
+}
+
+/**
+ * The value-side twin of `lowerTrim()`: `LOWER(TRIM(?))` bound with the RAW,
+ * untransformed value — confirmed genuinely missing by reading this file's
+ * full export list before adding it (R9), not assumed from the inventory's
+ * own flag. Pairs with `lowerTrim()` as a filter KEY for the composed
+ * `LOWER(TRIM(<column>)) = LOWER(TRIM(?))` shape
+ * `atlas.service.ts:876-877`'s AT31 needs (`lower(trim(name)) =
+ * lower(trim(?))`), the same "bind the raw value, let SQL apply the SAME
+ * transform to both sides" reasoning `lowerParam()`'s own docstring gives —
+ * do NOT pre-trim/pre-lower the value in JS before calling this (program
+ * rule 18: mixing engines is the bug this pairing exists to avoid).
+ */
+export function lowerTrimParam(platform: Platform, value: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) return raw('LOWER(TRIM(?))', [value]);
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3g Task 0 (R1) — no consumer yet: Task 1 (`getJourneyFull`'s gallery
+// read) and Task 3 (`getPublicJourney`'s gallery read) each fold this into
+// their own rebuild of `journey-gallery-order.ts`'s `GALLERY_CHRONOLOGICAL_ORDER`
+// text (a `COALESCE(NULLIF(tp.taken_at, ''), <correlated MIN+concat subquery>,
+// <this>)` ORDER BY, worked out in full in Task 0's report for both to paste
+// in verbatim, neither re-deriving it). Added here, Kysely-only (no MikroORM
+// `raw()` sibling): the shape it exists for is genuinely Kysely-only (a
+// correlated scalar subquery cannot be expressed through the MikroORM
+// QueryBuilder — the same "T6 ruling" `castIntegerKysely`'s own docstring
+// cites for RS20/RV2), and nothing else in this plan's inventory needs a
+// MikroORM-form epoch-to-ISO conversion (§6: "no other strftime/julianday
+// sites found elsewhere in this cluster"). A raw twin can be added later,
+// same as every other helper here, the moment a real consumer needs one.
+// ---------------------------------------------------------------------------
+
+/**
+ * `strftime('%Y-%m-%dT%H:%M:%SZ', <ref> / 1000, 'unixepoch')` — the last of
+ * `GALLERY_CHRONOLOGICAL_ORDER`'s three fallback tiers (R1): when a gallery
+ * photo has neither a capture time (`tp.taken_at`) nor a linked entry to
+ * borrow a date from, the moment it was added is what is left to order by.
+ * `<ref>` is an epoch-MILLISECONDS column (`journey_photos.created_at`, like
+ * every other `*_at` epoch column in this codebase) — SQLite's `unixepoch`
+ * modifier expects whole SECONDS, so the division is load-bearing, not
+ * decorative, and matches the legacy text's own `gp.created_at / 1000`
+ * exactly. SQLite's `/` on two integers truncates instead of rounding; that
+ * sub-second loss is the legacy statement's own behaviour, preserved here
+ * rather than "fixed" into a float divide that would render a different ISO
+ * string for any timestamp not an exact multiple of 1000ms.
+ *
+ * Named for what it computes, not the SQL function it spells — matching
+ * every other `*Kysely` twin in this file (`castIntegerKysely`, not
+ * `castKysely`; `startsWithIsoDateKysely`, not `globKysely`).
+ */
+export function unixEpochToIsoKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  ref: ReferenceExpression<DB, TB>,
+): ExpressionWrapper<DB, TB, string> {
+  if (platform instanceof SqlitePlatform) {
+    const seconds = eb(ref, '/', eb.val(1000));
+    return eb.fn<string>('strftime', [eb.val('%Y-%m-%dT%H:%M:%SZ'), seconds, eb.val('unixepoch')]);
+  }
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3h Task 0 — no consumer yet: Task 3 (`dawarich-sync.service.ts`'s
+// `listTripsToSync`, DSY2 — `date('now','-400 days')` / `date('now','+1
+// day')`) and Task 4 (`route-usage.service.ts`'s `purgeExpired`, RU4 —
+// `date('now', ?)` bound with the modifier `-${RETENTION_DAYS} days`, and
+// RETENTION_DAYS (`route-usage.service.ts:13`) is a compile-time module
+// constant (`400`), not a runtime value — so RU4's "bound parameter" and
+// DSY2's "literal" are the SAME shape at the call site once the modifier is
+// known, confirmed directly against both files' actual source rather than
+// assumed from the legacy SQL's own binding style) wire `nowDateOffset` in
+// when each converts its own statement.
+//
+// Plan 3f's own four `date('now')` sites (atlas.service.ts AT39/AT42/AT44/
+// AT45 — 3g's inventory's own open question, inherited from 3f and never
+// resolved until now) do NOT go through a dialect helper at all: `todayUtc()`
+// (a `@trek/shared` JS function) resolves the calendar date once in the
+// CALLING SERVICE (`atlas.service.ts:912`, `const trip = await
+// this.trips.lastStartedTrip(userId, todayUtc())`) and the repository binds
+// it as a plain parameter (`Trips.repository.ts#lastStartedTrip`:
+// `.where((eb) => eb(eb.fn.coalesce('t.start_date', 't.end_date'), '<=',
+// today))`) — confirmed by reading the actual converted code at HEAD, not
+// the plan document's description of it. That pattern covers a BARE
+// `date('now')` (no offset) cleanly, and needs no new helper here. It does
+// not extend to an OFFSET the way DSY2/RU4 need without every call site
+// re-deriving day arithmetic in JS by hand, so this file instead grows the
+// sibling `nowMinusDays`/`nowMinusHours` already establish for exactly this
+// family (Plan 3c Task 0b/Plan 3f Task 0 R9): a signed day-count offset from
+// "now", spelled into the fragment after integer validation, the same
+// reasoning those two helpers give (MikroORM's raw fragments do not accept a
+// placeholder inside a SQLite date/time function's modifier argument).
+// `PlaceShadowPicksRepository.expireStale` (Plan 3c Task 1) is this shape's
+// own closest working precedent — a retention-window purge built on
+// `nowMinusDays` exactly the way `RouteUsageDailyRepository`'s own purge
+// (RU4) will be built on `nowDateOffset` below.
+// ---------------------------------------------------------------------------
+
+/**
+ * `date('now', '<sign>N days')` — the SQLite clock's CALENDAR DATE (`date()`,
+ * not `datetime()` — `nowMinusDays` above is the wrong shape for this: it
+ * targets `datetime()`, and only ever subtracts), shifted by a signed whole
+ * day count. Unlike `nowMinusDays`, `days` may be POSITIVE (forward),
+ * NEGATIVE (backward) or zero — `dawarich-sync.service.ts`'s
+ * `listTripsToSync` (DSY2) needs both directions in the SAME statement
+ * (`date('now','-400 days')` for the trailing edge, `date('now','+1 day')`
+ * for the leading one). `days` is spelled directly into the fragment (not
+ * bound), the same reasoning `nowMinusDays`'s own docstring gives.
+ *
+ * Verified directly (not assumed) that SQLite's modifier keyword tolerates
+ * the singular/plural mismatch between the two legacy texts (`'+1 day'`
+ * singular, `'-400 days'` plural): `date('now','+1 day')` and
+ * `date('now','+1 days')` render the identical result against a live
+ * `better-sqlite3` connection, so this helper's always-plural spelling is
+ * behaviourally identical to both legacy statements, not just the plural one.
+ */
+export function nowDateOffset(platform: Platform, days: number): RawQueryFragment {
+  if (!Number.isInteger(days)) {
+    throw new Error(`sql-functions: nowDateOffset needs an integer day count, got ${days}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    const sign = days < 0 ? '-' : '+';
+    return raw(`date('now', '${sign}${Math.abs(days)} days')`);
+  }
+  return unsupported(platform);
+}
+
+/**
+ * `datetime('now', '+N seconds')` — the seconds-granularity, ADDING sibling
+ * of `nowMinusDays`/`nowMinusHours` above: the shape `doc-sync.service.ts`'s
+ * `upsertItem` (DS23, inside an `ON CONFLICT DO UPDATE`'s `CASE WHEN`; DS26,
+ * inside the sibling `INSERT ... VALUES`) and `recordLinkFailure` (a third,
+ * structurally identical call site found re-reading the file at HEAD —
+ * `next_attempt_at = datetime('now', '+' || ? || ' seconds')`,
+ * `doc-sync.service.ts:967`, not individually numbered in the plan's own
+ * inventory) all need: a caller-computed backoff window (`backoffSeconds(
+ * ...)`, a genuine RUNTIME value, never a source-code constant the way
+ * `nowMinusDays`'s callers' day counts are) added to the database clock.
+ * `seconds` is validated non-negative-integer and spelled directly into the
+ * fragment — the same reasoning (and the same MikroORM raw-fragment
+ * placeholder limitation) `nowMinusDays`'s own docstring gives; every known
+ * call site's `seconds` argument is already a JS-computed `number`, never
+ * user input, the same trust boundary this file relies on elsewhere
+ * (`dateAdd`'s day count, `substring`'s start/length).
+ */
+export function nowPlusSeconds(platform: Platform, seconds: number): RawQueryFragment {
+  if (!Number.isInteger(seconds) || seconds < 0) {
+    throw new Error(`sql-functions: nowPlusSeconds needs a non-negative integer second count, got ${seconds}`);
+  }
+  if (platform instanceof SqlitePlatform) return raw(`datetime('now', '+${seconds} seconds')`);
+  return unsupported(platform);
+}
+
+/**
+ * The Kysely-expression twin of {@link nowPlusSeconds}: DS23/DS24's
+ * `ON CONFLICT ... DO UPDATE` / `INSERT ... VALUES` (R3) is a hand-typed
+ * Kysely statement — MikroORM's `em.upsert` cannot express a
+ * partial-unique-index conflict target (R3's own ruling) — so the
+ * `next_attempt_at` computation inside its `CASE WHEN` needs a Kysely
+ * `Expression`, not a MikroORM `RawQueryFragment` (SQLF-048: a
+ * `RawQueryFragment` throws when handed into a Kysely statement). Same
+ * validation, same always-non-negative-integer trust boundary as the
+ * MikroORM form above.
+ */
+export function nowPlusSecondsKysely<DB, TB extends keyof DB>(
+  platform: Platform,
+  eb: ExpressionBuilder<DB, TB>,
+  seconds: number,
+): ExpressionWrapper<DB, TB, string> {
+  if (!Number.isInteger(seconds) || seconds < 0) {
+    throw new Error(`sql-functions: nowPlusSecondsKysely needs a non-negative integer second count, got ${seconds}`);
+  }
+  if (platform instanceof SqlitePlatform) {
+    return eb.fn<string>('datetime', [eb.val('now'), eb.val(`+${seconds} seconds`)]);
+  }
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// Plan 3h Task 5 (doc-sync) — `FOUND_AGAIN` (`doc-sync.service.ts:53-54`), the
+// module-level SQL-text CASE constant reused by four legacy UPDATEs (DS2
+// `relocate`, DS3 `rename_remote`, DS5 `rename_local`, DS12 `touch`). Unlike
+// every other CASE in this file's DS2-DS12 neighbourhood — whose WHEN
+// condition binds a value already known in JS at the call site (a boolean
+// flag, a state string), so the whole CASE collapses to a plain JS ternary
+// deciding which field to include in a `nativeUpdate` call — this one
+// compares the ROW'S OWN CURRENT `state`/`file_id` columns, which are not
+// knowable until the UPDATE executes. That is genuinely SQL-level, and the
+// four call sites share one method (`DocumentSyncItemsRepository`'s private
+// `foundAgain` builder) rather than four independent re-derivations, per the
+// task's own instruction to keep `FOUND_AGAIN` "a reusable typed CASE
+// expression ... consumed by all four".
+// ---------------------------------------------------------------------------
+
+/**
+ * `CASE WHEN <stateRef> = 'remote_missing' AND <fileIdRef> IS NOT NULL THEN
+ * 'synced' ELSE <stateRef> END` — doc-sync's `FOUND_AGAIN` clause, for the
+ * `state` column of an UPDATE `document_sync_items` SET list. Only a copy
+ * that is BOTH on record as missing AND still paired to a file recovers this
+ * way; every other state (`error`, `conflict`, a row with no file at all)
+ * passes through unchanged. `remote_missing_at` is cleared unconditionally
+ * by the SAME UPDATE's own `remote_missing_at = NULL` (a plain value, not
+ * part of this fragment — the caller sets it alongside).
+ */
+export function foundAgainState(platform: Platform, stateRef: string, fileIdRef: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) {
+    return raw(
+      `CASE WHEN ${column(stateRef)} = 'remote_missing' AND ${column(fileIdRef)} IS NOT NULL THEN 'synced' ELSE ${column(stateRef)} END`,
+    );
+  }
+  return unsupported(platform);
+}
+
+/**
+ * The Kysely-expression twin of {@link currentTimestamp}: the bare
+ * `CURRENT_TIMESTAMP` keyword, for a value position inside a hand-typed
+ * Kysely statement (DS24's `ON CONFLICT ... DO UPDATE SET last_seen_at =
+ * CURRENT_TIMESTAMP` — R3's partial-index upsert). Verified directly against
+ * `better-sqlite3` that SQLite accepts the bare keyword (`SELECT
+ * CURRENT_TIMESTAMP`) but rejects it called as a function
+ * (`SELECT CURRENT_TIMESTAMP()` → `near "(": syntax error`), so
+ * `eb.fn('current_timestamp', [])` — every other helper in this file's
+ * usual Kysely shape — is not an option here; the whole point of a keyword
+ * literal is that it takes no parentheses. This is this file's one
+ * Kysely-side use of the `sql` template tag — confined here, the sanctioned
+ * escape hatch this file already is for every raw-SQL spelling in the
+ * codebase (the MikroORM helpers above use `raw()` for the identical
+ * reason), never inline in a repository (the TRAP list's "Kysely `sql`
+ * banned under repositories" is about repository FILES, not this one).
+ */
+export function currentTimestampKysely(platform: Platform): RawBuilder<string> {
+  if (platform instanceof SqlitePlatform) return sql<string>`CURRENT_TIMESTAMP`;
+  return unsupported(platform);
+}
+
+// ---------------------------------------------------------------------------
+// `UsersRepository.setImmichSettings` (IM4, #2475): the self-signed switch is
+// trusted for ONE server, so whether a null incoming value may keep the stored
+// choice depends on whether the URL written in the same SET list is the URL
+// already stored. Like `foundAgainState` above, the WHEN condition reads the
+// ROW'S OWN CURRENT column, which is not knowable in JS before the UPDATE runs
+// — a read-then-write would be two statements where the legacy SQL had one.
+// ---------------------------------------------------------------------------
+
+/**
+ * `CASE WHEN <keyRef> IS ? THEN COALESCE(?, <ref>) ELSE COALESCE(?, 0) END` —
+ * {@link coalesceOverride}'s "new value wins unless it is null" shape, but the
+ * stored column is only a valid fallback WHILE the key column still holds
+ * `keyValue` (the value the same UPDATE writes to it). Once the key changes,
+ * a null `value` falls back to the column's default `0` instead of a choice
+ * made for a different key. SET expressions see the row as it was before the
+ * UPDATE, so `<keyRef> IS ?` compares the STORED key with the new one even
+ * though the same statement overwrites it. `value` is bound twice on purpose:
+ * the fragment has two value slots and `raw()` binds positionally.
+ */
+export function coalesceOverrideWhileSame(platform: Platform, value: number | null, ref: string, keyRef: string, keyValue: string): RawQueryFragment {
+  if (platform instanceof SqlitePlatform) {
+    return raw(`CASE WHEN ${column(keyRef)} IS ? THEN COALESCE(?, ${column(ref)}) ELSE COALESCE(?, 0) END`, [keyValue, value, value]);
+  }
+  return unsupported(platform);
+}
+