@fuzdev/fuz_app 0.110.1 → 0.112.0

package/dist/db/cell_queries.js

@@ -22,18 +22,53 @@
  */
 import { fact_hash_extract_refs } from '@fuzdev/fuz_util/fact_hash.ts';
 import { assert_row } from './assert_row.js';
+import { iso8601_timestamp_expr, qualify_columns } from './sql_columns.js';
 /**
- * SQL fragment for the `grant_count` projection — correlated subquery
- * against `cell_grant`. Inlined in every cell-row SELECT / RETURNING so
- * `CellRow` carries the count uniformly. Pass the cell alias used in
- * the outer query (`'cell'` for table-name references, `'c'` for the
- * aliased form in `query_cell_list`).
+ * The full `cell` column set, named explicitly so a row read fails loud on
+ * schema drift — a `SELECT *` silently omits a dropped column and the
+ * `deleted_at IS NULL`-shaped predicates on the hydrated row then misread
+ * `undefined` (see `ACCOUNT_COLUMNS` in `auth/account_queries.ts` for the
+ * outage class). Column order mirrors the Rust twin's `cell_columns(alias)`
+ * (`fuz_cell`), which decodes the same projection positionally. The derived
+ * `grant_count` is not a column — `cell_row_projection` appends it. Keep
+ * in sync with `CellRow` and the `cell` DDL in `db/cell_ddl.ts`.
+ */
+export const CELL_COLUMNS = [
+    'id',
+    'data',
+    'kind',
+    'visibility',
+    'path',
+    'refs',
+    'parent_id',
+    'root_id',
+    'moderation',
+    'created_at',
+    'updated_at',
+    'deleted_at',
+    'created_by',
+    'updated_by'
+];
+/** The `cell` timestamp override, by row qualifier — the one `cell_row_projection` is given. */
+const cell_expr = iso8601_timestamp_expr(CELL_COLUMNS, ['created_at', 'updated_at', 'deleted_at']);
+/**
+ * The full `CellRow` projection — `CELL_COLUMNS` qualified by `alias` plus
+ * the derived `grant_count` (a correlated subquery against `cell_grant`,
+ * served by `idx_cell_grant_cell`) — used by every cell-row SELECT /
+ * RETURNING. `alias` is the row qualifier: the table name (`'cell'`) for
+ * single-table reads + `RETURNING`, the query alias (`'c'`) for
+ * `query_cell_list`. Twin of `fuz_cell`'s `cell_columns(alias)`.
+ *
+ * `::int` narrows the count from `bigint` so the JS row hydrates a `number`
+ * rather than a bigint primitive — counts on a single cell are trivially
+ * within int32.
  *
- * `::int` narrows from `bigint` to `int` so the JS row hydrates as a
- * `number` rather than a bigint primitive — counts on a single cell are
- * trivially within int32.
+ * Exported for consumers writing their own cell-row reads: `CELL_COLUMNS`
+ * alone hydrates a row without `grant_count`, which typechecks as a
+ * `CellRow` but fails at `to_cell_json` — this is the projection that
+ * actually produces one.
  */
