@geekmidas/constructs 10.0.0-alpha.6 → 10.0.0-alpha.61

package/dist/kysely-BYfM6Zby.mjs

@@ -0,0 +1,288 @@
+import { t as onShutdown } from "./shutdown-C7xa8x9S.mjs";
+import { Cache } from "./cache.mjs";
+import { DEFAULT_POSTGRES_VERSION, canonicalId, provideKey, serviceKey } from "@geekmidas/manifest";
+import { Kysely, PostgresDialect } from "kysely";
+import { currentRequestContext } from "@geekmidas/services";
+import pg from "pg";
+//#region src/database/pool.ts
+/**
+* The `pg` pools a database construct opens, and what every one of them gets:
+*
+* - **A name.** `application_name` is what `pg_stat_activity` shows beside a
+*   connection. Without one, a database at `max_connections` cannot say who
+*   holds them. It is a *fallback*, so `PGAPPNAME` or `?application_name=` in
+*   the URL still win.
+* - **Tagged queries.** Inside a request, each query ends in a comment naming
+*   what ran it — `/*operation='POST /orders',request_id='…'*\/` — in the
+*   sqlcommenter form. It shows in `pg_stat_activity.query`, in the server's
+*   slow-query and `auto_explain` logs, and costs no round trip;
+*   `pg_stat_statements` ignores comments, so its grouping is unchanged.
+* - **A listener for idle-client errors.** When the server ends an idle
+*   connection (`idle_session_timeout`, a failover, an admin), the pool emits
+*   `'error'`. With no listener that is an uncaught exception that kills the
+*   process — for a client the pool has already discarded.
+* - **A way to close.** {@link closeDatabasePools} ends every pool opened, so a
+*   server shutting down releases its connections instead of holding them
+*   until the process dies.
+*/
+/** Every pool opened and not yet closed, so a shutdown can end them all. */
+const open = /* @__PURE__ */ new Set();
+onShutdown(() => closeDatabasePools());
+/**
+* A pool for one URL, with its schema actually on the search path.
+*
+* `?search_path=` is not a libpq parameter — a URL carrying it connects
+* happily and then resolves every unqualified name against `public`, which is
+* how a schema tenant silently writes its tables into the database it was
+* separated from. Postgres takes it as a startup option instead, so the URL
+* keeps the readable form the target derives and this turns it into the thing
+* the server understands.
+*/
+function openPool(url, options = {}) {
+	const parsed = new URL(url);
+	const searchPath = parsed.searchParams.get("search_path");
+	parsed.searchParams.delete("search_path");
+	const pool = new pg.Pool({
+		connectionString: parsed.toString(),
+		...searchPath ? { options: `-c search_path=${searchPath}` } : {},
+		fallback_application_name: applicationName()
+	});
+	pool.on("error", (error) => {
+		const logger = currentRequestContext()?.logger;
+		if (logger) logger.warn({ error }, "Idle database connection lost");
+		else console.warn("Idle database connection lost:", error.message);
+	});
+	if (options.queryTags !== false) pool.on("connect", (client) => tagQueries(client));
+	open.add(pool);
+	const end = pool.end.bind(pool);
+	pool.end = (async () => {
+		open.delete(pool);
+		await end();
+	});
+	return pool;
+}
+/**
+* End every pool opened, waiting for checked-out connections to come back.
+* For a server's shutdown, after it has stopped taking requests.
+*/
+async function closeDatabasePools() {
+	await Promise.all([...open].map((pool) => pool.end()));
+}
+/**
+* Who this process is, as Postgres will show it: the Lambda function, else the
+* app — `GKM_APP_NAME` where an entry sets it, `gkm dev`'s app tag otherwise.
+* Postgres keeps 63 bytes of it.
+*/
+function applicationName(env = process.env) {
+	return env.AWS_LAMBDA_FUNCTION_NAME || env.GKM_APP_NAME || env.GKM_DEV_APP?.split("#").pop() || void 0;
+}
+/**
+* The comment that says what ran a query, or '' outside a request.
+*
+* Values keep only characters that cannot end a comment or a quoted value —
+* `*` and `'` among those dropped — so a route cannot inject SQL through it.
+*/
+function queryTag() {
+	const request = currentRequestContext();
+	if (!request) return "";
+	const tags = [["operation", request.operation], ["request_id", request.requestId]].filter((tag) => Boolean(tag[1]));
+	if (tags.length === 0) return "";
+	const clean = (value) => value.replace(/[^\w ./:{}@-]/g, "");
+	return ` /*${tags.map(([key, value]) => `${key}='${clean(value)}'`).join(",")}*/`;
+}
+/**
+* Append {@link queryTag} to everything `client` runs: a SQL string — what
+* Kysely sends — or a query object such as a cursor's.
+*/
+function tagQueries(client) {
+	const query = client.query.bind(client);
+	client.query = ((first, ...rest) => {
+		const tag = queryTag();
+		if (tag && typeof first === "string") return query(first + tag, ...rest);
+		if (tag && first && typeof first === "object" && typeof first.text === "string") {
+			const config = first;
+			config.text += tag;
+		}
+		return query(first, ...rest);
+	});
+}
+//#endregion
+//#region src/database/kysely.ts
+/**
+* `KyselyDatabase` — a declared Postgres database, typed by its schema.
+*
+* It declares a logical database, a schema, and the roles that reach it, and
+* hands back a Kysely client built from the one URL the adapter supplied. It
+* names no cloud: `--target=aws` fills that URL from RDS, local dev from the
+* Postgres container.
+*
+* Transactions and RLS context are the execution wrapper's job — it opens the
+* transaction and puts it in `ctx.db`. This construct does not resolve
+* connections per request.
+*/
+/** The schema a database uses when it does not say otherwise. */
+const DEFAULT_SCHEMA = "app";
+/**
+* @typeParam DB - the database's schema.
+* @typeParam TName - the canonical id. TypeScript has no partial
+* type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves
+* this at its default and the service key widens to `string`. `db` still types
+* through `.database()`, which infers from the service.
+*/
+var KyselyDatabase = class KyselyDatabase {
+	options;
+	id;
+	service;
+	/**
+	* Declared once and read by both `declare()` and `connect()`, so the key the
+	* build publishes and the key the client reads cannot drift.
+	*/
+	config;
+	schemaName;
+	roles;
+	version;
+	derivedFrom;
+	constructor(id, options = {}, derivedFrom) {
+		this.options = options;
+		const canonical = canonicalId(id);
+		this.id = canonical;
+		this.config = {
+			url: provideKey(canonical, "url"),
+			ownerUrl: provideKey(canonical, "ownerUrl")
+		};
+		this.schemaName = options.schema ?? DEFAULT_SCHEMA;
+		this.roles = options.roles ?? true;
+		this.version = options.version ?? DEFAULT_POSTGRES_VERSION;
+		this.derivedFrom = derivedFrom;
+		this.service = {
+			serviceName: serviceKey(canonical),
+			register: (registerOptions) => this.connect(registerOptions)
+		};
+	}
+	declare() {
+		if (this.derivedFrom) {
+			const { kind, of, schema } = this.derivedFrom;
+			return [kind === "database-schema" ? {
+				kind,
+				id: this.id,
+				of,
+				schema: schema ?? this.schemaName,
+				provides: [this.config.url]
+			} : {
+				kind,
+				id: this.id,
+				of,
+				provides: [this.config.url]
+			}];
+		}
+		return [{
+			kind: "database",
+			id: this.id,
+			engine: "postgres",
+			schema: this.schemaName,
+			version: this.version,
+			provides: [this.config.url],
+			...this.roles ? {} : { roles: false }
+		}];
+	}
+	/**
+	* A read-only endpoint on this database.
+	*
+	* Read-only is enforced by the reader role's grants rather than by which
+	* endpoint it resolves to, so falling back to the writer where no replica
+	* exists is safe rather than a silently writable connection behind a name
+	* that says reader. There is no `writer()`: the database *is* the writer, so
+	* a replica can never be reached by accident.
+	*
+	* The return type is narrower than this class on purpose — see
+	* {@link ReadOnlyDatabase}.
+	*/
+	reader() {
+		return new KyselyDatabase(`${this.id}Reader`, this.options, {
+			kind: "database-reader",
+			of: this.id
+		});
+	}
+	/**
+	* A cache that lives in this database.
+	*
+	* The same strengthening `schema()` is over a second database: `new
+	* Cache('Sessions')` says the app caches and leaves where to the deployment,
+	* while this says it caches *here* — which is a fact about the application
+	* and so belongs in its code.
+	*
+	* What it buys beyond being explicit: the table's schema and the role that
+	* reaches it come from this database rather than from a second convention,
+	* and the backend no longer has to guess which database "the database" meant
+	* when an app declares two.
+	*
+	* A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client
+	* is a key/value store, not a query builder, and typing it as the parent
+	* would be a convenience that lies.
+	*/
+	cache(id = `${this.id}Cache`, options = {}) {
+		return new Cache(id, {
+			of: this.id,
+			...options.table ? { table: options.table } : {}
+		});
+	}
+	/**
+	* A second schema in this database, with its own role(s) and its own URL —
+	* so this database's role holds no grant on those tables at all.
+	*
+	* Typed separately because a tenant has its own tables: the point is that
+	* `auth.selectFrom('sessions')` type-checks and
+	* `orders.selectFrom('sessions')` does not.
+	*/
+	schema(id, options = {}) {
+		return new KyselyDatabase(id, options, {
+			kind: "database-schema",
+			of: this.id,
+			schema: options.schema ?? id.toLowerCase()
+		});
+	}
+	/**
+	* A connection as the *owner* role — the one that may create, alter and drop.
+	*
+	* A `Service` rather than part of the construct, and deliberately so: a
+	* construct is what `.dependsOn()` accepts, and nothing should be able to
+	* depend on this. A migrator asks for it by name; a handler cannot ask at
+	* all, which is the security property the role split exists for.
+	*
+	* Falls back to the runtime URL where no owner URL was published — the
+	* `roles: false` downgrade, where there is only one credential and it is the
+	* cluster master's.
+	*/
+	get owner() {
+		return {
+			serviceName: `${serviceKey(this.id)}Owner`,
+			register: (options) => this.connect(options, { owner: true })
+		};
+	}
+	/**
+	* What this database's clients are built with besides a dialect — the
+	* plugins and logging it was declared with.
+	*
+	* Public so that whatever opens a connection to it outside \`connect()\` —
+	* a test's transaction — builds the same client. A test that dropped the
+	* plugins would write \`createdAt\` where production writes \`created_at\`.
+	*/
+	get clientConfig() {
+		const { schema: _schema, roles: _roles, version: _version, queryTags: _queryTags, ...kysely } = this.options;
+		return kysely;
+	}
+	async connect(options, as = {}) {
+		const { url, ownerUrl } = options.envParser.create((get) => ({
+			url: get(this.config.url).string(),
+			ownerUrl: get(this.config.ownerUrl).string().optional()
+		})).parse();
+		return new Kysely({
+			...this.clientConfig,
+			dialect: new PostgresDialect({ pool: openPool(as.owner ? ownerUrl ?? url : url, { queryTags: this.options.queryTags }) })
+		});
+	}
+};
+//#endregion
+export { closeDatabasePools as n, KyselyDatabase as t };
+
+//# sourceMappingURL=kysely-BYfM6Zby.mjs.map

