ekklesiaandClaude Opus 5
6b6b77c105
Every PostgreSQL connection this repository opened was plaintext, in every environment: no connection site set `ssl` at all, so credentials, session tokens, and row data crossed the network in the clear and nothing in configuration, startup, or `pnpm doctor` said so. The public identity URL boundary was also looser than it appeared. `core/src/database/transport.ts` is now the one typed policy. It has exactly two modes: `verify-full` (TLS required, certificate chain verified, and server identity verified against the configured host — the production default) and `disable` (the development/test default, refused outright in production). There is deliberately no encryption-only `require` mode, no chain-only `verify-ca`, and no `rejectUnauthorized: false` escape hatch anywhere in the configuration surface; every loose or aliased spelling is rejected in both environments, so a typo never quietly becomes a weaker mode. Production has no plaintext exception at all, not even for a loopback database — a connection string cannot prove the database is process-local. Verification is certificate *and* hostname. The policy supplies an explicit `checkServerIdentity` pinned to the host parsed from DATABASE_URL, because the pinned driver sets TLS `servername` only for non-IP hosts and Node performs no identity check when it is unset — so `rejectUnauthorized: true` alone accepts a certificate from any host the trusted CA ever signed when connecting by IP. Both halves are proven against a real TLS-enabled PostgreSQL, including that the same connection without the pinned callback succeeds. Every CA, certificate, and key is generated at test runtime and deleted afterwards. A DATABASE_URL may no longer carry its own TLS parameters. The pinned driver merges parsed connection-string values over explicitly passed options, so a `?sslmode=disable` in the URL would silently replace the policy's verified `ssl` object; that now fails with a stable code, reported by both `pnpm doctor` and the migration CLIs rather than as "failed unexpectedly". One shared environment reader keeps `process.env` out of Core's reusable constructors, and every executable that opens a connection resolves the policy identically: the API (validated before any pool, Better Auth instance, module runtime, or listener exists), both migration commands, the bootstrap CLI, and Doctor's own connection. Doctor reports it as a blocking failure, never a warning, naming only the effective mode. Separately, the identity base URL and every trusted origin must now be exactly one canonical origin — the WHATWG origin serialization must equal the supplied string — so a path, trailing slash, credentials, explicit default port, or non-canonical case is rejected rather than normalized into something that no longer matches what a browser sends. Production's loopback rejection now classifies the address instead of comparing against three literals, covering `.localhost`, all of 127.0.0.0/8, 0.0.0.0, `::`, expanded and IPv4-mapped forms. This is a configuration-shape guarantee only: it does not resolve DNS or prove reachability, and TLS protects the connection, not the exposure. Co-Authored-By: Claude Opus 5 <[email protected]>
47 lines
2.0 KiB
TypeScript
47 lines
2.0 KiB
TypeScript
import {
|
|
assertProductionDatabaseTransport,
|
|
type DatabaseTransportEnvironment,
|
|
type DatabaseTransportPolicy,
|
|
createDatabaseTransportPolicy,
|
|
} from "../database/transport.js";
|
|
|
|
/**
|
|
* The one place every Core-owned executable reads its database transport policy from the process
|
|
* environment, so `pnpm doctor`, `pnpm migrations:plan`, `pnpm migrations:apply`, and
|
|
* `pnpm authorization:bootstrap-owner` cannot drift from each other or from `apps/api`.
|
|
*
|
|
* Environment reading lives here, in the executable layer, deliberately: the reusable Core
|
|
* database/migration constructors keep taking explicit typed inputs and never touch `process.env`.
|
|
* `NODE_ENV` is interpreted exactly as `apps/api` interprets it — only the literal string
|
|
* `"development"` relaxes anything, so an unset or misspelled value validates as production.
|
|
*/
|
|
export function readDatabaseTransportFromEnvironment(): {
|
|
readonly environment: DatabaseTransportEnvironment;
|
|
readonly transport: DatabaseTransportPolicy;
|
|
} {
|
|
const environment: DatabaseTransportEnvironment =
|
|
process.env.NODE_ENV === "development" ? "development" : "production";
|
|
const transport = createDatabaseTransportPolicy(
|
|
{
|
|
...(process.env.EKKLESIA_DATABASE_CA === undefined
|
|
? {}
|
|
: { certificateAuthority: process.env.EKKLESIA_DATABASE_CA }),
|
|
...(process.env.EKKLESIA_DATABASE_TLS_MODE === undefined
|
|
? {}
|
|
: { mode: process.env.EKKLESIA_DATABASE_TLS_MODE }),
|
|
},
|
|
{ environment },
|
|
);
|
|
return { environment, transport };
|
|
}
|
|
|
|
/**
|
|
* Resolves the policy and asserts it is safe for the given database URL before any client, pool,
|
|
* or connection is constructed. Throws the sanitized `DatabaseTransportError` otherwise.
|
|
*/
|
|
export function resolveExecutableDatabaseTransport(databaseUrl: string): DatabaseTransportPolicy {
|
|
const { environment, transport } = readDatabaseTransportFromEnvironment();
|
|
assertProductionDatabaseTransport(databaseUrl, transport, environment);
|
|
return transport;
|
|
}
|