-const grant_count_projection = (cell_alias) => `(SELECT COUNT(*)::int FROM cell_grant WHERE cell_id = ${cell_alias}.id) AS grant_count`;
+export const cell_row_projection = (alias) => `${qualify_columns(CELL_COLUMNS, alias, cell_expr(alias))}, (SELECT COUNT(*)::int FROM cell_grant WHERE cell_id = ${alias}.id) AS grant_count`;
 /**
  * Insert a cell row, deriving `refs` from `data`.
  *
@@ -53,7 +88,7 @@ export const query_cell_create = async (deps, input) => {
     const row = await deps.db.query_one(`INSERT INTO cell
 		   (data, kind, visibility, path, refs, parent_id, root_id, moderation, created_by)
 		 VALUES ($1::jsonb, $2, COALESCE($3::cell_visibility, 'private'::cell_visibility), $4, $5::text[], $6, $7, $8, $9)
-		 RETURNING *, ${grant_count_projection('cell')}`, [
+		 RETURNING ${cell_row_projection('cell')}`, [
         JSON.stringify(input.data),
         input.kind ?? null,
         input.visibility ?? null,
@@ -76,7 +111,7 @@ export const query_cell_create = async (deps, input) => {
  */
 export const query_cell_get = async (deps, id, options) => {
     const include_deleted = options?.include_deleted === true;
-    const row = await deps.db.query_one(`SELECT *, ${grant_count_projection('cell')}
+    const row = await deps.db.query_one(`SELECT ${cell_row_projection('cell')}
 		 FROM cell
 		 WHERE id = $1
 		   AND ($2::bool OR deleted_at IS NULL)`, [id, include_deleted]);
@@ -92,7 +127,7 @@ export const query_cell_get = async (deps, id, options) => {
  * @returns the row or `null` when not found
  */
 export const query_cell_get_by_path = async (deps, path) => {
-    const row = await deps.db.query_one(`SELECT *, ${grant_count_projection('cell')}
+    const row = await deps.db.query_one(`SELECT ${cell_row_projection('cell')}
 		 FROM cell
 		 WHERE path = $1 AND deleted_at IS NULL`, [path]);
     return row ?? null;
@@ -111,7 +146,7 @@ export const query_cell_get_by_path = async (deps, path) => {
 export const query_cell_load_many = async (deps, ids) => {
     if (ids.length === 0)
         return [];
-    return deps.db.query(`SELECT *, ${grant_count_projection('cell')}
+    return deps.db.query(`SELECT ${cell_row_projection('cell')}
 		 FROM cell
 		 WHERE id = ANY($1::uuid[]) AND deleted_at IS NULL`, [ids]);
 };
@@ -140,7 +175,7 @@ export const query_cell_update = async (deps, id, patch) => {
 		   visibility = CASE WHEN $9::bool THEN $10::cell_visibility ELSE visibility END,
 		   updated_at = NOW()
 		 WHERE id = $1 AND deleted_at IS NULL
-		 RETURNING *, ${grant_count_projection('cell')}`, [
+		 RETURNING ${cell_row_projection('cell')}`, [
         id,
         data_provided,
         data_provided ? JSON.stringify(patch.data) : null,
@@ -199,7 +234,7 @@ export const query_cell_set_moderation = async (deps, id, moderation, options) =
 		   updated_by = $4,
 		   updated_at = NOW()
 		 WHERE id = $1 AND deleted_at IS NULL
-		 RETURNING *, ${grant_count_projection('cell')}`, [id, moderation, options.set_visibility_public, options.updated_by ?? null]);
+		 RETURNING ${cell_row_projection('cell')}`, [id, moderation, options.set_visibility_public, options.updated_by ?? null]);
     return row ?? null;
 };
 /**
@@ -211,11 +246,11 @@ export const query_cell_set_moderation = async (deps, id, moderation, options) =
  * @param options - pagination
  * @returns matching active rows
  */
-export const query_cell_list_by_kind = async (deps, kind, options) => deps.db.query(`SELECT *, ${grant_count_projection('cell')}
+export const query_cell_list_by_kind = async (deps, kind, options) => deps.db.query(`SELECT ${cell_row_projection('cell')}
 		 FROM cell
 		 WHERE kind = $1
 		   AND deleted_at IS NULL
-		 ORDER BY created_at DESC
+		 ORDER BY cell.created_at DESC
 		 LIMIT $2 OFFSET $3`, [kind, options?.limit ?? null, options?.offset ?? 0]);
 /**
  * List active cells created by an actor, newest first. Backed by the
@@ -226,10 +261,10 @@ export const query_cell_list_by_kind = async (deps, kind, options) => deps.db.qu
  * @param options - pagination
  * @returns matching active rows
  */
-export const query_cell_list_by_creator = async (deps, actor_id, options) => deps.db.query(`SELECT *, ${grant_count_projection('cell')}
+export const query_cell_list_by_creator = async (deps, actor_id, options) => deps.db.query(`SELECT ${cell_row_projection('cell')}
 		 FROM cell
 		 WHERE created_by = $1 AND deleted_at IS NULL
-		 ORDER BY created_at DESC
+		 ORDER BY cell.created_at DESC
 		 LIMIT $2 OFFSET $3`, [actor_id, options?.limit ?? null, options?.offset ?? 0]);
 /**
  * Filterable list query for the generic `cell_list` RPC.
@@ -365,7 +400,7 @@ const CALLER_ROLE_GRANTS_CTE = `WITH caller_role_grants AS (
 	 )`;
 /** General `cell_list` SQL: cell-driven scan, full visibility predicate. */
 const build_general_sql = (order_column, order_direction) => `${CALLER_ROLE_GRANTS_CTE}
-	 SELECT c.*, ${grant_count_projection('c')} FROM cell c
+	 SELECT ${cell_row_projection('c')} FROM cell c
 	 WHERE ($1::bool OR c.deleted_at IS NULL)
 	   AND ($2::text IS NULL OR c.kind = $2::text)
 	   AND ($14::cell_visibility IS NULL OR c.visibility = $14::cell_visibility)
@@ -403,7 +438,7 @@ const build_general_sql = (order_column, order_direction) => `${CALLER_ROLE_GRAN
  * "what's shared with me" wants their grant footprint, not every cell.
  */
 const build_shared_with_sql = (order_column, order_direction) => `${CALLER_ROLE_GRANTS_CTE}
-	 SELECT c.*, ${grant_count_projection('c')} FROM cell c
+	 SELECT ${cell_row_projection('c')} FROM cell c
 	 WHERE ($1::bool OR c.deleted_at IS NULL)
 	   AND ($2::text IS NULL OR c.kind = $2::text)
 	   AND ($14::cell_visibility IS NULL OR c.visibility = $14::cell_visibility)
@@ -422,7 +457,7 @@ const build_shared_with_sql = (order_column, order_direction) => `${CALLER_ROLE_
 	   -- $6 (viewer_is_admin) intentionally not consulted: an admin
 	   -- asking "what's shared with me" wants their grant footprint, not
 	   -- every cell. Cast-only reference keeps the param's type known to
-	   -- the planner so the shared 14-param positional layout stays valid.
+	   -- the planner so the shared 16-param positional layout stays valid.
 	   AND $6::bool IS NOT NULL
 	 ORDER BY c.${order_column} ${order_direction} NULLS LAST
 	 LIMIT $8 OFFSET $9`;

package/dist/db/fact_queries.d.ts

@@ -22,6 +22,13 @@ export interface FactRow {
     size: number | string;
     created_at: Date;
 }
+/**
+ * The full `fact` column set, named explicitly so a row read fails loud on
+ * schema drift (see `ACCOUNT_COLUMNS` in `auth/account_queries.ts` for the
+ * outage class). Keep in sync with `FactRow` and the `fact` DDL in
+ * `db/fact_ddl.ts`.
+ */
+export declare const FACT_COLUMNS: readonly ["hash", "bytes", "external_url", "content_type", "size", "created_at"];
 /** Subset returned by metadata-only queries (no `bytes` payload). */
 export interface FactMetaRow {
     hash: FactHash;

package/dist/db/fact_queries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fact_queries.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/fact_queries.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fact_queries.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/fact_queries.ts"],"names":[],"mappings":"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"}

package/dist/db/fact_queries.js

@@ -11,6 +11,29 @@
  *
  * @module
  */
+import { columns_sql, iso8601_timestamp_column, omit_columns } from './sql_columns.js';
+/**
+ * The full `fact` column set, named explicitly so a row read fails loud on
+ * schema drift (see `ACCOUNT_COLUMNS` in `auth/account_queries.ts` for the
+ * outage class). Keep in sync with `FactRow` and the `fact` DDL in
+ * `db/fact_ddl.ts`.
+ */
+export const FACT_COLUMNS = [
+    'hash',
+    'bytes',
+    'external_url',
+    'content_type',
+    'size',
+    'created_at'
+];
+// `created_at` is deliberately *not* projected through
+// `iso8601_timestamp_column` here, unlike every other table: these rows feed
+// `PgFactStore`, whose `FactMeta.created_at` is a `Date` in the
+// `@fuzdev/fuz_util` `FactStore` contract, and nothing serializes them. The
+// one fact timestamp that does reach the wire — the orphan-sweep sample in
+// `query_orphan_facts_list` — projects the ISO-8601 wire string.
+/** `FACT_COLUMNS` minus the payload — the `FactMetaRow` projection. */
+const FACT_META_COLUMNS = omit_columns(FACT_COLUMNS, 'bytes');
 /**
  * Idempotently insert a fact row.
  *
@@ -44,7 +67,7 @@ export const query_put_fact_refs = async (deps, source_hash, target_hashes) => {
  * `FactStore.get`; cheaper accessors live below.
  */
 export const query_get_fact = async (deps, hash) => {
-    const row = await deps.db.query_one(`SELECT hash, bytes, external_url, content_type, size, created_at
+    const row = await deps.db.query_one(`SELECT ${columns_sql(FACT_COLUMNS)}
 		 FROM fact WHERE hash = $1`, [hash]);
     return row ?? null;
 };
@@ -52,7 +75,7 @@ export const query_get_fact = async (deps, hash) => {
  * Fetch metadata only — skips the (potentially large) `bytes` column.
  */
 export const query_get_fact_meta = async (deps, hash) => {
-    const row = await deps.db.query_one(`SELECT hash, external_url, content_type, size, created_at
+    const row = await deps.db.query_one(`SELECT ${columns_sql(FACT_META_COLUMNS)}
 		 FROM fact WHERE hash = $1`, [hash]);
     return row ?? null;
 };
@@ -120,7 +143,7 @@ export const query_orphan_facts_list = async (deps, older_than, sample_limit) =>
 		     AND c.deleted_at IS NULL
 		 )
 		 AND ($1::timestamptz IS NULL OR f.created_at < $1::timestamptz)`, [older_than]);
-    const sample_rows = await deps.db.query(`SELECT hash, size, created_at, external_url
+    const sample_rows = await deps.db.query(`SELECT hash, size, ${iso8601_timestamp_column('f', 'created_at')} AS created_at, external_url
 		 FROM fact f
 		 WHERE NOT EXISTS (
 		   SELECT 1 FROM cell c
@@ -136,7 +159,7 @@ export const query_orphan_facts_list = async (deps, older_than, sample_limit) =>
         sample: sample_rows.map((r) => ({
             hash: r.hash,
             size: Number(r.size),
-            created_at: typeof r.created_at === 'string' ? r.created_at : r.created_at.toISOString(),
+            created_at: r.created_at,
             external_url: r.external_url
         }))
     };

package/dist/db/schema_ready.d.ts

@@ -47,9 +47,14 @@ export type ExpectedSchema = Record<string, ReadonlyArray<string>>;
  * never-migrated DB then correctly fails readiness instead of passing on an
  * empty expectation.
  *
+ * @param db - the database to introspect
+ * @param options - `table` narrows the scan to one relation (the drift guard's
+ *   one-table question); omitted, every `public` relation is returned
  * @returns relation name → sorted column names
  */
-export declare const query_public_columns: (db: Db) => Promise<Record<string, Array<string>>>;
+export declare const query_public_columns: (db: Db, options?: {
+    table?: string;
+}) => Promise<Record<string, Array<string>>>;
 /** Columns the live DB is missing for a table the expected schema declares. */
 export interface MissingColumns {
     table: string;

package/dist/db/schema_ready.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema_ready.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/schema_ready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AAOnE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,oBAAoB,GAAU,IAAI,EAAE,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAWxF,CAAC;AAEF,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,uCAAuC;AACvC,MAAM,WAAW,iBAAiB;IACjC,EAAE,EAAE,OAAO,CAAC;IACZ,+CAA+C;IAC/C,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B,6EAA6E;IAC7E,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;CACvC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,IAAI,EAAE,EACN,UAAU,cAAc,KACtB,OAAO,CAAC,iBAAiB,CAmB3B,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,KAAG,MAO9D,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,WAAW;;;CAGd,CAAC"}
+{"version":3,"file":"schema_ready.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/schema_ready.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AAOnE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAChC,IAAI,EAAE,EACN,UAAU;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,KAC1B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAavC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,uCAAuC;AACvC,MAAM,WAAW,iBAAiB;IACjC,EAAE,EAAE,OAAO,CAAC;IACZ,+CAA+C;IAC/C,cAAc,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B,6EAA6E;IAC7E,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;CACvC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC9B,IAAI,EAAE,EACN,UAAU,cAAc,KACtB,OAAO,CAAC,iBAAiB,CAmB3B,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,mBAAmB,GAAI,OAAO,iBAAiB,KAAG,MAO9D,CAAC;AAEF,sFAAsF;AACtF,eAAO,MAAM,WAAW;;;CAGd,CAAC"}

package/dist/db/schema_ready.js

@@ -44,12 +44,16 @@
  * never-migrated DB then correctly fails readiness instead of passing on an
  * empty expectation.
  *
+ * @param db - the database to introspect
+ * @param options - `table` narrows the scan to one relation (the drift guard's
+ *   one-table question); omitted, every `public` relation is returned
  * @returns relation name → sorted column names
  */
-export const query_public_columns = async (db) => {
+export const query_public_columns = async (db, options) => {
     const rows = await db.query(`SELECT table_name, column_name FROM information_schema.columns
 		 WHERE table_schema = 'public'
-		 ORDER BY table_name, column_name`);
+		   AND ($1::text IS NULL OR table_name = $1)
+		 ORDER BY table_name, column_name`, [options?.table ?? null]);
     const by_table = {};
     for (const { table_name, column_name } of rows) {
         (by_table[table_name] ??= []).push(column_name);

package/dist/db/sql_columns.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Helpers for the named-column projection consts (`ACCOUNT_COLUMNS`,
+ * `CELL_COLUMNS`, …) — per-table column-name arrays that every table read
+ * projects through so a dropped or leftover column fails loud instead of
+ * vanishing under `SELECT *`.
+ *
+ * Each query module exports its table's const and derives every projection
+ * it needs from it at the read site — `columns_sql` for single-table reads,
+ * `qualify_columns` for reads that alias the table, `omit_columns` for a
+ * client-safe subset — rather than spelling a second column list, so the
+ * drift guard on the base const (`assert_columns_match_live` in
+ * `testing/db.ts`) covers every derived projection too. Twin of the Rust
+ * spine's `*_COLUMNS` consts + `fuz_db::qualify_columns` / `omit_columns`.
+ *
+ * A read that needs a column rendered as something other than the bare
+ * reference passes a `ColumnExpr` — the `expr` override, twin of the third
+ * argument to `fuz_db::qualify_columns`. Every timestamp that reaches the
+ * wire projects through `iso8601_timestamp_column` so both spines serialize
+ * the same instant to the same bytes; each query module builds its override
+ * with `iso8601_timestamp_expr` over its table const. An override costs one
+ * rule — a projected `ORDER BY` must qualify its column — stated on
+ * `qualify_columns`.
+ *
+ * Placement rule: a const lives in its table's query module. When two query
+ * modules project the same table (the revoke cascades in
+ * `auth/role_grant_queries.ts` supersede `role_grant_offer` rows while the
+ * offer module's accept path writes `role_grant` rows), it lives in the
+ * table's `*_ddl.ts` instead — the module both already import — so the query
+ * modules stay acyclic.
+ *
+ * Column arrays are literal consts; the alias passed to `qualify_columns` is
+ * the only input these helpers treat as dynamic (and validate). Each const
+ * also carries `satisfies ReadonlyArray<keyof Row>` so a column name the row
+ * type doesn't know is a compile error.
+ *
+ * @module
+ */
+/**
+ * Per-column expression override for a projection — return the SQL to
+ * project for `column`, or `undefined` to keep the bare column reference.
+ *
+ * Twin of the `expr` closure `fuz_db::qualify_columns` takes. The Rust side
+ * decodes rows positionally, so its overrides need no output name; TS reads
+ * rows by name, so `columns_sql` / `qualify_columns` alias every override
+ * back to its column (`… AS created_at`) — otherwise a `to_char(…)`
+ * projection would arrive under Postgres' derived name and read as
+ * `undefined`.
+ *
+ * `undefined` is the *only* decline sentinel. An empty string is a returned
+ * expression, not a decline: it renders ` AS created_at` and the query fails
+ * to parse. This is documented rather than guarded — every override in the
+ * repo is a literal lookup returning a fragment or nothing, and a malformed
+ * projection failing loud at the first query beats silently swallowing an
+ * expression the caller meant to supply.
+ */
+export type ColumnExpr = (column: string) => string | undefined;
+/**
+ * Build a `to_char({alias}.{column} AT TIME ZONE 'UTC',
+ * 'YYYY-MM-DD"T"HH24:MI:SS"Z"')` fragment for embedding in a SELECT
+ * projection, via a `ColumnExpr` override.
+ *
+ * The format literal is the spine's canonical timestamp wire shape —
+ * second-precision UTC ISO-8601, exactly 20 characters — byte-identical to
+ * `fuz_db::iso8601_timestamp_column`, so the two backends serialize the same
+ * instant to the same bytes. `to_iso8601_seconds` (`timestamp.ts`) is the
+ * same shape for stamps minted in TS rather than read from Postgres.
+ *
+ * @param alias - the table alias or name to qualify the column with, or the
+ *   empty string for an unqualified reference
+ * @param column - the timestamp column name
+ * @returns the `to_char(…)` fragment
+ */
+export declare const iso8601_timestamp_column: (alias: string, column: string) => string;
+/**
+ * Build a table's timestamp override: a `ColumnExpr` factory that projects
+ * each of `timestamp_columns` through `iso8601_timestamp_column` and declines
+ * every other column. The result takes the row qualifier — the empty string
+ * for a bare-table read, the alias for a JOIN — so one definition per query
+ * module serves every read in it.
+ *
+ * `timestamp_columns` is typed against `columns` (and checked at build time),
+ * so a misspelled name is a compile error and a stale one throws at module
+ * load rather than silently leaving a column projected as a `Date`.
+ *
+ * @param columns - the table's `*_COLUMNS` const
+ * @param timestamp_columns - the members of `columns` that carry timestamps
+ * @returns `(alias) => ColumnExpr`
+ * @throws Error when a name in `timestamp_columns` is not in `columns`
+ */
+export declare const iso8601_timestamp_expr: <T extends string>(columns: ReadonlyArray<T>, timestamp_columns: ReadonlyArray<NoInfer<T>>) => ((alias: string) => ColumnExpr);
+/**
+ * Render a `*_COLUMNS` const as a SQL select list, in projection order.
+ *
+ * @param columns - the column names
+ * @param expr - optional per-column expression override; an overridden
+ *   column is aliased back to its own name
+ * @returns `a, b, c`
+ */
+export declare const columns_sql: (columns: ReadonlyArray<string>, expr?: ColumnExpr) => string;
+/**
+ * Render a `*_COLUMNS` const as a SQL select list with every column qualified
+ * by a table alias, for reads that alias the table (JOINs, the `c`-aliased
+ * `cell_list` scan).
+ *
+ * The alias is interpolated into SQL, so it must be a plain identifier —
+ * every in-repo call passes a literal, but a consumer threading a computed
+ * alias through gets a thrown error instead of a malformed (or injectable)
+ * projection.
+ *
+ * **An `expr` override costs one rule: an `ORDER BY` in a projected SELECT
+ * must qualify its column.** An override is aliased back to its own name
+ * (`… AS created_at`), and Postgres resolves a bare `ORDER BY created_at`
+ * against the *output* names first, so it would sort on the `to_char(…)`
+ * text — collapsing sub-second order into ties and losing the btree index (a
+ * `Sort` node over the expression instead of an `Index Scan`). Writing
+ * `ORDER BY <alias>.created_at` (or `<table>.created_at`) names the input
+ * column and both go away. The Rust twin needs no such rule: it decodes
+ * positionally, so `fuz_db::qualify_columns` emits no alias and its bare
+ * `ORDER BY created_at` already means the column.
+ *
+ * @param columns - the column names
+ * @param alias - the table alias or name to prefix each column with
+ * @param expr - optional per-column expression override; an overridden
+ *   column is aliased back to its own name
+ * @returns `alias.a, alias.b, alias.c`
+ * @throws Error when `alias` is not a valid SQL identifier
+ */
+export declare const qualify_columns: (columns: ReadonlyArray<string>, alias: string, expr?: ColumnExpr) => string;
+/**
+ * Drop named columns from a `*_COLUMNS` const, preserving projection order —
+ * for a read that deliberately narrows the row (a client-safe listing, a
+ * metadata read that skips a payload column).
+ *
+ * With an `as const` column array the omitted names are checked at compile
+ * time; the runtime check covers plain `string[]` consts (a consumer's).
+ *
+ * @param columns - the column names
+ * @param omitted - column names to leave out
+ * @returns the columns without the omitted ones, in projection order
+ * @throws Error when an omitted name isn't in the list — a typo here would
+ *   silently keep the column it meant to hide
+ */
+export declare const omit_columns: <T extends string>(columns: ReadonlyArray<T>, ...omitted: Array<NoInfer<T>>) => ReadonlyArray<T>;
+//# sourceMappingURL=sql_columns.d.ts.map

package/dist/db/sql_columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql_columns.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/sql_columns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAEhE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAG,MAGS,CAAC;AAEnF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,EACtD,SAAS,aAAa,CAAC,CAAC,CAAC,EACzB,mBAAmB,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAC1C,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,UAAU,CAYhC,CAAC;AAqBF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,aAAa,CAAC,MAAM,CAAC,EAAE,OAAO,UAAU,KAAG,MACvB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,GAC3B,SAAS,aAAa,CAAC,MAAM,CAAC,EAC9B,OAAO,MAAM,EACb,OAAO,UAAU,KACf,MAGF,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,EAC5C,SAAS,aAAa,CAAC,CAAC,CAAC,EACzB,GAAG,SAAS,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAC3B,aAAa,CAAC,CAAC,CAOjB,CAAC"}

package/dist/db/sql_columns.js

@@ -0,0 +1,164 @@
+/**
+ * Helpers for the named-column projection consts (`ACCOUNT_COLUMNS`,
+ * `CELL_COLUMNS`, …) — per-table column-name arrays that every table read
+ * projects through so a dropped or leftover column fails loud instead of
+ * vanishing under `SELECT *`.
+ *
+ * Each query module exports its table's const and derives every projection
+ * it needs from it at the read site — `columns_sql` for single-table reads,
+ * `qualify_columns` for reads that alias the table, `omit_columns` for a
+ * client-safe subset — rather than spelling a second column list, so the
+ * drift guard on the base const (`assert_columns_match_live` in
+ * `testing/db.ts`) covers every derived projection too. Twin of the Rust
+ * spine's `*_COLUMNS` consts + `fuz_db::qualify_columns` / `omit_columns`.
+ *
+ * A read that needs a column rendered as something other than the bare
+ * reference passes a `ColumnExpr` — the `expr` override, twin of the third
+ * argument to `fuz_db::qualify_columns`. Every timestamp that reaches the
+ * wire projects through `iso8601_timestamp_column` so both spines serialize
+ * the same instant to the same bytes; each query module builds its override
+ * with `iso8601_timestamp_expr` over its table const. An override costs one
+ * rule — a projected `ORDER BY` must qualify its column — stated on
+ * `qualify_columns`.
+ *
+ * Placement rule: a const lives in its table's query module. When two query
+ * modules project the same table (the revoke cascades in
+ * `auth/role_grant_queries.ts` supersede `role_grant_offer` rows while the
+ * offer module's accept path writes `role_grant` rows), it lives in the
+ * table's `*_ddl.ts` instead — the module both already import — so the query
+ * modules stay acyclic.
+ *
+ * Column arrays are literal consts; the alias passed to `qualify_columns` is
+ * the only input these helpers treat as dynamic (and validate). Each const
+ * also carries `satisfies ReadonlyArray<keyof Row>` so a column name the row
+ * type doesn't know is a compile error.
+ *
+ * @module
+ */
+import { assert_valid_sql_identifier } from './sql_identifier.js';
+/**
+ * Build a `to_char({alias}.{column} AT TIME ZONE 'UTC',
+ * 'YYYY-MM-DD"T"HH24:MI:SS"Z"')` fragment for embedding in a SELECT
+ * projection, via a `ColumnExpr` override.
+ *
+ * The format literal is the spine's canonical timestamp wire shape —
+ * second-precision UTC ISO-8601, exactly 20 characters — byte-identical to
+ * `fuz_db::iso8601_timestamp_column`, so the two backends serialize the same
+ * instant to the same bytes. `to_iso8601_seconds` (`timestamp.ts`) is the
+ * same shape for stamps minted in TS rather than read from Postgres.
+ *
+ * @param alias - the table alias or name to qualify the column with, or the
+ *   empty string for an unqualified reference
+ * @param column - the timestamp column name
+ * @returns the `to_char(…)` fragment
+ */
+export const iso8601_timestamp_column = (alias, column) => alias === ''
+    ? `to_char(${column} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')`
+    : `to_char(${alias}.${column} AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS"Z"')`;
+/**
+ * Build a table's timestamp override: a `ColumnExpr` factory that projects
+ * each of `timestamp_columns` through `iso8601_timestamp_column` and declines
+ * every other column. The result takes the row qualifier — the empty string
+ * for a bare-table read, the alias for a JOIN — so one definition per query
+ * module serves every read in it.
+ *
+ * `timestamp_columns` is typed against `columns` (and checked at build time),
+ * so a misspelled name is a compile error and a stale one throws at module
+ * load rather than silently leaving a column projected as a `Date`.
+ *
+ * @param columns - the table's `*_COLUMNS` const
+ * @param timestamp_columns - the members of `columns` that carry timestamps
+ * @returns `(alias) => ColumnExpr`
+ * @throws Error when a name in `timestamp_columns` is not in `columns`
+ */
+export const iso8601_timestamp_expr = (columns, timestamp_columns) => {
+    for (const t of timestamp_columns) {
+        if (!columns.includes(t)) {
+            throw new Error(`iso8601_timestamp_expr: "${t}" is not in the column list "${columns.join(', ')}"`);
+        }
+    }
+    return (alias) => (column) => timestamp_columns.includes(column)
+        ? iso8601_timestamp_column(alias, column)
+        : undefined;
+};
+/**
+ * Render one projection entry — the `expr` override aliased back to its
+ * column name, or `fallback` when the override declines the column
+ * (`undefined`, and only `undefined` — see `ColumnExpr`).
+ *
+ * The alias this adds is what makes the `ORDER BY` rule on `qualify_columns`
+ * necessary.
+ *
+ * @param column - the column name, and the output name an override is aliased to
+ * @param fallback - what to project when the override declines — the bare
+ *   column, or the alias-qualified reference
+ * @param expr - the per-column expression override, if the read has one
+ * @returns the projection entry, `<expr> AS <column>` or `fallback`
+ */
+const render_column = (column, fallback, expr) => {
+    const override = expr?.(column);
+    return override === undefined ? fallback : `${override} AS ${column}`;
+};
+/**
+ * Render a `*_COLUMNS` const as a SQL select list, in projection order.
+ *
+ * @param columns - the column names
+ * @param expr - optional per-column expression override; an overridden
+ *   column is aliased back to its own name
+ * @returns `a, b, c`
+ */
+export const columns_sql = (columns, expr) => columns.map((c) => render_column(c, c, expr)).join(', ');
+/**
+ * Render a `*_COLUMNS` const as a SQL select list with every column qualified
+ * by a table alias, for reads that alias the table (JOINs, the `c`-aliased
+ * `cell_list` scan).
+ *
+ * The alias is interpolated into SQL, so it must be a plain identifier —
+ * every in-repo call passes a literal, but a consumer threading a computed
+ * alias through gets a thrown error instead of a malformed (or injectable)
+ * projection.
+ *
+ * **An `expr` override costs one rule: an `ORDER BY` in a projected SELECT
+ * must qualify its column.** An override is aliased back to its own name
+ * (`… AS created_at`), and Postgres resolves a bare `ORDER BY created_at`
+ * against the *output* names first, so it would sort on the `to_char(…)`
+ * text — collapsing sub-second order into ties and losing the btree index (a
+ * `Sort` node over the expression instead of an `Index Scan`). Writing
+ * `ORDER BY <alias>.created_at` (or `<table>.created_at`) names the input
+ * column and both go away. The Rust twin needs no such rule: it decodes
+ * positionally, so `fuz_db::qualify_columns` emits no alias and its bare
+ * `ORDER BY created_at` already means the column.
+ *
+ * @param columns - the column names
+ * @param alias - the table alias or name to prefix each column with
+ * @param expr - optional per-column expression override; an overridden
+ *   column is aliased back to its own name
+ * @returns `alias.a, alias.b, alias.c`
+ * @throws Error when `alias` is not a valid SQL identifier
+ */
+export const qualify_columns = (columns, alias, expr) => {
+    assert_valid_sql_identifier(alias);
+    return columns.map((c) => render_column(c, `${alias}.${c}`, expr)).join(', ');
+};
+/**
+ * Drop named columns from a `*_COLUMNS` const, preserving projection order —
+ * for a read that deliberately narrows the row (a client-safe listing, a
+ * metadata read that skips a payload column).
+ *
+ * With an `as const` column array the omitted names are checked at compile
+ * time; the runtime check covers plain `string[]` consts (a consumer's).
+ *
+ * @param columns - the column names
+ * @param omitted - column names to leave out
+ * @returns the columns without the omitted ones, in projection order
+ * @throws Error when an omitted name isn't in the list — a typo here would
+ *   silently keep the column it meant to hide
+ */
+export const omit_columns = (columns, ...omitted) => {
+    for (const o of omitted) {
+        if (!columns.includes(o)) {
+            throw new Error(`omit_columns: "${o}" is not in the column list "${columns.join(', ')}"`);
+        }
+    }
+    return columns.filter((c) => !omitted.includes(c));
+};

package/dist/db/sql_identifier.d.ts

@@ -1,10 +1,11 @@
 /**
- * SQL identifier validation for dynamic DDL queries.
+ * SQL identifier validation for the places an identifier must be
+ * interpolated rather than parameterized.
  *
- * PostgreSQL DDL operations (DROP TABLE, TRUNCATE, ALTER) do not support
- * parameterized table/column names — only values can be parameterized.
- * This validator ensures identifiers are safe for string interpolation
- * in those specific cases.
+ * PostgreSQL parameterizes values only — table and column names in DDL
+ * (DROP TABLE, TRUNCATE, ALTER) and the alias `qualify_columns` prefixes
+ * onto a projection (`db/sql_columns.ts`) have to be string-interpolated.
+ * This validator ensures such identifiers are safe to interpolate.
  *
  * @module
  */

package/dist/db/sql_identifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql_identifier.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/sql_identifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAA6B,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,MAAM,KAAG,MAK1D,CAAC"}
+{"version":3,"file":"sql_identifier.d.ts","sourceRoot":"../src/lib/","sources":["../../src/lib/db/sql_identifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAA6B,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,2BAA2B,GAAI,MAAM,MAAM,KAAG,MAK1D,CAAC"}