package/dist/kysely-BYfM6Zby.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-BYfM6Zby.mjs","names":[],"sources":["../src/database/pool.ts","../src/database/kysely.ts"],"sourcesContent":["/**\n * The `pg` pools a database construct opens, and what every one of them gets:\n *\n * - **A name.** `application_name` is what `pg_stat_activity` shows beside a\n *   connection. Without one, a database at `max_connections` cannot say who\n *   holds them. It is a *fallback*, so `PGAPPNAME` or `?application_name=` in\n *   the URL still win.\n * - **Tagged queries.** Inside a request, each query ends in a comment naming\n *   what ran it — `/*operation='POST /orders',request_id='…'*\\/` — in the\n *   sqlcommenter form. It shows in `pg_stat_activity.query`, in the server's\n *   slow-query and `auto_explain` logs, and costs no round trip;\n *   `pg_stat_statements` ignores comments, so its grouping is unchanged.\n * - **A listener for idle-client errors.** When the server ends an idle\n *   connection (`idle_session_timeout`, a failover, an admin), the pool emits\n *   `'error'`. With no listener that is an uncaught exception that kills the\n *   process — for a client the pool has already discarded.\n * - **A way to close.** {@link closeDatabasePools} ends every pool opened, so a\n *   server shutting down releases its connections instead of holding them\n *   until the process dies.\n */\n\nimport { currentRequestContext } from '@geekmidas/services';\nimport pg from 'pg';\nimport { onShutdown } from '../shutdown';\n\nexport interface DatabasePoolOptions {\n\t/** Tag queries run inside a request with what ran them. Default true. */\n\tqueryTags?: boolean;\n}\n\n/** Every pool opened and not yet closed, so a shutdown can end them all. */\nconst open = new Set<pg.Pool>();\nonShutdown(() => closeDatabasePools());\n\n/**\n * A pool for one URL, with its schema actually on the search path.\n *\n * `?search_path=` is not a libpq parameter — a URL carrying it connects\n * happily and then resolves every unqualified name against `public`, which is\n * how a schema tenant silently writes its tables into the database it was\n * separated from. Postgres takes it as a startup option instead, so the URL\n * keeps the readable form the target derives and this turns it into the thing\n * the server understands.\n */\nexport function openPool(\n\turl: string,\n\toptions: DatabasePoolOptions = {},\n): pg.Pool {\n\tconst parsed = new URL(url);\n\tconst searchPath = parsed.searchParams.get('search_path');\n\tparsed.searchParams.delete('search_path');\n\n\tconst pool = new pg.Pool({\n\t\tconnectionString: parsed.toString(),\n\t\t...(searchPath ? { options: `-c search_path=${searchPath}` } : {}),\n\t\tfallback_application_name: applicationName(),\n\t});\n\n\tpool.on('error', (error) => {\n\t\tconst logger = currentRequestContext()?.logger;\n\t\tif (logger) logger.warn({ error }, 'Idle database connection lost');\n\t\telse console.warn('Idle database connection lost:', error.message);\n\t});\n\tif (options.queryTags !== false) {\n\t\tpool.on('connect', (client) => tagQueries(client));\n\t}\n\n\topen.add(pool);\n\tconst end = pool.end.bind(pool);\n\tpool.end = (async () => {\n\t\topen.delete(pool);\n\t\tawait end();\n\t}) as typeof pool.end;\n\n\treturn pool;\n}\n\n/**\n * End every pool opened, waiting for checked-out connections to come back.\n * For a server's shutdown, after it has stopped taking requests.\n */\nexport async function closeDatabasePools(): Promise<void> {\n\tawait Promise.all([...open].map((pool) => pool.end()));\n}\n\n/**\n * Who this process is, as Postgres will show it: the Lambda function, else the\n * app — `GKM_APP_NAME` where an entry sets it, `gkm dev`'s app tag otherwise.\n * Postgres keeps 63 bytes of it.\n */\nexport function applicationName(\n\tenv: NodeJS.ProcessEnv = process.env,\n): string | undefined {\n\treturn (\n\t\tenv.AWS_LAMBDA_FUNCTION_NAME ||\n\t\tenv.GKM_APP_NAME ||\n\t\tenv.GKM_DEV_APP?.split('#').pop() ||\n\t\tundefined\n\t);\n}\n\n/**\n * The comment that says what ran a query, or '' outside a request.\n *\n * Values keep only characters that cannot end a comment or a quoted value —\n * `*` and `'` among those dropped — so a route cannot inject SQL through it.\n */\nexport function queryTag(): string {\n\tconst request = currentRequestContext();\n\tif (!request) return '';\n\n\tconst tags = [\n\t\t['operation', request.operation],\n\t\t['request_id', request.requestId],\n\t].filter((tag): tag is [string, string] => Boolean(tag[1]));\n\tif (tags.length === 0) return '';\n\n\tconst clean = (value: string) => value.replace(/[^\\w ./:{}@-]/g, '');\n\treturn ` /*${tags.map(([key, value]) => `${key}='${clean(value)}'`).join(',')}*/`;\n}\n\n/**\n * Append {@link queryTag} to everything `client` runs: a SQL string — what\n * Kysely sends — or a query object such as a cursor's.\n */\nfunction tagQueries(client: pg.PoolClient): void {\n\tconst query = client.query.bind(client) as (...args: unknown[]) => unknown;\n\tclient.query = ((first: unknown, ...rest: unknown[]) => {\n\t\tconst tag = queryTag();\n\t\tif (tag && typeof first === 'string') return query(first + tag, ...rest);\n\t\tif (\n\t\t\ttag &&\n\t\t\tfirst &&\n\t\t\ttypeof first === 'object' &&\n\t\t\ttypeof (first as { text?: unknown }).text === 'string'\n\t\t) {\n\t\t\tconst config = first as { text: string };\n\t\t\tconfig.text += tag;\n\t\t}\n\t\treturn query(first, ...rest);\n\t}) as typeof client.query;\n}\n","/**\n * `KyselyDatabase` — a declared Postgres database, typed by its schema.\n *\n * It declares a logical database, a schema, and the roles that reach it, and\n * hands back a Kysely client built from the one URL the adapter supplied. It\n * names no cloud: `--target=aws` fills that URL from RDS, local dev from the\n * Postgres container.\n *\n * Transactions and RLS context are the execution wrapper's job — it opens the\n * transaction and puts it in `ctx.db`. This construct does not resolve\n * connections per request.\n */\n\nimport {\n\ttype ConstructName,\n\tcanonicalId,\n\tDEFAULT_POSTGRES_VERSION,\n\ttype Declaration,\n\ttype PostgresVersion,\n\tprovideKey,\n\tserviceKey,\n} from '@geekmidas/manifest';\nimport type { Service, ServiceRegisterOptions } from '@geekmidas/services';\nimport { Kysely, type KyselyConfig, PostgresDialect } from 'kysely';\nimport { Cache } from '../cache';\nimport type { Construct } from '../construct-interface';\nimport { openPool } from './pool';\n\n/** The schema a database uses when it does not say otherwise. */\nconst DEFAULT_SCHEMA = 'app';\n\n/**\n * Everything Kysely takes, plus what this construct declares.\n *\n * `dialect` is omitted because the construct owns it — it is built from the one\n * URL the adapter supplied, which is the whole point of the construct. The rest\n * of `KyselyConfig` (`plugins`, `log`) is the app's business and passes\n * straight through, so anything Kysely adds later arrives without being\n * tracked here.\n */\nexport interface KyselyDatabaseOptions extends Omit<KyselyConfig, 'dialect'> {\n\t/**\n\t * The schema, pinned on both roles' `search_path`.\n\t *\n\t * Defaults to `app` — the role the schema plays, rather than a restatement\n\t * of the database's own name, which reads correctly beside `auth` and\n\t * `pgboss` and keeps the application off `public`.\n\t */\n\tschema?: string;\n\t/**\n\t * Provision the owner/runtime role split. Defaults to on.\n\t *\n\t * Off falls back to the cluster's master credential in both URLs, giving up\n\t * the DDL/DML split and putting credentials that can drop a table into the\n\t * function's environment. A deliberate downgrade, not a default.\n\t */\n\troles?: boolean;\n\t/**\n\t * The Postgres major version to provision.\n\t *\n\t * Declared here so one statement reaches both targets. It was previously\n\t * set in two unrelated places — a container tag locally, nothing at all on\n\t * AWS (so Aurora chose) — which is how local came to run 18 while deployed\n\t * ran 17.7 with nothing recording the difference.\n\t *\n\t * Defaults to {@link DEFAULT_POSTGRES_VERSION}.\n\t */\n\tversion?: PostgresVersion;\n\t/**\n\t * End each query run inside a request with a comment naming what ran it —\n\t * `/*operation='POST /orders',request_id='…'*\\/` — so `pg_stat_activity`\n\t * and the server's logs can tie a query to its endpoint. Defaults to on.\n\t */\n\tqueryTags?: boolean;\n}\n\n/** What makes a construct derived rather than a database in its own right. */\ninterface DerivedFrom {\n\tkind: 'database-reader' | 'database-schema';\n\tof: string;\n\tschema?: string;\n}\n\n/**\n * @typeParam DB - the database's schema.\n * @typeParam TName - the canonical id. TypeScript has no partial\n * type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves\n * this at its default and the service key widens to `string`. `db` still types\n * through `.database()`, which infers from the service.\n */\nexport class KyselyDatabase<DB = unknown, TName extends string = string>\n\timplements Construct<TName, Kysely<DB>>\n{\n\treadonly id: TName;\n\treadonly service: Service<Uncapitalize<TName>, Kysely<DB>>;\n\n\t/**\n\t * Declared once and read by both `declare()` and `connect()`, so the key the\n\t * build publishes and the key the client reads cannot drift.\n\t */\n\tprivate readonly config: { url: string; ownerUrl: string };\n\tprivate readonly schemaName: string;\n\tprivate readonly roles: boolean;\n\tprivate readonly version: PostgresVersion;\n\tprivate readonly derivedFrom?: DerivedFrom;\n\n\tconstructor(\n\t\tid: ConstructName<TName>,\n\t\tprivate readonly options: KyselyDatabaseOptions = {},\n\t\tderivedFrom?: DerivedFrom,\n\t) {\n\t\t// Canonicalises, so `orders` and `Orders` are one construct rather than\n\t\t// two that collide. Throws on anything that cannot become a valid id.\n\t\tconst canonical = canonicalId(id as string);\n\n\t\tthis.id = canonical as TName;\n\t\tthis.config = {\n\t\t\turl: provideKey(canonical, 'url'),\n\t\t\townerUrl: provideKey(canonical, 'ownerUrl'),\n\t\t};\n\t\tthis.schemaName = options.schema ?? DEFAULT_SCHEMA;\n\t\tthis.roles = options.roles ?? true;\n\t\tthis.version = options.version ?? DEFAULT_POSTGRES_VERSION;\n\t\tthis.derivedFrom = derivedFrom;\n\n\t\t// A field, not a getter: service discovery caches by object identity.\n\t\tthis.service = {\n\t\t\tserviceName: serviceKey(canonical) as Uncapitalize<TName>,\n\t\t\t// Forwards the whole options object — cherry-picking `envParser` strips\n\t\t\t// `context` and with it the request-scoped logger.\n\t\t\tregister: (registerOptions) => this.connect(registerOptions),\n\t\t};\n\t}\n\n\tdeclare(): Declaration[] {\n\t\tif (this.derivedFrom) {\n\t\t\tconst { kind, of, schema } = this.derivedFrom;\n\n\t\t\treturn [\n\t\t\t\tkind === 'database-schema'\n\t\t\t\t\t? {\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tid: this.id,\n\t\t\t\t\t\t\tof,\n\t\t\t\t\t\t\tschema: schema ?? this.schemaName,\n\t\t\t\t\t\t\t// The runtime key alone — see the note below on the parent.\n\t\t\t\t\t\t\tprovides: [this.config.url],\n\t\t\t\t\t\t}\n\t\t\t\t\t: {\n\t\t\t\t\t\t\tkind,\n\t\t\t\t\t\t\tid: this.id,\n\t\t\t\t\t\t\tof,\n\t\t\t\t\t\t\t// A reader has no owner URL of its own — nothing migrates\n\t\t\t\t\t\t\t// through a read-only endpoint — so this is the one key.\n\t\t\t\t\t\t\tprovides: [this.config.url],\n\t\t\t\t\t\t},\n\t\t\t];\n\t\t}\n\n\t\treturn [\n\t\t\t{\n\t\t\t\tkind: 'database',\n\t\t\t\tid: this.id,\n\t\t\t\tengine: 'postgres',\n\t\t\t\tschema: this.schemaName,\n\t\t\t\tversion: this.version,\n\t\t\t\t// One key, the runtime role's. `config` also holds the owner key and\n\t\t\t\t// it is deliberately absent here: a key in `provides` is a key an\n\t\t\t\t// edge can name, and nothing should be able to depend on DDL rights.\n\t\t\t\tprovides: [this.config.url],\n\t\t\t\t...(this.roles ? {} : { roles: false }),\n\t\t\t},\n\t\t];\n\t}\n\n\t/**\n\t * A read-only endpoint on this database.\n\t *\n\t * Read-only is enforced by the reader role's grants rather than by which\n\t * endpoint it resolves to, so falling back to the writer where no replica\n\t * exists is safe rather than a silently writable connection behind a name\n\t * that says reader. There is no `writer()`: the database *is* the writer, so\n\t * a replica can never be reached by accident.\n\t *\n\t * The return type is narrower than this class on purpose — see\n\t * {@link ReadOnlyDatabase}.\n\t */\n\treader(): ReadOnlyDatabase<DB, `${TName}Reader`> {\n\t\treturn new KyselyDatabase<DB, `${TName}Reader`>(\n\t\t\t`${this.id}Reader` as ConstructName<`${TName}Reader`>,\n\t\t\tthis.options,\n\t\t\t{ kind: 'database-reader', of: this.id },\n\t\t);\n\t}\n\n\t/**\n\t * A cache that lives in this database.\n\t *\n\t * The same strengthening `schema()` is over a second database: `new\n\t * Cache('Sessions')` says the app caches and leaves where to the deployment,\n\t * while this says it caches *here* — which is a fact about the application\n\t * and so belongs in its code.\n\t *\n\t * What it buys beyond being explicit: the table's schema and the role that\n\t * reaches it come from this database rather than from a second convention,\n\t * and the backend no longer has to guess which database \"the database\" meant\n\t * when an app declares two.\n\t *\n\t * A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client\n\t * is a key/value store, not a query builder, and typing it as the parent\n\t * would be a convenience that lies.\n\t */\n\tcache<TCache extends string = `${TName}Cache`>(\n\t\tid: ConstructName<TCache> = `${this.id}Cache` as ConstructName<TCache>,\n\t\toptions: { table?: string } = {},\n\t): Cache<TCache> {\n\t\treturn new Cache<TCache>(id, {\n\t\t\tof: this.id,\n\t\t\t...(options.table ? { table: options.table } : {}),\n\t\t});\n\t}\n\n\t/**\n\t * A second schema in this database, with its own role(s) and its own URL —\n\t * so this database's role holds no grant on those tables at all.\n\t *\n\t * Typed separately because a tenant has its own tables: the point is that\n\t * `auth.selectFrom('sessions')` type-checks and\n\t * `orders.selectFrom('sessions')` does not.\n\t */\n\tschema<TenantDB, TTenant extends string>(\n\t\tid: ConstructName<TTenant>,\n\t\toptions: KyselyDatabaseOptions = {},\n\t): KyselyDatabase<TenantDB, TTenant> {\n\t\treturn new KyselyDatabase<TenantDB, TTenant>(id, options, {\n\t\t\tkind: 'database-schema',\n\t\t\tof: this.id,\n\t\t\tschema: options.schema ?? (id as string).toLowerCase(),\n\t\t});\n\t}\n\n\t/**\n\t * A connection as the *owner* role — the one that may create, alter and drop.\n\t *\n\t * A `Service` rather than part of the construct, and deliberately so: a\n\t * construct is what `.dependsOn()` accepts, and nothing should be able to\n\t * depend on this. A migrator asks for it by name; a handler cannot ask at\n\t * all, which is the security property the role split exists for.\n\t *\n\t * Falls back to the runtime URL where no owner URL was published — the\n\t * `roles: false` downgrade, where there is only one credential and it is the\n\t * cluster master's.\n\t */\n\tget owner(): Service<`${Uncapitalize<TName>}Owner`, Kysely<DB>> {\n\t\treturn {\n\t\t\tserviceName:\n\t\t\t\t`${serviceKey(this.id)}Owner` as `${Uncapitalize<TName>}Owner`,\n\t\t\tregister: (options) => this.connect(options, { owner: true }),\n\t\t};\n\t}\n\n\t/**\n\t * What this database's clients are built with besides a dialect — the\n\t * plugins and logging it was declared with.\n\t *\n\t * Public so that whatever opens a connection to it outside \\`connect()\\` —\n\t * a test's transaction — builds the same client. A test that dropped the\n\t * plugins would write \\`createdAt\\` where production writes \\`created_at\\`.\n\t */\n\tget clientConfig(): Omit<KyselyConfig, 'dialect'> {\n\t\t// Split what the manifest declared from what Kysely takes, so neither\n\t\t// leaks into the other: \\`schema\\`, \\`roles\\` and \\`version\\` describe\n\t\t// infrastructure and mean nothing to a client.\n\t\tconst {\n\t\t\tschema: _schema,\n\t\t\troles: _roles,\n\t\t\tversion: _version,\n\t\t\tqueryTags: _queryTags,\n\t\t\t...kysely\n\t\t} = this.options;\n\t\treturn kysely;\n\t}\n\n\tprivate async connect(\n\t\toptions: ServiceRegisterOptions,\n\t\tas: { owner?: boolean } = {},\n\t): Promise<Kysely<DB>> {\n\t\tconst { url, ownerUrl } = options.envParser\n\t\t\t.create((get) => ({\n\t\t\t\turl: get(this.config.url).string(),\n\t\t\t\townerUrl: get(this.config.ownerUrl).string().optional(),\n\t\t\t}))\n\t\t\t.parse();\n\n\t\treturn new Kysely<DB>({\n\t\t\t...this.clientConfig,\n\t\t\tdialect: new PostgresDialect({\n\t\t\t\tpool: openPool(as.owner ? (ownerUrl ?? url) : url, {\n\t\t\t\t\tqueryTags: this.options.queryTags,\n\t\t\t\t}),\n\t\t\t}),\n\t\t});\n\t}\n}\n\n/**\n * A database you may read through, and derive nothing from.\n *\n * A reader is terminal in the graph, and this is that fact in the type system.\n * `DERIVES_FROM` gives `cache` and `database-schema` no `database-reader`\n * parent, and there is no reader of a reader — so `orders.reader().cache(…)`\n * has always been illegal, but it type-checked and failed later at\n * `assertDerivations`. That is a long way round to learn that a read-only\n * endpoint cannot own a table something writes to.\n *\n * Omitting the three deriving methods rather than making them throw keeps the\n * failure where it costs least: the editor, on the line that wrote it.\n *\n * The result is deliberately not assignable back to `KyselyDatabase` — a\n * reader is not one, and anything that genuinely needs the writer should say\n * so.\n */\nexport type ReadOnlyDatabase<DB, TName extends string> = Omit<\n\tKyselyDatabase<DB, TName>,\n\t'reader' | 'cache' | 'schema'\n>;\nexport { closeDatabasePools } from './pool';\n"],"mappings":"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"}

package/dist/kysely-CjuvdXEV.d.mts

@@ -0,0 +1,173 @@
+import { n as Construct } from "./construct-interface-DluK3_da.mjs";
+import { t as Cache } from "./cache-CXh6GIgb.mjs";
+import { ConstructName, Declaration, PostgresVersion } from "@geekmidas/manifest";
+import { Kysely, KyselyConfig } from "kysely";
+import { Service } from "@geekmidas/services";
+import pg from "pg";
+//#region src/database/pool.d.ts
+/**
+ * End every pool opened, waiting for checked-out connections to come back.
+ * For a server's shutdown, after it has stopped taking requests.
+ */
+declare function closeDatabasePools(): Promise<void>;
+//#endregion
+//#region src/database/kysely.d.ts
+/**
+ * Everything Kysely takes, plus what this construct declares.
+ *
+ * `dialect` is omitted because the construct owns it — it is built from the one
+ * URL the adapter supplied, which is the whole point of the construct. The rest
+ * of `KyselyConfig` (`plugins`, `log`) is the app's business and passes
+ * straight through, so anything Kysely adds later arrives without being
+ * tracked here.
+ */
+interface KyselyDatabaseOptions extends Omit<KyselyConfig, 'dialect'> {
+  /**
+   * The schema, pinned on both roles' `search_path`.
+   *
+   * Defaults to `app` — the role the schema plays, rather than a restatement
+   * of the database's own name, which reads correctly beside `auth` and
+   * `pgboss` and keeps the application off `public`.
+   */
+  schema?: string;
+  /**
+   * Provision the owner/runtime role split. Defaults to on.
+   *
+   * Off falls back to the cluster's master credential in both URLs, giving up
+   * the DDL/DML split and putting credentials that can drop a table into the
+   * function's environment. A deliberate downgrade, not a default.
+   */
+  roles?: boolean;
+  /**
+   * The Postgres major version to provision.
+   *
+   * Declared here so one statement reaches both targets. It was previously
+   * set in two unrelated places — a container tag locally, nothing at all on
+   * AWS (so Aurora chose) — which is how local came to run 18 while deployed
+   * ran 17.7 with nothing recording the difference.
+   *
+   * Defaults to {@link DEFAULT_POSTGRES_VERSION}.
+   */
+  version?: PostgresVersion;
+  /**
+   * End each query run inside a request with a comment naming what ran it —
+   * `/*operation='POST /orders',request_id='…'*\/` — so `pg_stat_activity`
+   * and the server's logs can tie a query to its endpoint. Defaults to on.
+   */
+  queryTags?: boolean;
+}
+/** What makes a construct derived rather than a database in its own right. */
+interface DerivedFrom {
+  kind: 'database-reader' | 'database-schema';
+  of: string;
+  schema?: string;
+}
+/**
+ * @typeParam DB - the database's schema.
+ * @typeParam TName - the canonical id. TypeScript has no partial
+ * type-argument inference, so `new KyselyDatabase<OrdersDB>('orders')` leaves
+ * this at its default and the service key widens to `string`. `db` still types
+ * through `.database()`, which infers from the service.
+ */
+declare class KyselyDatabase<DB = unknown, TName extends string = string> implements Construct<TName, Kysely<DB>> {
+  private readonly options;
+  readonly id: TName;
+  readonly service: Service<Uncapitalize<TName>, Kysely<DB>>;
+  /**
+   * Declared once and read by both `declare()` and `connect()`, so the key the
+   * build publishes and the key the client reads cannot drift.
+   */
+  private readonly config;
+  private readonly schemaName;
+  private readonly roles;
+  private readonly version;
+  private readonly derivedFrom?;
+  constructor(id: ConstructName<TName>, options?: KyselyDatabaseOptions, derivedFrom?: DerivedFrom);
+  declare(): Declaration[];
+  /**
+   * A read-only endpoint on this database.
+   *
+   * Read-only is enforced by the reader role's grants rather than by which
+   * endpoint it resolves to, so falling back to the writer where no replica
+   * exists is safe rather than a silently writable connection behind a name
+   * that says reader. There is no `writer()`: the database *is* the writer, so
+   * a replica can never be reached by accident.
+   *
+   * The return type is narrower than this class on purpose — see
+   * {@link ReadOnlyDatabase}.
+   */
+  reader(): ReadOnlyDatabase<DB, `${TName}Reader`>;
+  /**
+   * A cache that lives in this database.
+   *
+   * The same strengthening `schema()` is over a second database: `new
+   * Cache('Sessions')` says the app caches and leaves where to the deployment,
+   * while this says it caches *here* — which is a fact about the application
+   * and so belongs in its code.
+   *
+   * What it buys beyond being explicit: the table's schema and the role that
+   * reaches it come from this database rather than from a second convention,
+   * and the backend no longer has to guess which database "the database" meant
+   * when an app declares two.
+   *
+   * A cache is not a `KyselyDatabase`, so this returns a `Cache` — the client
+   * is a key/value store, not a query builder, and typing it as the parent
+   * would be a convenience that lies.
+   */
+  cache<TCache extends string = `${TName}Cache`>(id?: ConstructName<TCache>, options?: {
+    table?: string;
+  }): Cache<TCache>;
+  /**
+   * A second schema in this database, with its own role(s) and its own URL —
+   * so this database's role holds no grant on those tables at all.
+   *
+   * Typed separately because a tenant has its own tables: the point is that
+   * `auth.selectFrom('sessions')` type-checks and
+   * `orders.selectFrom('sessions')` does not.
+   */
+  schema<TenantDB, TTenant extends string>(id: ConstructName<TTenant>, options?: KyselyDatabaseOptions): KyselyDatabase<TenantDB, TTenant>;
+  /**
+   * A connection as the *owner* role — the one that may create, alter and drop.
+   *
+   * A `Service` rather than part of the construct, and deliberately so: a
+   * construct is what `.dependsOn()` accepts, and nothing should be able to
+   * depend on this. A migrator asks for it by name; a handler cannot ask at
+   * all, which is the security property the role split exists for.
+   *
+   * Falls back to the runtime URL where no owner URL was published — the
+   * `roles: false` downgrade, where there is only one credential and it is the
+   * cluster master's.
+   */
+  get owner(): Service<`${Uncapitalize<TName>}Owner`, Kysely<DB>>;
+  /**
+   * What this database's clients are built with besides a dialect — the
+   * plugins and logging it was declared with.
+   *
+   * Public so that whatever opens a connection to it outside \`connect()\` —
+   * a test's transaction — builds the same client. A test that dropped the
+   * plugins would write \`createdAt\` where production writes \`created_at\`.
+   */
+  get clientConfig(): Omit<KyselyConfig, 'dialect'>;
+  private connect;
+}
+/**
+ * A database you may read through, and derive nothing from.
+ *
+ * A reader is terminal in the graph, and this is that fact in the type system.
+ * `DERIVES_FROM` gives `cache` and `database-schema` no `database-reader`
+ * parent, and there is no reader of a reader — so `orders.reader().cache(…)`
+ * has always been illegal, but it type-checked and failed later at
+ * `assertDerivations`. That is a long way round to learn that a read-only
+ * endpoint cannot own a table something writes to.
+ *
+ * Omitting the three deriving methods rather than making them throw keeps the
+ * failure where it costs least: the editor, on the line that wrote it.
+ *
+ * The result is deliberately not assignable back to `KyselyDatabase` — a
+ * reader is not one, and anything that genuinely needs the writer should say
+ * so.
+ */
+type ReadOnlyDatabase<DB, TName extends string> = Omit<KyselyDatabase<DB, TName>, 'reader' | 'cache' | 'schema'>;
+//#endregion
+export { closeDatabasePools as i, KyselyDatabaseOptions as n, ReadOnlyDatabase as r, KyselyDatabase as t };
+//# sourceMappingURL=kysely-CjuvdXEV.d.mts.map

package/dist/kysely-CjuvdXEV.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-CjuvdXEV.d.mts","names":[],"sources":["../src/database/pool.ts","../src/database/kysely.ts"],"mappings":";;;;;;;;;;;iBAiFsB,sBAAsB;;;;;;;;;;;;UCzC3B,8BAA8B,KAAK;;;;;;;;EAQnD;;;;;;;;EAQA;;;;;;;;;;;EAWA,UAAU;;;;;;EAMV;;;UAIS;EACT;EACA;EACA;;;;;;;;;cAUY,eAAe,cAAc,0CAC9B,UAAU,OAAO,OAAO;mBAiBjB;WAfT,IAAI;WACJ,SAAS,QAAQ,aAAa,QAAQ,OAAO;;;;;mBAMrC;mBACA;mBACA;mBACA;mBACA;EAEjB,YACC,IAAI,cAAc,QACD,UAAS,uBAC1B,cAAc;EAyBf,WAAW;;;;;;;;;;;;;EAqDX,UAAU,iBAAiB,OAAO;;;;;;;;;;;;;;;;;;EAyBlC,MAAM,2BAA2B,cAChC,KAAI,cAAc,SAClB;IAAW;MACT,MAAM;;;;;;;;;EAeT,OAAO,UAAU,wBAChB,IAAI,cAAc,UAClB,UAAS,wBACP,eAAe,UAAU;;;;;;;;;;;;;MAoBxB,SAAS,WAAW,aAAa,eAAe,OAAO;;;;;;;;;MAgBvD,gBAAgB,KAAK;UAcX;;;;;;;;;;;;;;;;;;;KAuCH,iBAAiB,IAAI,wBAAwB,KACxD,eAAe,IAAI"}

package/dist/{lazyAccessors-BoJN3SMd.mjs → lazyAccessors-CFanua0O.mjs}

@@ -1,44 +1,4 @@
 import { getCookie } from "hono/cookie";
-
-//#region src/publisher.ts
-async function publishEvents(logger, serviceDiscovery, ev = [], response, publisherService) {
-	try {
-		if (!ev?.length) {
-			logger.debug("No events to publish");
-			return;
-		}
-		if (!publisherService) {
-			logger.warn("No publisher service available");
-			return;
-		}
-		const services = await serviceDiscovery.register([publisherService]);
-		const publisher = services[publisherService.serviceName];
-		const events = [];
-		for (const { when, payload, type,...e } of ev) {
-			logger.debug({ event: type }, "Processing event");
-			const resolvedPayload = await payload(response);
-			const event = {
-				...e,
-				type,
-				payload: resolvedPayload
-			};
-			if (!when || when(response)) events.push(event);
-		}
-		if (events.length) {
-			logger.debug({ eventCount: ev.length }, "Publishing events");
-			await publisher.publish(events).catch((err) => {
-				logger.error(err, "Failed to publish events");
-			});
-		}
-	} catch (error) {
-		logger.error(error, "Something went wrong publishing events");
-	}
-}
-async function publishConstructEvents(construct, response, serviceDiscovery, logger = construct.logger) {
-	return publishEvents(logger, serviceDiscovery, construct.events, response, construct.publisherService);
-}
-
-//#endregion
 //#region src/endpoints/lazyAccessors.ts
 /**
 * Create a lazy header accessor for Hono.
@@ -47,11 +7,11 @@ async function publishConstructEvents(construct, response, serviceDiscovery, log
 */
 function createHonoHeaders(c) {
 	let allHeaders = null;
-	return (key) => {
+	return ((key) => {
 		if (key !== void 0) return c.req.header(key);
 		if (!allHeaders) allHeaders = c.req.header();
 		return allHeaders;
-	};
+	});
 }
 /**
 * Create a lazy cookie accessor for Hono.
@@ -60,7 +20,7 @@ function createHonoHeaders(c) {
 */
 function createHonoCookies(c) {
 	let allCookies = null;
-	return (name) => {
+	return ((name) => {
 		if (name !== void 0) return getCookie(c, name);
 		if (!allCookies) {
 			allCookies = {};
@@ -76,7 +36,7 @@ function createHonoCookies(c) {
 			}
 		}
 		return allCookies;
-	};
+	});
 }
 /**
 * Create a lazy header accessor for API Gateway events.
@@ -93,17 +53,17 @@ function createApiGatewayHeaders(headers) {
 		}
 		return normalizedHeaders;
 	};
-	return (key) => {
+	return ((key) => {
 		if (key !== void 0) {
 			if (headers) {
 				const direct = headers[key] ?? headers[key.toLowerCase()];
 				if (direct !== void 0) return direct;
 				return normalize()[key.toLowerCase()];
 			}
-			return void 0;
+			return;
 		}
 		return normalize();
-	};
+	});
 }
 /**
 * Create a lazy cookie accessor for API Gateway events.
@@ -134,10 +94,10 @@ function createApiGatewayCookies(cookies, cookieHeader) {
 		}
 		return parsed;
 	};
-	return (name) => {
+	return ((name) => {
 		if (name !== void 0) return parse()[name];
 		return parse();
-	};
+	});
 }
 /**
 * Create a lazy header accessor for plain object headers (test adaptor, etc).
@@ -145,7 +105,7 @@ function createApiGatewayCookies(cookies, cookieHeader) {
 */
 function createObjectHeaders(headers) {
 	let normalized = null;
-	return (key) => {
+	return ((key) => {
 		if (key !== void 0) {
 			if (headers) {
 				const direct = headers[key] ?? headers[key.toLowerCase()];
@@ -162,7 +122,7 @@ function createObjectHeaders(headers) {
 			for (const [k, v] of Object.entries(headers)) normalized[k.toLowerCase()] = v;
 		}
 		return normalized ?? {};
-	};
+	});
 }
 /**
 * Create a lazy cookie accessor from a cookie header string.
@@ -185,30 +145,30 @@ function createCookieHeaderAccessor(cookieHeader) {
 		}
 		return parsed;
 	};
-	return (name) => {
+	return ((name) => {
 		if (name !== void 0) return parse()[name];
 		return parse();
-	};
+	});
 }
 /**
 * Create a no-op header accessor (for minimal endpoints that don't use headers).
 */
 function createNoopHeaders() {
-	return (key) => {
+	return ((key) => {
 		if (key !== void 0) return void 0;
 		return {};
-	};
+	});
 }
 /**
 * Create a no-op cookie accessor (for minimal endpoints that don't use cookies).
 */
 function createNoopCookies() {
-	return (name) => {
+	return ((name) => {
 		if (name !== void 0) return void 0;
 		return {};
-	};
+	});
 }
-
 //#endregion
-export { createApiGatewayCookies, createApiGatewayHeaders, createCookieHeaderAccessor, createHonoCookies, createHonoHeaders, createNoopCookies, createNoopHeaders, createObjectHeaders, publishConstructEvents, publishEvents };
-//# sourceMappingURL=lazyAccessors-BoJN3SMd.mjs.map
+export { createHonoHeaders as a, createObjectHeaders as c, createHonoCookies as i, createApiGatewayHeaders as n, createNoopCookies as o, createCookieHeaderAccessor as r, createNoopHeaders as s, createApiGatewayCookies as t };
+
+//# sourceMappingURL=lazyAccessors-CFanua0O.mjs.map